2 This file is part of systemd.
4 Copyright 2013 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
30 #include "alloc-util.h"
31 #include "bus-container.h"
32 #include "bus-control.h"
33 #include "bus-internal.h"
34 #include "bus-kernel.h"
35 #include "bus-label.h"
36 #include "bus-message.h"
37 #include "bus-objects.h"
38 #include "bus-protocol.h"
40 #include "bus-socket.h"
41 #include "bus-track.h"
44 #include "cgroup-util.h"
47 #include "hexdecoct.h"
48 #include "hostname-util.h"
51 #include "parse-util.h"
52 #include "string-util.h"
56 #define log_debug_bus_message(m) \
58 sd_bus_message *_mm = (m); \
59 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
60 bus_message_type_to_string(_mm->header->type), \
61 strna(sd_bus_message_get_sender(_mm)), \
62 strna(sd_bus_message_get_destination(_mm)), \
63 strna(sd_bus_message_get_path(_mm)), \
64 strna(sd_bus_message_get_interface(_mm)), \
65 strna(sd_bus_message_get_member(_mm)), \
66 BUS_MESSAGE_COOKIE(_mm), \
68 strna(_mm->error.message)); \
71 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
72 static int attach_io_events(sd_bus
*b
);
73 static void detach_io_events(sd_bus
*b
);
75 static thread_local sd_bus
*default_system_bus
= NULL
;
76 static thread_local sd_bus
*default_user_bus
= NULL
;
77 static thread_local sd_bus
*default_starter_bus
= NULL
;
79 static void bus_close_fds(sd_bus
*b
) {
84 if (b
->input_fd
!= b
->output_fd
)
85 safe_close(b
->output_fd
);
86 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
89 static void bus_reset_queues(sd_bus
*b
) {
92 while (b
->rqueue_size
> 0)
93 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
95 b
->rqueue
= mfree(b
->rqueue
);
96 b
->rqueue_allocated
= 0;
98 while (b
->wqueue_size
> 0)
99 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
101 b
->wqueue
= mfree(b
->wqueue
);
102 b
->wqueue_allocated
= 0;
105 static void bus_free(sd_bus
*b
) {
109 assert(!b
->track_queue
);
112 b
->state
= BUS_CLOSED
;
114 sd_bus_detach_event(b
);
116 while ((s
= b
->slots
)) {
117 /* At this point only floating slots can still be
118 * around, because the non-floating ones keep a
119 * reference to the bus, and we thus couldn't be
120 * destructing right now... We forcibly disconnect the
121 * slots here, so that they still can be referenced by
122 * apps, but are dead. */
125 bus_slot_disconnect(s
);
126 sd_bus_slot_unref(s
);
129 if (b
->default_bus_ptr
)
130 *b
->default_bus_ptr
= NULL
;
136 free(b
->unique_name
);
137 free(b
->auth_buffer
);
140 free(b
->cgroup_root
);
141 free(b
->description
);
144 strv_free(b
->exec_argv
);
146 close_many(b
->fds
, b
->n_fds
);
151 ordered_hashmap_free_free(b
->reply_callbacks
);
152 prioq_free(b
->reply_callbacks_prioq
);
154 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
155 bus_match_free(&b
->match_callbacks
);
157 hashmap_free_free(b
->vtable_methods
);
158 hashmap_free_free(b
->vtable_properties
);
160 assert(hashmap_isempty(b
->nodes
));
161 hashmap_free(b
->nodes
);
165 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
170 _public_
int sd_bus_new(sd_bus
**ret
) {
173 assert_return(ret
, -EINVAL
);
179 r
->n_ref
= REFCNT_INIT
;
180 r
->input_fd
= r
->output_fd
= -1;
181 r
->message_version
= 1;
182 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
183 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
184 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
185 r
->original_pid
= getpid_cached();
187 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
189 /* We guarantee that wqueue always has space for at least one
191 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
200 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
203 assert_return(bus
, -EINVAL
);
204 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
205 assert_return(address
, -EINVAL
);
206 assert_return(!bus_pid_changed(bus
), -ECHILD
);
218 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
219 assert_return(bus
, -EINVAL
);
220 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
221 assert_return(input_fd
>= 0, -EBADF
);
222 assert_return(output_fd
>= 0, -EBADF
);
223 assert_return(!bus_pid_changed(bus
), -ECHILD
);
225 bus
->input_fd
= input_fd
;
226 bus
->output_fd
= output_fd
;
230 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
233 assert_return(bus
, -EINVAL
);
234 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
235 assert_return(path
, -EINVAL
);
236 assert_return(!strv_isempty(argv
), -EINVAL
);
237 assert_return(!bus_pid_changed(bus
), -ECHILD
);
249 free(bus
->exec_path
);
250 strv_free(bus
->exec_argv
);
258 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
259 assert_return(bus
, -EINVAL
);
260 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
261 assert_return(!bus_pid_changed(bus
), -ECHILD
);
263 bus
->bus_client
= !!b
;
267 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
268 assert_return(bus
, -EINVAL
);
269 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
270 assert_return(!bus_pid_changed(bus
), -ECHILD
);
272 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
276 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
277 assert_return(bus
, -EINVAL
);
278 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
279 assert_return(!bus_pid_changed(bus
), -ECHILD
);
281 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
285 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
287 assert_return(bus
, -EINVAL
);
288 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
289 assert_return(!bus_pid_changed(bus
), -ECHILD
);
291 new_flags
= bus
->attach_flags
;
292 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
294 if (bus
->attach_flags
== new_flags
)
297 bus
->attach_flags
= new_flags
;
302 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
305 assert_return(bus
, -EINVAL
);
306 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
307 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
308 assert_return(!bus_pid_changed(bus
), -ECHILD
);
310 SET_FLAG(bus
->creds_mask
, mask
, b
);
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
;
325 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
326 assert_return(bus
, -EINVAL
);
327 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
328 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
329 assert_return(!bus_pid_changed(bus
), -ECHILD
);
331 bus
->is_server
= !!b
;
332 bus
->server_id
= server_id
;
336 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
337 assert_return(bus
, -EINVAL
);
338 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
339 assert_return(!bus_pid_changed(bus
), -ECHILD
);
341 bus
->anonymous_auth
= !!b
;
345 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
346 assert_return(bus
, -EINVAL
);
347 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
348 assert_return(!bus_pid_changed(bus
), -ECHILD
);
354 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
355 assert_return(bus
, -EINVAL
);
356 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
357 assert_return(!bus_pid_changed(bus
), -ECHILD
);
359 return free_and_strdup(&bus
->description
, description
);
362 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
363 assert_return(bus
, -EINVAL
);
364 assert_return(!bus_pid_changed(bus
), -ECHILD
);
366 bus
->allow_interactive_authorization
= !!b
;
370 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
371 assert_return(bus
, -EINVAL
);
372 assert_return(!bus_pid_changed(bus
), -ECHILD
);
374 return bus
->allow_interactive_authorization
;
377 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
385 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
387 r
= sd_bus_message_get_errno(reply
);
391 r
= sd_bus_message_read(reply
, "s", &s
);
395 if (!service_name_is_valid(s
) || s
[0] != ':')
398 bus
->unique_name
= strdup(s
);
399 if (!bus
->unique_name
)
402 if (bus
->state
== BUS_HELLO
)
403 bus
->state
= BUS_RUNNING
;
408 static int bus_send_hello(sd_bus
*bus
) {
409 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
414 if (!bus
->bus_client
)
417 r
= sd_bus_message_new_method_call(
420 "org.freedesktop.DBus",
421 "/org/freedesktop/DBus",
422 "org.freedesktop.DBus",
427 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
430 int bus_start_running(sd_bus
*bus
) {
433 if (bus
->bus_client
) {
434 bus
->state
= BUS_HELLO
;
438 bus
->state
= BUS_RUNNING
;
442 static int parse_address_key(const char **p
, const char *key
, char **value
) {
443 size_t l
, n
= 0, allocated
= 0;
453 if (strncmp(*p
, key
, l
) != 0)
466 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
484 c
= (char) ((x
<< 4) | y
);
491 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
515 static void skip_address_key(const char **p
) {
519 *p
+= strcspn(*p
, ",");
525 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
526 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
535 while (**p
!= 0 && **p
!= ';') {
536 r
= parse_address_key(p
, "guid", guid
);
542 r
= parse_address_key(p
, "path", &path
);
548 r
= parse_address_key(p
, "abstract", &abstract
);
557 if (!path
&& !abstract
)
560 if (path
&& abstract
)
565 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
568 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
569 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
570 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
571 } else if (abstract
) {
572 l
= strlen(abstract
);
573 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
576 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
577 b
->sockaddr
.un
.sun_path
[0] = 0;
578 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
579 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
);
656 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
658 unsigned n_argv
= 0, j
;
660 size_t allocated
= 0;
668 while (**p
!= 0 && **p
!= ';') {
669 r
= parse_address_key(p
, "guid", guid
);
675 r
= parse_address_key(p
, "path", &path
);
681 if (startswith(*p
, "argv")) {
685 ul
= strtoul(*p
+ 4, (char**) p
, 10);
686 if (errno
> 0 || **p
!= '=' || ul
> 256) {
694 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
702 r
= parse_address_key(p
, NULL
, argv
+ ul
);
717 /* Make sure there are no holes in the array, with the
718 * exception of argv[0] */
719 for (j
= 1; j
< n_argv
; j
++)
725 if (argv
&& argv
[0] == NULL
) {
726 argv
[0] = strdup(path
);
741 for (j
= 0; j
< n_argv
; j
++)
749 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
750 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
758 while (**p
!= 0 && **p
!= ';') {
759 r
= parse_address_key(p
, "guid", guid
);
765 r
= parse_address_key(p
, "machine", &machine
);
771 r
= parse_address_key(p
, "pid", &pid
);
780 if (!machine
== !pid
)
784 if (!machine_name_is_valid(machine
))
788 b
->machine
= machine
;
791 b
->machine
= mfree(b
->machine
);
795 r
= parse_pid(pid
, &b
->nspid
);
801 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
802 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
803 b
->sockaddr_size
= SOCKADDR_UN_LEN(b
->sockaddr
.un
);
809 static void bus_reset_parsed_address(sd_bus
*b
) {
813 b
->sockaddr_size
= 0;
814 b
->exec_argv
= strv_free(b
->exec_argv
);
815 b
->exec_path
= mfree(b
->exec_path
);
816 b
->server_id
= SD_ID128_NULL
;
817 b
->machine
= mfree(b
->machine
);
821 static int bus_parse_next_address(sd_bus
*b
) {
822 _cleanup_free_
char *guid
= NULL
;
830 if (b
->address
[b
->address_index
] == 0)
833 bus_reset_parsed_address(b
);
835 a
= b
->address
+ b
->address_index
;
844 if (startswith(a
, "unix:")) {
847 r
= parse_unix_address(b
, &a
, &guid
);
852 } else if (startswith(a
, "tcp:")) {
855 r
= parse_tcp_address(b
, &a
, &guid
);
861 } else if (startswith(a
, "unixexec:")) {
864 r
= parse_exec_address(b
, &a
, &guid
);
870 } else if (startswith(a
, "x-machine-unix:")) {
873 r
= parse_container_unix_address(b
, &a
, &guid
);
886 r
= sd_id128_from_string(guid
, &b
->server_id
);
891 b
->address_index
= a
- b
->address
;
895 static int bus_start_address(sd_bus
*b
) {
903 /* If you provide multiple different bus-addresses, we
904 * try all of them in order and use the first one that
908 r
= bus_socket_exec(b
);
910 else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
911 r
= bus_container_connect_socket(b
);
913 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
914 r
= bus_socket_connect(b
);
920 r
= attach_io_events(b
);
925 b
->last_connect_error
= -r
;
928 r
= bus_parse_next_address(b
);
932 return b
->last_connect_error
> 0 ? -b
->last_connect_error
: -ECONNREFUSED
;
936 int bus_next_address(sd_bus
*b
) {
939 bus_reset_parsed_address(b
);
940 return bus_start_address(b
);
943 static int bus_start_fd(sd_bus
*b
) {
948 assert(b
->input_fd
>= 0);
949 assert(b
->output_fd
>= 0);
951 r
= fd_nonblock(b
->input_fd
, true);
955 r
= fd_cloexec(b
->input_fd
, true);
959 if (b
->input_fd
!= b
->output_fd
) {
960 r
= fd_nonblock(b
->output_fd
, true);
964 r
= fd_cloexec(b
->output_fd
, true);
969 if (fstat(b
->input_fd
, &st
) < 0)
972 return bus_socket_take_fd(b
);
975 _public_
int sd_bus_start(sd_bus
*bus
) {
978 assert_return(bus
, -EINVAL
);
979 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
980 assert_return(!bus_pid_changed(bus
), -ECHILD
);
982 bus
->state
= BUS_OPENING
;
984 if (bus
->is_server
&& bus
->bus_client
)
987 if (bus
->input_fd
>= 0)
988 r
= bus_start_fd(bus
);
989 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->machine
)
990 r
= bus_start_address(bus
);
999 return bus_send_hello(bus
);
1002 _public_
int sd_bus_open(sd_bus
**ret
) {
1007 assert_return(ret
, -EINVAL
);
1009 /* Let's connect to the starter bus if it is set, and
1010 * otherwise to the bus that is appropropriate for the scope
1011 * we are running in */
1013 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1015 if (streq(e
, "system"))
1016 return sd_bus_open_system(ret
);
1017 else if (STR_IN_SET(e
, "session", "user"))
1018 return sd_bus_open_user(ret
);
1021 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1023 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1024 return sd_bus_open_user(ret
);
1026 return sd_bus_open_system(ret
);
1033 r
= sd_bus_set_address(b
, e
);
1037 b
->bus_client
= true;
1039 /* We don't know whether the bus is trusted or not, so better
1040 * be safe, and authenticate everything */
1042 b
->is_local
= false;
1043 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1044 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1046 r
= sd_bus_start(b
);
1058 int bus_set_address_system(sd_bus
*b
) {
1062 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1064 return sd_bus_set_address(b
, e
);
1066 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1069 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1073 assert_return(ret
, -EINVAL
);
1079 r
= bus_set_address_system(b
);
1083 b
->bus_client
= true;
1084 b
->is_system
= true;
1086 /* Let's do per-method access control on the system bus. We
1087 * need the caller's UID and capability set for that. */
1089 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1090 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1093 r
= sd_bus_start(b
);
1105 int bus_set_address_user(sd_bus
*b
) {
1107 _cleanup_free_
char *ee
= NULL
, *s
= NULL
;
1111 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1113 return sd_bus_set_address(b
, e
);
1115 e
= secure_getenv("XDG_RUNTIME_DIR");
1119 ee
= bus_address_escape(e
);
1123 if (asprintf(&s
, UNIX_USER_BUS_ADDRESS_FMT
, ee
) < 0)
1132 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1136 assert_return(ret
, -EINVAL
);
1142 r
= bus_set_address_user(b
);
1146 b
->bus_client
= true;
1149 /* We don't do any per-method access control on the user
1154 r
= sd_bus_start(b
);
1166 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1167 _cleanup_free_
char *e
= NULL
;
1168 char *m
= NULL
, *c
= NULL
;
1173 /* Let's see if we shall enter some container */
1174 m
= strchr(host
, ':');
1178 /* Let's make sure this is not a port of some kind,
1179 * and is a valid machine name. */
1180 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1183 /* Cut out the host part */
1184 t
= strndupa(host
, m
- host
- 1);
1185 e
= bus_address_escape(t
);
1189 c
= strjoina(",argv5=--machine=", m
);
1194 e
= bus_address_escape(host
);
1199 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e
, ",argv4=systemd-stdio-bridge", c
);
1206 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1210 assert_return(host
, -EINVAL
);
1211 assert_return(ret
, -EINVAL
);
1213 r
= sd_bus_new(&bus
);
1217 r
= bus_set_address_system_remote(bus
, host
);
1221 bus
->bus_client
= true;
1222 bus
->trusted
= false;
1223 bus
->is_system
= true;
1224 bus
->is_local
= false;
1226 r
= sd_bus_start(bus
);
1238 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1239 _cleanup_free_
char *e
= NULL
;
1244 e
= bus_address_escape(machine
);
1248 b
->address
= strjoin("x-machine-unix:machine=", e
);
1255 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1259 assert_return(machine
, -EINVAL
);
1260 assert_return(ret
, -EINVAL
);
1261 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1263 r
= sd_bus_new(&bus
);
1267 r
= bus_set_address_system_machine(bus
, machine
);
1271 bus
->bus_client
= true;
1272 bus
->trusted
= false;
1273 bus
->is_system
= true;
1274 bus
->is_local
= false;
1276 r
= sd_bus_start(bus
);
1288 _public_
void sd_bus_close(sd_bus
*bus
) {
1292 if (bus
->state
== BUS_CLOSED
)
1294 if (bus_pid_changed(bus
))
1297 bus
->state
= BUS_CLOSED
;
1299 sd_bus_detach_event(bus
);
1301 /* Drop all queued messages so that they drop references to
1302 * the bus object and the bus may be freed */
1303 bus_reset_queues(bus
);
1308 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1316 return sd_bus_unref(bus
);
1319 static void bus_enter_closing(sd_bus
*bus
) {
1322 if (bus
->state
!= BUS_OPENING
&&
1323 bus
->state
!= BUS_AUTHENTICATING
&&
1324 bus
->state
!= BUS_HELLO
&&
1325 bus
->state
!= BUS_RUNNING
)
1328 bus
->state
= BUS_CLOSING
;
1331 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1336 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1341 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1347 i
= REFCNT_DEC(bus
->n_ref
);
1355 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1357 assert_return(bus
, -EINVAL
);
1358 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1360 return BUS_IS_OPEN(bus
->state
);
1363 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1366 assert_return(bus
, -EINVAL
);
1367 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1368 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1370 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1373 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1374 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1377 r
= bus_ensure_running(bus
);
1381 return bus
->can_fds
;
1384 return bus_type_is_valid(type
);
1387 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1390 assert_return(bus
, -EINVAL
);
1391 assert_return(id
, -EINVAL
);
1392 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1394 r
= bus_ensure_running(bus
);
1398 *id
= bus
->server_id
;
1402 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1407 /* If we copy the same message to multiple
1408 * destinations, avoid using the same cookie
1410 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1415 timeout
= BUS_DEFAULT_TIMEOUT
;
1417 return bus_message_seal(m
, ++b
->cookie
, timeout
);
1420 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1421 bool remarshal
= false;
1425 /* wrong packet version */
1426 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1429 /* wrong packet endianness */
1430 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1433 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1436 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1440 /* Fake some timestamps, if they were requested, and not
1441 * already initialized */
1442 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1443 if (m
->realtime
<= 0)
1444 m
->realtime
= now(CLOCK_REALTIME
);
1446 if (m
->monotonic
<= 0)
1447 m
->monotonic
= now(CLOCK_MONOTONIC
);
1450 /* The bus specification says the serial number cannot be 0,
1451 * hence let's fill something in for synthetic messages. Since
1452 * synthetic messages might have a fake sender and we don't
1453 * want to interfere with the real sender's serial numbers we
1454 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1455 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1456 * even though kdbus can do 64bit. */
1457 return bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1460 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1466 r
= bus_socket_write_message(bus
, m
, idx
);
1470 if (*idx
>= BUS_MESSAGE_SIZE(m
))
1471 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
1472 bus_message_type_to_string(m
->header
->type
),
1473 strna(sd_bus_message_get_sender(m
)),
1474 strna(sd_bus_message_get_destination(m
)),
1475 strna(sd_bus_message_get_path(m
)),
1476 strna(sd_bus_message_get_interface(m
)),
1477 strna(sd_bus_message_get_member(m
)),
1478 BUS_MESSAGE_COOKIE(m
),
1480 strna(m
->error
.message
));
1485 static int dispatch_wqueue(sd_bus
*bus
) {
1489 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1491 while (bus
->wqueue_size
> 0) {
1493 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1497 /* Didn't do anything this time */
1499 else if (bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1500 /* Fully written. Let's drop the entry from
1503 * This isn't particularly optimized, but
1504 * well, this is supposed to be our worst-case
1505 * buffer only, and the socket buffer is
1506 * supposed to be our primary buffer, and if
1507 * it got full, then all bets are off
1511 sd_bus_message_unref(bus
->wqueue
[0]);
1512 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1522 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1525 return bus_socket_read_message(bus
);
1528 int bus_rqueue_make_room(sd_bus
*bus
) {
1531 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1534 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1540 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1545 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1547 /* Note that the priority logic is only available on kdbus,
1548 * where the rqueue is unused. We check the rqueue here
1549 * anyway, because it's simple... */
1552 if (bus
->rqueue_size
> 0) {
1553 /* Dispatch a queued message */
1555 *m
= bus
->rqueue
[0];
1557 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1561 /* Try to read a new message */
1562 r
= bus_read_message(bus
, hint_priority
, priority
);
1572 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1573 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1576 assert_return(m
, -EINVAL
);
1581 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1583 if (!BUS_IS_OPEN(bus
->state
))
1587 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1594 /* If the cookie number isn't kept, then we know that no reply
1596 if (!cookie
&& !m
->sealed
)
1597 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1599 r
= bus_seal_message(bus
, m
, 0);
1603 /* Remarshall if we have to. This will possibly unref the
1604 * message and place a replacement in m */
1605 r
= bus_remarshal_message(bus
, &m
);
1609 /* If this is a reply and no reply was requested, then let's
1610 * suppress this, if we can */
1614 if ((bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1617 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1619 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1620 bus_enter_closing(bus
);
1627 if (idx
< BUS_MESSAGE_SIZE(m
)) {
1628 /* Wasn't fully written. So let's remember how
1629 * much was written. Note that the first entry
1630 * of the wqueue array is always allocated so
1631 * that we always can remember how much was
1633 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1634 bus
->wqueue_size
= 1;
1639 /* Just append it to the queue. */
1641 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1644 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1647 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1652 *cookie
= BUS_MESSAGE_COOKIE(m
);
1657 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1658 return bus_send_internal(bus
, m
, cookie
, false);
1661 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1664 assert_return(m
, -EINVAL
);
1669 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1671 if (!BUS_IS_OPEN(bus
->state
))
1674 if (!streq_ptr(m
->destination
, destination
)) {
1679 r
= sd_bus_message_set_destination(m
, destination
);
1684 return sd_bus_send(bus
, m
, cookie
);
1687 static usec_t
calc_elapse(uint64_t usec
) {
1688 if (usec
== (uint64_t) -1)
1691 return now(CLOCK_MONOTONIC
) + usec
;
1694 static int timeout_compare(const void *a
, const void *b
) {
1695 const struct reply_callback
*x
= a
, *y
= b
;
1697 if (x
->timeout
!= 0 && y
->timeout
== 0)
1700 if (x
->timeout
== 0 && y
->timeout
!= 0)
1703 if (x
->timeout
< y
->timeout
)
1706 if (x
->timeout
> y
->timeout
)
1712 _public_
int sd_bus_call_async(
1716 sd_bus_message_handler_t callback
,
1720 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1721 _cleanup_(sd_bus_slot_unrefp
) sd_bus_slot
*s
= NULL
;
1724 assert_return(m
, -EINVAL
);
1725 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1726 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1727 assert_return(callback
, -EINVAL
);
1732 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1734 if (!BUS_IS_OPEN(bus
->state
))
1737 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1741 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1745 r
= bus_seal_message(bus
, m
, usec
);
1749 r
= bus_remarshal_message(bus
, &m
);
1753 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1757 s
->reply_callback
.callback
= callback
;
1759 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1760 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1762 s
->reply_callback
.cookie
= 0;
1766 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1767 if (s
->reply_callback
.timeout
!= 0) {
1768 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1770 s
->reply_callback
.timeout
= 0;
1775 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1786 int bus_ensure_running(sd_bus
*bus
) {
1791 if (bus
->state
== BUS_UNSET
|| bus
->state
== BUS_CLOSED
|| bus
->state
== BUS_CLOSING
)
1793 if (bus
->state
== BUS_RUNNING
)
1797 r
= sd_bus_process(bus
, NULL
);
1800 if (bus
->state
== BUS_RUNNING
)
1805 r
= sd_bus_wait(bus
, (uint64_t) -1);
1811 _public_
int sd_bus_call(
1815 sd_bus_error
*error
,
1816 sd_bus_message
**reply
) {
1818 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1824 bus_assert_return(m
, -EINVAL
, error
);
1825 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
1826 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
1827 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
1832 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
1834 if (!BUS_IS_OPEN(bus
->state
)) {
1839 r
= bus_ensure_running(bus
);
1843 i
= bus
->rqueue_size
;
1845 r
= bus_seal_message(bus
, m
, usec
);
1849 r
= bus_remarshal_message(bus
, &m
);
1853 r
= bus_send_internal(bus
, m
, &cookie
, true);
1857 timeout
= calc_elapse(m
->timeout
);
1862 while (i
< bus
->rqueue_size
) {
1863 sd_bus_message
*incoming
= NULL
;
1865 incoming
= bus
->rqueue
[i
];
1867 if (incoming
->reply_cookie
== cookie
) {
1868 /* Found a match! */
1870 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
1872 log_debug_bus_message(incoming
);
1874 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
1876 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
1880 sd_bus_message_unref(incoming
);
1885 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1886 sd_bus_message_unref(incoming
);
1889 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
1890 r
= sd_bus_error_copy(error
, &incoming
->error
);
1891 sd_bus_message_unref(incoming
);
1898 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
1901 streq(bus
->unique_name
, incoming
->sender
)) {
1903 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
1906 /* Our own message? Somebody is trying
1907 * to send its own client a message,
1908 * let's not dead-lock, let's fail
1911 sd_bus_message_unref(incoming
);
1916 /* Try to read more, right-away */
1920 r
= bus_read_message(bus
, false, 0);
1922 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1923 bus_enter_closing(bus
);
1935 n
= now(CLOCK_MONOTONIC
);
1943 left
= (uint64_t) -1;
1945 r
= bus_poll(bus
, true, left
);
1953 r
= dispatch_wqueue(bus
);
1955 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1956 bus_enter_closing(bus
);
1965 return sd_bus_error_set_errno(error
, r
);
1968 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
1970 assert_return(bus
, -EINVAL
);
1971 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
1972 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1974 return bus
->input_fd
;
1977 _public_
int sd_bus_get_events(sd_bus
*bus
) {
1980 assert_return(bus
, -EINVAL
);
1981 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1983 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
1986 if (bus
->state
== BUS_OPENING
)
1988 else if (bus
->state
== BUS_AUTHENTICATING
) {
1990 if (bus_socket_auth_needs_write(bus
))
1995 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
1996 if (bus
->rqueue_size
<= 0)
1998 if (bus
->wqueue_size
> 0)
2005 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2006 struct reply_callback
*c
;
2008 assert_return(bus
, -EINVAL
);
2009 assert_return(timeout_usec
, -EINVAL
);
2010 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2012 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2015 if (bus
->track_queue
) {
2020 if (bus
->state
== BUS_CLOSING
) {
2025 if (bus
->state
== BUS_AUTHENTICATING
) {
2026 *timeout_usec
= bus
->auth_timeout
;
2030 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2031 *timeout_usec
= (uint64_t) -1;
2035 if (bus
->rqueue_size
> 0) {
2040 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2042 *timeout_usec
= (uint64_t) -1;
2046 if (c
->timeout
== 0) {
2047 *timeout_usec
= (uint64_t) -1;
2051 *timeout_usec
= c
->timeout
;
2055 static int process_timeout(sd_bus
*bus
) {
2056 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2057 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
* m
= NULL
;
2058 struct reply_callback
*c
;
2065 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2069 n
= now(CLOCK_MONOTONIC
);
2073 r
= bus_message_new_synthetic_error(
2076 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2081 r
= bus_seal_synthetic_message(bus
, m
);
2085 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2088 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2091 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2093 bus
->iteration_counter
++;
2095 bus
->current_message
= m
;
2096 bus
->current_slot
= sd_bus_slot_ref(slot
);
2097 bus
->current_handler
= c
->callback
;
2098 bus
->current_userdata
= slot
->userdata
;
2099 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2100 bus
->current_userdata
= NULL
;
2101 bus
->current_handler
= NULL
;
2102 bus
->current_slot
= NULL
;
2103 bus
->current_message
= NULL
;
2105 if (slot
->floating
) {
2106 bus_slot_disconnect(slot
);
2107 sd_bus_slot_unref(slot
);
2110 sd_bus_slot_unref(slot
);
2112 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2115 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2119 if (bus
->state
!= BUS_HELLO
)
2122 /* Let's make sure the first message on the bus is the HELLO
2123 * reply. But note that we don't actually parse the message
2124 * here (we leave that to the usual handling), we just verify
2125 * we don't let any earlier msg through. */
2127 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2128 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2131 if (m
->reply_cookie
!= 1)
2137 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2138 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*synthetic_reply
= NULL
;
2139 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2140 struct reply_callback
*c
;
2147 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2148 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2151 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2154 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2160 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2162 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2164 /* If the reply contained a file descriptor which we
2165 * didn't want we pass an error instead. */
2167 r
= bus_message_new_synthetic_error(
2170 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2175 /* Copy over original timestamp */
2176 synthetic_reply
->realtime
= m
->realtime
;
2177 synthetic_reply
->monotonic
= m
->monotonic
;
2178 synthetic_reply
->seqnum
= m
->seqnum
;
2180 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2184 m
= synthetic_reply
;
2186 r
= sd_bus_message_rewind(m
, true);
2191 if (c
->timeout
!= 0) {
2192 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2196 bus
->current_slot
= sd_bus_slot_ref(slot
);
2197 bus
->current_handler
= c
->callback
;
2198 bus
->current_userdata
= slot
->userdata
;
2199 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2200 bus
->current_userdata
= NULL
;
2201 bus
->current_handler
= NULL
;
2202 bus
->current_slot
= NULL
;
2204 if (slot
->floating
) {
2205 bus_slot_disconnect(slot
);
2206 sd_bus_slot_unref(slot
);
2209 sd_bus_slot_unref(slot
);
2211 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2214 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2215 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2216 struct filter_callback
*l
;
2223 bus
->filter_callbacks_modified
= false;
2225 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2228 if (bus
->filter_callbacks_modified
)
2231 /* Don't run this more than once per iteration */
2232 if (l
->last_iteration
== bus
->iteration_counter
)
2235 l
->last_iteration
= bus
->iteration_counter
;
2237 r
= sd_bus_message_rewind(m
, true);
2241 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2243 bus
->current_slot
= sd_bus_slot_ref(slot
);
2244 bus
->current_handler
= l
->callback
;
2245 bus
->current_userdata
= slot
->userdata
;
2246 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2247 bus
->current_userdata
= NULL
;
2248 bus
->current_handler
= NULL
;
2249 bus
->current_slot
= sd_bus_slot_unref(slot
);
2251 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2257 } while (bus
->filter_callbacks_modified
);
2262 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2269 bus
->match_callbacks_modified
= false;
2271 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2275 } while (bus
->match_callbacks_modified
);
2280 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2281 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2287 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2290 if (bus
->manual_peer_interface
)
2293 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2296 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2299 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2302 if (streq_ptr(m
->member
, "Ping"))
2303 r
= sd_bus_message_new_method_return(m
, &reply
);
2304 else if (streq_ptr(m
->member
, "GetMachineId")) {
2308 r
= sd_id128_get_machine(&id
);
2312 r
= sd_bus_message_new_method_return(m
, &reply
);
2316 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2318 r
= sd_bus_message_new_method_errorf(
2320 SD_BUS_ERROR_UNKNOWN_METHOD
,
2321 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2327 r
= sd_bus_send(bus
, reply
, NULL
);
2334 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2338 /* If we got a message with a file descriptor which we didn't
2339 * want to accept, then let's drop it. How can this even
2340 * happen? For example, when the kernel queues a message into
2341 * an activatable names's queue which allows fds, and then is
2342 * delivered to us later even though we ourselves did not
2345 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2351 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2354 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2355 return 1; /* just eat it up */
2357 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2360 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2366 bus
->current_message
= m
;
2367 bus
->iteration_counter
++;
2369 log_debug_bus_message(m
);
2371 r
= process_hello(bus
, m
);
2375 r
= process_reply(bus
, m
);
2379 r
= process_fd_check(bus
, m
);
2383 r
= process_filter(bus
, m
);
2387 r
= process_match(bus
, m
);
2391 r
= process_builtin(bus
, m
);
2395 r
= bus_process_object(bus
, m
);
2398 bus
->current_message
= NULL
;
2402 static int dispatch_track(sd_bus
*bus
) {
2405 if (!bus
->track_queue
)
2408 bus_track_dispatch(bus
->track_queue
);
2412 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2413 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2417 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2419 r
= process_timeout(bus
);
2423 r
= dispatch_wqueue(bus
);
2427 r
= dispatch_track(bus
);
2431 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2437 r
= process_message(bus
, m
);
2442 r
= sd_bus_message_rewind(m
, true);
2451 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2453 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2454 strna(sd_bus_message_get_sender(m
)),
2455 strna(sd_bus_message_get_path(m
)),
2456 strna(sd_bus_message_get_interface(m
)),
2457 strna(sd_bus_message_get_member(m
)));
2459 r
= sd_bus_reply_method_errorf(
2461 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2462 "Unknown object '%s'.", m
->path
);
2476 static int bus_exit_now(sd_bus
*bus
) {
2479 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2480 * sd_event_exit(), otherwise invokes libc exit(). */
2482 if (bus
->exited
) /* did we already exit? */
2484 if (!bus
->exit_triggered
) /* was the exit condition triggered? */
2486 if (!bus
->exit_on_disconnect
) /* Shall we actually exit on disconnection? */
2489 bus
->exited
= true; /* never exit more than once */
2491 log_debug("Bus connection disconnected, exiting.");
2494 return sd_event_exit(bus
->event
, EXIT_FAILURE
);
2498 assert_not_reached("exit() didn't exit?");
2501 static int process_closing_reply_callback(sd_bus
*bus
, struct reply_callback
*c
) {
2502 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2503 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2510 r
= bus_message_new_synthetic_error(
2513 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2518 r
= bus_seal_synthetic_message(bus
, m
);
2522 if (c
->timeout
!= 0) {
2523 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2527 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2530 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2532 bus
->iteration_counter
++;
2534 bus
->current_message
= m
;
2535 bus
->current_slot
= sd_bus_slot_ref(slot
);
2536 bus
->current_handler
= c
->callback
;
2537 bus
->current_userdata
= slot
->userdata
;
2538 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2539 bus
->current_userdata
= NULL
;
2540 bus
->current_handler
= NULL
;
2541 bus
->current_slot
= NULL
;
2542 bus
->current_message
= NULL
;
2544 if (slot
->floating
) {
2545 bus_slot_disconnect(slot
);
2546 sd_bus_slot_unref(slot
);
2549 sd_bus_slot_unref(slot
);
2551 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2554 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2555 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2556 struct reply_callback
*c
;
2560 assert(bus
->state
== BUS_CLOSING
);
2562 /* First, fail all outstanding method calls */
2563 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2565 return process_closing_reply_callback(bus
, c
);
2567 /* Then, fake-drop all remaining bus tracking references */
2569 bus_track_close(bus
->tracks
);
2573 /* Then, synthesize a Disconnected message */
2574 r
= sd_bus_message_new_signal(
2577 "/org/freedesktop/DBus/Local",
2578 "org.freedesktop.DBus.Local",
2583 bus_message_set_sender_local(bus
, m
);
2585 r
= bus_seal_synthetic_message(bus
, m
);
2591 bus
->current_message
= m
;
2592 bus
->iteration_counter
++;
2594 r
= process_filter(bus
, m
);
2598 r
= process_match(bus
, m
);
2602 /* Nothing else to do, exit now, if the condition holds */
2603 bus
->exit_triggered
= true;
2604 (void) bus_exit_now(bus
);
2614 bus
->current_message
= NULL
;
2619 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2620 BUS_DONT_DESTROY(bus
);
2623 /* Returns 0 when we didn't do anything. This should cause the
2624 * caller to invoke sd_bus_wait() before returning the next
2625 * time. Returns > 0 when we did something, which possibly
2626 * means *ret is filled in with an unprocessed message. */
2628 assert_return(bus
, -EINVAL
);
2629 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2631 /* We don't allow recursively invoking sd_bus_process(). */
2632 assert_return(!bus
->current_message
, -EBUSY
);
2633 assert(!bus
->current_slot
);
2635 switch (bus
->state
) {
2644 r
= bus_socket_process_opening(bus
);
2645 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2646 bus_enter_closing(bus
);
2654 case BUS_AUTHENTICATING
:
2655 r
= bus_socket_process_authenticating(bus
);
2656 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2657 bus_enter_closing(bus
);
2669 r
= process_running(bus
, hint_priority
, priority
, ret
);
2670 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2671 bus_enter_closing(bus
);
2681 return process_closing(bus
, ret
);
2684 assert_not_reached("Unknown state");
2687 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2688 return bus_process_internal(bus
, false, 0, ret
);
2691 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2692 return bus_process_internal(bus
, true, priority
, ret
);
2695 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2696 struct pollfd p
[2] = {};
2699 usec_t m
= USEC_INFINITY
;
2703 if (bus
->state
== BUS_CLOSING
)
2706 if (!BUS_IS_OPEN(bus
->state
))
2709 e
= sd_bus_get_events(bus
);
2714 /* The caller really needs some more data, he doesn't
2715 * care about what's already read, or any timeouts
2716 * except its own. */
2720 /* The caller wants to process if there's something to
2721 * process, but doesn't care otherwise */
2723 r
= sd_bus_get_timeout(bus
, &until
);
2728 nw
= now(CLOCK_MONOTONIC
);
2729 m
= until
> nw
? until
- nw
: 0;
2733 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2736 p
[0].fd
= bus
->input_fd
;
2737 if (bus
->output_fd
== bus
->input_fd
) {
2741 p
[0].events
= e
& POLLIN
;
2742 p
[1].fd
= bus
->output_fd
;
2743 p
[1].events
= e
& POLLOUT
;
2747 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2751 return r
> 0 ? 1 : 0;
2754 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2756 assert_return(bus
, -EINVAL
);
2757 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2759 if (bus
->state
== BUS_CLOSING
)
2762 if (!BUS_IS_OPEN(bus
->state
))
2765 if (bus
->rqueue_size
> 0)
2768 return bus_poll(bus
, false, timeout_usec
);
2771 _public_
int sd_bus_flush(sd_bus
*bus
) {
2774 assert_return(bus
, -EINVAL
);
2775 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2777 if (bus
->state
== BUS_CLOSING
)
2780 if (!BUS_IS_OPEN(bus
->state
))
2783 r
= bus_ensure_running(bus
);
2787 if (bus
->wqueue_size
<= 0)
2791 r
= dispatch_wqueue(bus
);
2793 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2794 bus_enter_closing(bus
);
2801 if (bus
->wqueue_size
<= 0)
2804 r
= bus_poll(bus
, false, (uint64_t) -1);
2810 _public_
int sd_bus_add_filter(
2813 sd_bus_message_handler_t callback
,
2818 assert_return(bus
, -EINVAL
);
2819 assert_return(callback
, -EINVAL
);
2820 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2822 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2826 s
->filter_callback
.callback
= callback
;
2828 bus
->filter_callbacks_modified
= true;
2829 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2837 _public_
int sd_bus_add_match(
2841 sd_bus_message_handler_t callback
,
2844 struct bus_match_component
*components
= NULL
;
2845 unsigned n_components
= 0;
2846 sd_bus_slot
*s
= NULL
;
2849 assert_return(bus
, -EINVAL
);
2850 assert_return(match
, -EINVAL
);
2851 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2853 r
= bus_match_parse(match
, &components
, &n_components
);
2857 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2863 s
->match_callback
.callback
= callback
;
2864 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2866 if (bus
->bus_client
) {
2867 enum bus_match_scope scope
;
2869 scope
= bus_match_get_scope(components
, n_components
);
2871 /* Do not install server-side matches for matches
2872 * against the local service, interface or bus path. */
2873 if (scope
!= BUS_MATCH_LOCAL
) {
2875 /* We store the original match string, so that
2876 * we can use it to remove the match again. */
2878 s
->match_callback
.match_string
= strdup(match
);
2879 if (!s
->match_callback
.match_string
) {
2884 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
2888 s
->match_added
= true;
2892 bus
->match_callbacks_modified
= true;
2893 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2902 bus_match_parse_free(components
, n_components
);
2903 sd_bus_slot_unref(s
);
2908 int bus_remove_match_by_string(
2911 sd_bus_message_handler_t callback
,
2914 struct bus_match_component
*components
= NULL
;
2915 unsigned n_components
= 0;
2916 struct match_callback
*c
;
2919 assert_return(bus
, -EINVAL
);
2920 assert_return(match
, -EINVAL
);
2921 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2923 r
= bus_match_parse(match
, &components
, &n_components
);
2927 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
2931 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
2934 bus_match_parse_free(components
, n_components
);
2939 bool bus_pid_changed(sd_bus
*bus
) {
2942 /* We don't support people creating a bus connection and
2943 * keeping it around over a fork(). Let's complain. */
2945 return bus
->original_pid
!= getpid_cached();
2948 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
2949 sd_bus
*bus
= userdata
;
2954 r
= sd_bus_process(bus
, NULL
);
2961 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
2962 sd_bus
*bus
= userdata
;
2967 r
= sd_bus_process(bus
, NULL
);
2974 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
2975 sd_bus
*bus
= userdata
;
2982 e
= sd_bus_get_events(bus
);
2986 if (bus
->output_fd
!= bus
->input_fd
) {
2988 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
2992 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
2996 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3001 r
= sd_bus_get_timeout(bus
, &until
);
3007 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3012 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3019 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3020 sd_bus
*bus
= userdata
;
3030 static int attach_io_events(sd_bus
*bus
) {
3035 if (bus
->input_fd
< 0)
3041 if (!bus
->input_io_event_source
) {
3042 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3046 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3050 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3054 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3056 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3061 if (bus
->output_fd
!= bus
->input_fd
) {
3062 assert(bus
->output_fd
>= 0);
3064 if (!bus
->output_io_event_source
) {
3065 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3069 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3073 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3075 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3084 static void detach_io_events(sd_bus
*bus
) {
3087 if (bus
->input_io_event_source
) {
3088 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3089 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3092 if (bus
->output_io_event_source
) {
3093 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3094 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3098 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3101 assert_return(bus
, -EINVAL
);
3102 assert_return(!bus
->event
, -EBUSY
);
3104 assert(!bus
->input_io_event_source
);
3105 assert(!bus
->output_io_event_source
);
3106 assert(!bus
->time_event_source
);
3109 bus
->event
= sd_event_ref(event
);
3111 r
= sd_event_default(&bus
->event
);
3116 bus
->event_priority
= priority
;
3118 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3122 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3126 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3130 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3134 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3138 r
= attach_io_events(bus
);
3145 sd_bus_detach_event(bus
);
3149 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3150 assert_return(bus
, -EINVAL
);
3155 detach_io_events(bus
);
3157 if (bus
->time_event_source
) {
3158 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3159 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3162 if (bus
->quit_event_source
) {
3163 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3164 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3167 bus
->event
= sd_event_unref(bus
->event
);
3171 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3172 assert_return(bus
, NULL
);
3177 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3178 assert_return(bus
, NULL
);
3180 return bus
->current_message
;
3183 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3184 assert_return(bus
, NULL
);
3186 return bus
->current_slot
;
3189 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3190 assert_return(bus
, NULL
);
3192 return bus
->current_handler
;
3195 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3196 assert_return(bus
, NULL
);
3198 return bus
->current_userdata
;
3201 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3206 assert(default_bus
);
3209 return !!*default_bus
;
3212 *ret
= sd_bus_ref(*default_bus
);
3220 b
->default_bus_ptr
= default_bus
;
3228 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3229 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3233 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3234 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3237 _public_
int sd_bus_default(sd_bus
**ret
) {
3241 /* Let's try our best to reuse another cached connection. If
3242 * the starter bus type is set, connect via our normal
3243 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3244 * we can share the connection with the user/system default
3247 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3249 if (streq(e
, "system"))
3250 return sd_bus_default_system(ret
);
3251 else if (STR_IN_SET(e
, "user", "session"))
3252 return sd_bus_default_user(ret
);
3255 /* No type is specified, so we have not other option than to
3256 * use the starter address if it is set. */
3258 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3261 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3264 /* Finally, if nothing is set use the cached connection for
3265 * the right scope */
3267 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3268 return sd_bus_default_user(ret
);
3270 return sd_bus_default_system(ret
);
3273 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3274 assert_return(b
, -EINVAL
);
3275 assert_return(tid
, -EINVAL
);
3276 assert_return(!bus_pid_changed(b
), -ECHILD
);
3284 return sd_event_get_tid(b
->event
, tid
);
3289 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3290 _cleanup_free_
char *e
= NULL
;
3293 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3294 assert_return(external_id
, -EINVAL
);
3295 assert_return(ret_path
, -EINVAL
);
3297 e
= bus_label_escape(external_id
);
3301 ret
= strjoin(prefix
, "/", e
);
3309 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3313 assert_return(object_path_is_valid(path
), -EINVAL
);
3314 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3315 assert_return(external_id
, -EINVAL
);
3317 e
= object_path_startswith(path
, prefix
);
3319 *external_id
= NULL
;
3323 ret
= bus_label_unescape(e
);
3331 _public_
int sd_bus_path_encode_many(char **out
, const char *path_template
, ...) {
3332 _cleanup_strv_free_
char **labels
= NULL
;
3333 char *path
, *path_pos
, **label_pos
;
3334 const char *sep
, *template_pos
;
3339 assert_return(out
, -EINVAL
);
3340 assert_return(path_template
, -EINVAL
);
3342 path_length
= strlen(path_template
);
3344 va_start(list
, path_template
);
3345 for (sep
= strchr(path_template
, '%'); sep
; sep
= strchr(sep
+ 1, '%')) {
3349 arg
= va_arg(list
, const char *);
3355 label
= bus_label_escape(arg
);
3361 r
= strv_consume(&labels
, label
);
3367 /* add label length, but account for the format character */
3368 path_length
+= strlen(label
) - 1;
3372 path
= malloc(path_length
+ 1);
3379 for (template_pos
= path_template
; *template_pos
; ) {
3380 sep
= strchrnul(template_pos
, '%');
3381 path_pos
= mempcpy(path_pos
, template_pos
, sep
- template_pos
);
3385 path_pos
= stpcpy(path_pos
, *label_pos
++);
3386 template_pos
= sep
+ 1;
3394 _public_
int sd_bus_path_decode_many(const char *path
, const char *path_template
, ...) {
3395 _cleanup_strv_free_
char **labels
= NULL
;
3396 const char *template_pos
, *path_pos
;
3402 * This decodes an object-path based on a template argument. The
3403 * template consists of a verbatim path, optionally including special
3406 * - Each occurrence of '%' in the template matches an arbitrary
3407 * substring of a label in the given path. At most one such
3408 * directive is allowed per label. For each such directive, the
3409 * caller must provide an output parameter (char **) via va_arg. If
3410 * NULL is passed, the given label is verified, but not returned.
3411 * For each matched label, the *decoded* label is stored in the
3412 * passed output argument, and the caller is responsible to free
3413 * it. Note that the output arguments are only modified if the
3414 * actualy path matched the template. Otherwise, they're left
3417 * This function returns <0 on error, 0 if the path does not match the
3418 * template, 1 if it matched.
3421 assert_return(path
, -EINVAL
);
3422 assert_return(path_template
, -EINVAL
);
3426 for (template_pos
= path_template
; *template_pos
; ) {
3431 /* verify everything until the next '%' matches verbatim */
3432 sep
= strchrnul(template_pos
, '%');
3433 length
= sep
- template_pos
;
3434 if (strncmp(path_pos
, template_pos
, length
))
3438 template_pos
+= length
;
3443 /* We found the next '%' character. Everything up until here
3444 * matched. We now skip ahead to the end of this label and make
3445 * sure it matches the tail of the label in the path. Then we
3446 * decode the string in-between and save it for later use. */
3448 ++template_pos
; /* skip over '%' */
3450 sep
= strchrnul(template_pos
, '/');
3451 length
= sep
- template_pos
; /* length of suffix to match verbatim */
3453 /* verify the suffixes match */
3454 sep
= strchrnul(path_pos
, '/');
3455 if (sep
- path_pos
< (ssize_t
)length
||
3456 strncmp(sep
- length
, template_pos
, length
))
3459 template_pos
+= length
; /* skip over matched label */
3460 length
= sep
- path_pos
- length
; /* length of sub-label to decode */
3462 /* store unescaped label for later use */
3463 label
= bus_label_unescape_n(path_pos
, length
);
3467 r
= strv_consume(&labels
, label
);
3471 path_pos
= sep
; /* skip decoded label and suffix */
3474 /* end of template must match end of path */
3478 /* copy the labels over to the caller */
3479 va_start(list
, path_template
);
3480 for (label_pos
= labels
; label_pos
&& *label_pos
; ++label_pos
) {
3483 arg
= va_arg(list
, char **);
3496 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3497 assert_return(bus
, -EINVAL
);
3498 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3503 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3504 assert_return(bus
, -EINVAL
);
3505 assert_return(description
, -EINVAL
);
3506 assert_return(bus
->description
, -ENXIO
);
3507 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3509 *description
= bus
->description
;
3513 int bus_get_root_path(sd_bus
*bus
) {
3516 if (bus
->cgroup_root
)
3519 r
= cg_get_root_path(&bus
->cgroup_root
);
3521 bus
->cgroup_root
= strdup("/");
3522 if (!bus
->cgroup_root
)
3531 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3532 assert_return(bus
, -EINVAL
);
3533 assert_return(scope
, -EINVAL
);
3534 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3541 if (bus
->is_system
) {
3549 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3551 assert_return(bus
, -EINVAL
);
3552 assert_return(address
, -EINVAL
);
3553 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3556 *address
= bus
->address
;
3563 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3564 assert_return(bus
, -EINVAL
);
3565 assert_return(mask
, -EINVAL
);
3566 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3568 *mask
= bus
->creds_mask
;
3572 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3573 assert_return(bus
, -EINVAL
);
3574 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3576 return bus
->bus_client
;
3579 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3580 assert_return(bus
, -EINVAL
);
3581 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3583 return bus
->is_server
;
3586 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3587 assert_return(bus
, -EINVAL
);
3588 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3590 return bus
->anonymous_auth
;
3593 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3594 assert_return(bus
, -EINVAL
);
3595 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3597 return bus
->trusted
;
3600 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3601 assert_return(bus
, -EINVAL
);
3602 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3604 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);
3607 static void flush_close(sd_bus
*bus
) {
3611 /* Flushes and closes the specified bus. We take a ref before,
3612 * to ensure the flushing does not cause the bus to be
3615 sd_bus_flush_close_unref(sd_bus_ref(bus
));
3618 _public_
void sd_bus_default_flush_close(void) {
3619 flush_close(default_starter_bus
);
3620 flush_close(default_user_bus
);
3621 flush_close(default_system_bus
);
3624 _public_
int sd_bus_set_exit_on_disconnect(sd_bus
*bus
, int b
) {
3625 assert_return(bus
, -EINVAL
);
3627 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
3628 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
3629 * from the client side. */
3630 bus
->exit_on_disconnect
= b
;
3632 /* If the exit condition was triggered already, exit immediately. */
3633 return bus_exit_now(bus
);
3636 _public_
int sd_bus_get_exit_on_disconnect(sd_bus
*bus
) {
3637 assert_return(bus
, -EINVAL
);
3639 return bus
->exit_on_disconnect
;