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/>.
38 #include "cgroup-util.h"
39 #include "bus-label.h"
42 #include "bus-internal.h"
43 #include "bus-message.h"
45 #include "bus-socket.h"
46 #include "bus-kernel.h"
47 #include "bus-control.h"
48 #include "bus-introspect.h"
49 #include "bus-signature.h"
50 #include "bus-objects.h"
52 #include "bus-container.h"
53 #include "bus-protocol.h"
54 #include "bus-track.h"
57 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
58 static int attach_io_events(sd_bus
*b
);
59 static void detach_io_events(sd_bus
*b
);
61 static void bus_close_fds(sd_bus
*b
) {
67 safe_close(b
->input_fd
);
69 if (b
->output_fd
>= 0 && b
->output_fd
!= b
->input_fd
)
70 safe_close(b
->output_fd
);
72 b
->input_fd
= b
->output_fd
= -1;
75 static void bus_reset_queues(sd_bus
*b
) {
78 while (b
->rqueue_size
> 0)
79 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
83 b
->rqueue_allocated
= 0;
85 while (b
->wqueue_size
> 0)
86 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
90 b
->wqueue_allocated
= 0;
93 static void bus_free(sd_bus
*b
) {
97 assert(!b
->track_queue
);
99 b
->state
= BUS_CLOSED
;
101 sd_bus_detach_event(b
);
103 while ((s
= b
->slots
)) {
104 /* At this point only floating slots can still be
105 * around, because the non-floating ones keep a
106 * reference to the bus, and we thus couldn't be
107 * destructing right now... We forcibly disconnect the
108 * slots here, so that they still can be referenced by
109 * apps, but are dead. */
112 bus_slot_disconnect(s
);
113 sd_bus_slot_unref(s
);
116 if (b
->default_bus_ptr
)
117 *b
->default_bus_ptr
= NULL
;
122 munmap(b
->kdbus_buffer
, KDBUS_POOL_SIZE
);
125 free(b
->unique_name
);
126 free(b
->auth_buffer
);
131 free(b
->cgroup_root
);
132 free(b
->description
);
135 strv_free(b
->exec_argv
);
137 close_many(b
->fds
, b
->n_fds
);
142 ordered_hashmap_free_free(b
->reply_callbacks
);
143 prioq_free(b
->reply_callbacks_prioq
);
145 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
146 bus_match_free(&b
->match_callbacks
);
148 hashmap_free_free(b
->vtable_methods
);
149 hashmap_free_free(b
->vtable_properties
);
151 assert(hashmap_isempty(b
->nodes
));
152 hashmap_free(b
->nodes
);
154 bus_kernel_flush_memfd(b
);
156 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
161 _public_
int sd_bus_new(sd_bus
**ret
) {
164 assert_return(ret
, -EINVAL
);
170 r
->n_ref
= REFCNT_INIT
;
171 r
->input_fd
= r
->output_fd
= -1;
172 r
->message_version
= 1;
173 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
174 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
175 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
176 r
->original_pid
= getpid();
178 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
180 /* We guarantee that wqueue always has space for at least one
182 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
191 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
194 assert_return(bus
, -EINVAL
);
195 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
196 assert_return(address
, -EINVAL
);
197 assert_return(!bus_pid_changed(bus
), -ECHILD
);
209 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
210 assert_return(bus
, -EINVAL
);
211 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
212 assert_return(input_fd
>= 0, -EINVAL
);
213 assert_return(output_fd
>= 0, -EINVAL
);
214 assert_return(!bus_pid_changed(bus
), -ECHILD
);
216 bus
->input_fd
= input_fd
;
217 bus
->output_fd
= output_fd
;
221 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
224 assert_return(bus
, -EINVAL
);
225 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
226 assert_return(path
, -EINVAL
);
227 assert_return(!strv_isempty(argv
), -EINVAL
);
228 assert_return(!bus_pid_changed(bus
), -ECHILD
);
240 free(bus
->exec_path
);
241 strv_free(bus
->exec_argv
);
249 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
250 assert_return(bus
, -EINVAL
);
251 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
252 assert_return(!bus_pid_changed(bus
), -ECHILD
);
254 bus
->bus_client
= !!b
;
258 _public_
int sd_bus_set_monitor(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 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
267 _public_
int sd_bus_negotiate_fds(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_ACCEPT_FD
, b
);
276 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
278 assert_return(bus
, -EINVAL
);
279 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
280 assert_return(!bus_pid_changed(bus
), -ECHILD
);
282 new_flags
= bus
->attach_flags
;
283 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
285 if (bus
->attach_flags
== new_flags
)
288 bus
->attach_flags
= new_flags
;
289 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
290 bus_kernel_realize_attach_flags(bus
);
295 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
298 assert_return(bus
, -EINVAL
);
299 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
300 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
301 assert_return(!bus_pid_changed(bus
), -ECHILD
);
304 bus
->creds_mask
|= mask
;
306 bus
->creds_mask
&= ~mask
;
308 /* The well knowns we need unconditionally, so that matches can work */
309 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
311 /* Make sure we don't lose the timestamp flag */
312 new_flags
= (bus
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) | attach_flags_to_kdbus(bus
->creds_mask
);
313 if (bus
->attach_flags
== new_flags
)
316 bus
->attach_flags
= new_flags
;
317 if (bus
->state
!= BUS_UNSET
&& bus
->is_kernel
)
318 bus_kernel_realize_attach_flags(bus
);
323 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
324 assert_return(bus
, -EINVAL
);
325 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
326 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
327 assert_return(!bus_pid_changed(bus
), -ECHILD
);
329 bus
->is_server
= !!b
;
330 bus
->server_id
= server_id
;
334 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
335 assert_return(bus
, -EINVAL
);
336 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
337 assert_return(!bus_pid_changed(bus
), -ECHILD
);
339 bus
->anonymous_auth
= !!b
;
343 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
344 assert_return(bus
, -EINVAL
);
345 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
346 assert_return(!bus_pid_changed(bus
), -ECHILD
);
352 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
353 assert_return(bus
, -EINVAL
);
354 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
355 assert_return(!bus_pid_changed(bus
), -ECHILD
);
357 return free_and_strdup(&bus
->description
, description
);
360 static int hello_callback(sd_bus
*bus
, sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
365 assert(bus
->state
== BUS_HELLO
|| bus
->state
== BUS_CLOSING
);
368 r
= sd_bus_message_get_errno(reply
);
372 r
= sd_bus_message_read(reply
, "s", &s
);
376 if (!service_name_is_valid(s
) || s
[0] != ':')
379 bus
->unique_name
= strdup(s
);
380 if (!bus
->unique_name
)
383 if (bus
->state
== BUS_HELLO
)
384 bus
->state
= BUS_RUNNING
;
389 static int bus_send_hello(sd_bus
*bus
) {
390 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
395 if (!bus
->bus_client
|| bus
->is_kernel
)
398 r
= sd_bus_message_new_method_call(
401 "org.freedesktop.DBus",
402 "/org/freedesktop/DBus",
403 "org.freedesktop.DBus",
408 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
411 int bus_start_running(sd_bus
*bus
) {
414 if (bus
->bus_client
&& !bus
->is_kernel
) {
415 bus
->state
= BUS_HELLO
;
419 bus
->state
= BUS_RUNNING
;
423 static int parse_address_key(const char **p
, const char *key
, char **value
) {
424 size_t l
, n
= 0, allocated
= 0;
434 if (strncmp(*p
, key
, l
) != 0)
447 while (*a
!= ';' && *a
!= ',' && *a
!= 0) {
465 c
= (char) ((x
<< 4) | y
);
472 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
496 static void skip_address_key(const char **p
) {
500 *p
+= strcspn(*p
, ",");
506 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
507 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
516 while (**p
!= 0 && **p
!= ';') {
517 r
= parse_address_key(p
, "guid", guid
);
523 r
= parse_address_key(p
, "path", &path
);
529 r
= parse_address_key(p
, "abstract", &abstract
);
538 if (!path
&& !abstract
)
541 if (path
&& abstract
)
546 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
549 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
550 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
551 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
552 } else if (abstract
) {
553 l
= strlen(abstract
);
554 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
557 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
558 b
->sockaddr
.un
.sun_path
[0] = 0;
559 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
560 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
566 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
567 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
569 struct addrinfo
*result
, hints
= {
570 .ai_socktype
= SOCK_STREAM
,
571 .ai_flags
= AI_ADDRCONFIG
,
579 while (**p
!= 0 && **p
!= ';') {
580 r
= parse_address_key(p
, "guid", guid
);
586 r
= parse_address_key(p
, "host", &host
);
592 r
= parse_address_key(p
, "port", &port
);
598 r
= parse_address_key(p
, "family", &family
);
611 if (streq(family
, "ipv4"))
612 hints
.ai_family
= AF_INET
;
613 else if (streq(family
, "ipv6"))
614 hints
.ai_family
= AF_INET6
;
619 r
= getaddrinfo(host
, port
, &hints
, &result
);
623 return -EADDRNOTAVAIL
;
625 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
626 b
->sockaddr_size
= result
->ai_addrlen
;
628 freeaddrinfo(result
);
633 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
635 unsigned n_argv
= 0, j
;
637 size_t allocated
= 0;
645 while (**p
!= 0 && **p
!= ';') {
646 r
= parse_address_key(p
, "guid", guid
);
652 r
= parse_address_key(p
, "path", &path
);
658 if (startswith(*p
, "argv")) {
662 ul
= strtoul(*p
+ 4, (char**) p
, 10);
663 if (errno
> 0 || **p
!= '=' || ul
> 256) {
671 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
679 r
= parse_address_key(p
, NULL
, argv
+ ul
);
694 /* Make sure there are no holes in the array, with the
695 * exception of argv[0] */
696 for (j
= 1; j
< n_argv
; j
++)
702 if (argv
&& argv
[0] == NULL
) {
703 argv
[0] = strdup(path
);
715 for (j
= 0; j
< n_argv
; j
++)
723 static int parse_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
724 _cleanup_free_
char *path
= NULL
;
732 while (**p
!= 0 && **p
!= ';') {
733 r
= parse_address_key(p
, "guid", guid
);
739 r
= parse_address_key(p
, "path", &path
);
758 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
759 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
767 while (**p
!= 0 && **p
!= ';') {
768 r
= parse_address_key(p
, "guid", guid
);
774 r
= parse_address_key(p
, "machine", &machine
);
780 r
= parse_address_key(p
, "pid", &pid
);
789 if (!machine
== !pid
)
793 if (!machine_name_is_valid(machine
))
797 b
->machine
= machine
;
805 r
= parse_pid(pid
, &b
->nspid
);
811 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
812 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
813 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + strlen("/var/run/dbus/system_bus_socket");
818 static int parse_container_kernel_address(sd_bus
*b
, const char **p
, char **guid
) {
819 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
827 while (**p
!= 0 && **p
!= ';') {
828 r
= parse_address_key(p
, "guid", guid
);
834 r
= parse_address_key(p
, "machine", &machine
);
840 r
= parse_address_key(p
, "pid", &pid
);
849 if (!machine
== !pid
)
853 if (!machine_name_is_valid(machine
))
857 b
->machine
= machine
;
865 r
= parse_pid(pid
, &b
->nspid
);
872 b
->kernel
= strdup("/sys/fs/kdbus/0-system/bus");
879 static void bus_reset_parsed_address(sd_bus
*b
) {
883 b
->sockaddr_size
= 0;
884 strv_free(b
->exec_argv
);
888 b
->server_id
= SD_ID128_NULL
;
896 static int bus_parse_next_address(sd_bus
*b
) {
897 _cleanup_free_
char *guid
= NULL
;
905 if (b
->address
[b
->address_index
] == 0)
908 bus_reset_parsed_address(b
);
910 a
= b
->address
+ b
->address_index
;
919 if (startswith(a
, "unix:")) {
922 r
= parse_unix_address(b
, &a
, &guid
);
927 } else if (startswith(a
, "tcp:")) {
930 r
= parse_tcp_address(b
, &a
, &guid
);
936 } else if (startswith(a
, "unixexec:")) {
939 r
= parse_exec_address(b
, &a
, &guid
);
945 } else if (startswith(a
, "kernel:")) {
948 r
= parse_kernel_address(b
, &a
, &guid
);
953 } else if (startswith(a
, "x-machine-unix:")) {
956 r
= parse_container_unix_address(b
, &a
, &guid
);
961 } else if (startswith(a
, "x-machine-kernel:")) {
964 r
= parse_container_kernel_address(b
, &a
, &guid
);
977 r
= sd_id128_from_string(guid
, &b
->server_id
);
982 b
->address_index
= a
- b
->address
;
986 static int bus_start_address(sd_bus
*b
) {
992 bool skipped
= false;
997 r
= bus_socket_exec(b
);
998 else if ((b
->nspid
> 0 || b
->machine
) && b
->kernel
)
999 r
= bus_container_connect_kernel(b
);
1000 else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1001 r
= bus_container_connect_socket(b
);
1003 r
= bus_kernel_connect(b
);
1004 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1005 r
= bus_socket_connect(b
);
1011 r
= attach_io_events(b
);
1016 b
->last_connect_error
= -r
;
1019 r
= bus_parse_next_address(b
);
1023 return b
->last_connect_error
? -b
->last_connect_error
: -ECONNREFUSED
;
1027 int bus_next_address(sd_bus
*b
) {
1030 bus_reset_parsed_address(b
);
1031 return bus_start_address(b
);
1034 static int bus_start_fd(sd_bus
*b
) {
1039 assert(b
->input_fd
>= 0);
1040 assert(b
->output_fd
>= 0);
1042 r
= fd_nonblock(b
->input_fd
, true);
1046 r
= fd_cloexec(b
->input_fd
, true);
1050 if (b
->input_fd
!= b
->output_fd
) {
1051 r
= fd_nonblock(b
->output_fd
, true);
1055 r
= fd_cloexec(b
->output_fd
, true);
1060 if (fstat(b
->input_fd
, &st
) < 0)
1063 if (S_ISCHR(b
->input_fd
))
1064 return bus_kernel_take_fd(b
);
1066 return bus_socket_take_fd(b
);
1069 _public_
int sd_bus_start(sd_bus
*bus
) {
1072 assert_return(bus
, -EINVAL
);
1073 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1074 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1076 bus
->state
= BUS_OPENING
;
1078 if (bus
->is_server
&& bus
->bus_client
)
1081 if (bus
->input_fd
>= 0)
1082 r
= bus_start_fd(bus
);
1083 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->kernel
|| bus
->machine
)
1084 r
= bus_start_address(bus
);
1093 return bus_send_hello(bus
);
1096 _public_
int sd_bus_open(sd_bus
**ret
) {
1101 assert_return(ret
, -EINVAL
);
1103 /* Let's connect to the starter bus if it is set, and
1104 * otherwise to the bus that is appropropriate for the scope
1105 * we are running in */
1107 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1109 if (streq(e
, "system"))
1110 return sd_bus_open_system(ret
);
1111 else if (STR_IN_SET(e
, "session", "user"))
1112 return sd_bus_open_user(ret
);
1115 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1117 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1118 return sd_bus_open_user(ret
);
1120 return sd_bus_open_system(ret
);
1127 r
= sd_bus_set_address(b
, e
);
1131 b
->bus_client
= true;
1133 /* We don't know whether the bus is trusted or not, so better
1134 * be safe, and authenticate everything */
1136 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1137 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1139 r
= sd_bus_start(b
);
1151 int bus_set_address_system(sd_bus
*b
) {
1155 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1157 return sd_bus_set_address(b
, e
);
1159 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1162 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1166 assert_return(ret
, -EINVAL
);
1172 r
= bus_set_address_system(b
);
1176 b
->bus_client
= true;
1177 b
->is_system
= true;
1179 /* Let's do per-method access control on the system bus. We
1180 * need the caller's UID and capability set for that. */
1182 b
->attach_flags
|= KDBUS_ATTACH_CAPS
| KDBUS_ATTACH_CREDS
;
1183 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1185 r
= sd_bus_start(b
);
1197 int bus_set_address_user(sd_bus
*b
) {
1202 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1204 return sd_bus_set_address(b
, e
);
1206 e
= secure_getenv("XDG_RUNTIME_DIR");
1208 _cleanup_free_
char *ee
= NULL
;
1210 ee
= bus_address_escape(e
);
1215 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
";" UNIX_USER_BUS_ADDRESS_FMT
, getuid(), ee
);
1217 (void) asprintf(&b
->address
, UNIX_USER_BUS_ADDRESS_FMT
, ee
);
1221 (void) asprintf(&b
->address
, KERNEL_USER_BUS_ADDRESS_FMT
, getuid());
1223 return -ECONNREFUSED
;
1233 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1237 assert_return(ret
, -EINVAL
);
1243 r
= bus_set_address_user(b
);
1247 b
->bus_client
= true;
1250 /* We don't do any per-method access control on the user
1254 r
= sd_bus_start(b
);
1266 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1267 _cleanup_free_
char *e
= NULL
;
1268 char *m
= NULL
, *c
= NULL
;
1273 /* Let's see if we shall enter some container */
1274 m
= strchr(host
, ':');
1278 /* Let's make sure this is not a port of some kind,
1279 * and is a valid machine name. */
1280 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1283 /* Cut out the host part */
1284 t
= strndupa(host
, m
- host
- 1);
1285 e
= bus_address_escape(t
);
1289 c
= strjoina(",argv4=--machine=", m
);
1294 e
= bus_address_escape(host
);
1299 b
->address
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e
, ",argv3=systemd-stdio-bridge", c
, NULL
);
1306 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1310 assert_return(host
, -EINVAL
);
1311 assert_return(ret
, -EINVAL
);
1313 r
= sd_bus_new(&bus
);
1317 r
= bus_set_address_system_remote(bus
, host
);
1321 bus
->bus_client
= true;
1322 bus
->trusted
= false;
1323 bus
->is_system
= true;
1325 r
= sd_bus_start(bus
);
1337 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1338 _cleanup_free_
char *e
= NULL
;
1343 e
= bus_address_escape(machine
);
1348 b
->address
= strjoin("x-machine-kernel:machine=", e
, ";x-machine-unix:machine=", e
, NULL
);
1350 b
->address
= strjoin("x-machine-unix:machine=", e
, NULL
);
1358 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1362 assert_return(machine
, -EINVAL
);
1363 assert_return(ret
, -EINVAL
);
1364 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1366 r
= sd_bus_new(&bus
);
1370 r
= bus_set_address_system_machine(bus
, machine
);
1374 bus
->bus_client
= true;
1375 bus
->trusted
= false;
1376 bus
->is_system
= true;
1378 r
= sd_bus_start(bus
);
1390 _public_
void sd_bus_close(sd_bus
*bus
) {
1394 if (bus
->state
== BUS_CLOSED
)
1396 if (bus_pid_changed(bus
))
1399 bus
->state
= BUS_CLOSED
;
1401 sd_bus_detach_event(bus
);
1403 /* Drop all queued messages so that they drop references to
1404 * the bus object and the bus may be freed */
1405 bus_reset_queues(bus
);
1407 if (!bus
->is_kernel
)
1410 /* We'll leave the fd open in case this is a kernel bus, since
1411 * there might still be memblocks around that reference this
1412 * bus, and they might need to invoke the KDBUS_CMD_FREE
1413 * ioctl on the fd when they are freed. */
1416 static void bus_enter_closing(sd_bus
*bus
) {
1419 if (bus
->state
!= BUS_OPENING
&&
1420 bus
->state
!= BUS_AUTHENTICATING
&&
1421 bus
->state
!= BUS_HELLO
&&
1422 bus
->state
!= BUS_RUNNING
)
1425 bus
->state
= BUS_CLOSING
;
1428 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1429 assert_return(bus
, NULL
);
1431 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1436 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1442 i
= REFCNT_DEC(bus
->n_ref
);
1450 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1452 assert_return(bus
, -EINVAL
);
1453 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1455 return BUS_IS_OPEN(bus
->state
);
1458 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1461 assert_return(bus
, -EINVAL
);
1462 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1463 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1465 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1468 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1469 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1472 r
= bus_ensure_running(bus
);
1476 return bus
->can_fds
;
1479 return bus_type_is_valid(type
);
1482 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1485 assert_return(bus
, -EINVAL
);
1486 assert_return(id
, -EINVAL
);
1487 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1489 r
= bus_ensure_running(bus
);
1493 *id
= bus
->server_id
;
1497 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1502 /* If we copy the same message to multiple
1503 * destinations, avoid using the same cookie
1505 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1510 timeout
= BUS_DEFAULT_TIMEOUT
;
1512 return bus_message_seal(m
, ++b
->cookie
, timeout
);
1515 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1518 /* Do packet version and endianness already match? */
1519 if ((b
->message_version
== 0 || b
->message_version
== (*m
)->header
->version
) &&
1520 (b
->message_endian
== 0 || b
->message_endian
== (*m
)->header
->endian
))
1523 /* No? Then remarshal! */
1524 return bus_message_remarshal(b
, m
);
1527 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1531 /* Fake some timestamps, if they were requested, and not
1532 * already initialized */
1533 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1534 if (m
->realtime
<= 0)
1535 m
->realtime
= now(CLOCK_REALTIME
);
1537 if (m
->monotonic
<= 0)
1538 m
->monotonic
= now(CLOCK_MONOTONIC
);
1541 /* The bus specification says the serial number cannot be 0,
1542 * hence let's fill something in for synthetic messages. Since
1543 * synthetic messages might have a fake sender and we don't
1544 * want to interfere with the real sender's serial numbers we
1545 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1546 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1547 * even though kdbus can do 64bit. */
1548 return bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1551 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1558 r
= bus_kernel_write_message(bus
, m
, hint_sync_call
);
1560 r
= bus_socket_write_message(bus
, m
, idx
);
1565 if (bus
->is_kernel
|| *idx
>= BUS_MESSAGE_SIZE(m
))
1566 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
1567 bus_message_type_to_string(m
->header
->type
),
1568 strna(sd_bus_message_get_sender(m
)),
1569 strna(sd_bus_message_get_destination(m
)),
1570 strna(sd_bus_message_get_path(m
)),
1571 strna(sd_bus_message_get_interface(m
)),
1572 strna(sd_bus_message_get_member(m
)),
1573 BUS_MESSAGE_COOKIE(m
),
1575 strna(m
->error
.message
));
1580 static int dispatch_wqueue(sd_bus
*bus
) {
1584 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1586 while (bus
->wqueue_size
> 0) {
1588 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1592 /* Didn't do anything this time */
1594 else if (bus
->is_kernel
|| bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1595 /* Fully written. Let's drop the entry from
1598 * This isn't particularly optimized, but
1599 * well, this is supposed to be our worst-case
1600 * buffer only, and the socket buffer is
1601 * supposed to be our primary buffer, and if
1602 * it got full, then all bets are off
1605 bus
->wqueue_size
--;
1606 sd_bus_message_unref(bus
->wqueue
[0]);
1607 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1617 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1621 return bus_kernel_read_message(bus
, hint_priority
, priority
);
1623 return bus_socket_read_message(bus
);
1626 int bus_rqueue_make_room(sd_bus
*bus
) {
1629 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1632 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1638 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1643 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
1645 /* Note that the priority logic is only available on kdbus,
1646 * where the rqueue is unused. We check the rqueue here
1647 * anyway, because it's simple... */
1650 if (bus
->rqueue_size
> 0) {
1651 /* Dispatch a queued message */
1653 *m
= bus
->rqueue
[0];
1654 bus
->rqueue_size
--;
1655 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1659 /* Try to read a new message */
1660 r
= bus_read_message(bus
, hint_priority
, priority
);
1670 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1671 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1674 assert_return(bus
, -EINVAL
);
1675 assert_return(m
, -EINVAL
);
1676 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1677 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1679 if (!BUS_IS_OPEN(bus
->state
))
1683 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1690 /* If the cookie number isn't kept, then we know that no reply
1692 if (!cookie
&& !m
->sealed
)
1693 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1695 r
= bus_seal_message(bus
, m
, 0);
1699 /* Remarshall if we have to. This will possibly unref the
1700 * message and place a replacement in m */
1701 r
= bus_remarshal_message(bus
, &m
);
1705 /* If this is a reply and no reply was requested, then let's
1706 * suppress this, if we can */
1710 if ((bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1713 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1715 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
1716 bus_enter_closing(bus
);
1723 if (!bus
->is_kernel
&& idx
< BUS_MESSAGE_SIZE(m
)) {
1724 /* Wasn't fully written. So let's remember how
1725 * much was written. Note that the first entry
1726 * of the wqueue array is always allocated so
1727 * that we always can remember how much was
1729 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1730 bus
->wqueue_size
= 1;
1735 /* Just append it to the queue. */
1737 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1740 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1743 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1748 *cookie
= BUS_MESSAGE_COOKIE(m
);
1753 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1754 return bus_send_internal(bus
, m
, cookie
, false);
1757 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1760 assert_return(bus
, -EINVAL
);
1761 assert_return(m
, -EINVAL
);
1762 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1764 if (!BUS_IS_OPEN(bus
->state
))
1767 if (!streq_ptr(m
->destination
, destination
)) {
1772 r
= sd_bus_message_set_destination(m
, destination
);
1777 return sd_bus_send(bus
, m
, cookie
);
1780 static usec_t
calc_elapse(uint64_t usec
) {
1781 if (usec
== (uint64_t) -1)
1784 return now(CLOCK_MONOTONIC
) + usec
;
1787 static int timeout_compare(const void *a
, const void *b
) {
1788 const struct reply_callback
*x
= a
, *y
= b
;
1790 if (x
->timeout
!= 0 && y
->timeout
== 0)
1793 if (x
->timeout
== 0 && y
->timeout
!= 0)
1796 if (x
->timeout
< y
->timeout
)
1799 if (x
->timeout
> y
->timeout
)
1805 _public_
int sd_bus_call_async(
1809 sd_bus_message_handler_t callback
,
1813 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1814 _cleanup_bus_slot_unref_ sd_bus_slot
*s
= NULL
;
1817 assert_return(bus
, -EINVAL
);
1818 assert_return(m
, -EINVAL
);
1819 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1820 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1821 assert_return(callback
, -EINVAL
);
1822 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1823 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1825 if (!BUS_IS_OPEN(bus
->state
))
1828 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1832 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1836 r
= bus_seal_message(bus
, m
, usec
);
1840 r
= bus_remarshal_message(bus
, &m
);
1844 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1848 s
->reply_callback
.callback
= callback
;
1850 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1851 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1853 s
->reply_callback
.cookie
= 0;
1857 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1858 if (s
->reply_callback
.timeout
!= 0) {
1859 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1861 s
->reply_callback
.timeout
= 0;
1866 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1877 int bus_ensure_running(sd_bus
*bus
) {
1882 if (bus
->state
== BUS_UNSET
|| bus
->state
== BUS_CLOSED
|| bus
->state
== BUS_CLOSING
)
1884 if (bus
->state
== BUS_RUNNING
)
1888 r
= sd_bus_process(bus
, NULL
);
1891 if (bus
->state
== BUS_RUNNING
)
1896 r
= sd_bus_wait(bus
, (uint64_t) -1);
1902 _public_
int sd_bus_call(
1906 sd_bus_error
*error
,
1907 sd_bus_message
**reply
) {
1909 _cleanup_bus_message_unref_ sd_bus_message
*m
= sd_bus_message_ref(_m
);
1915 assert_return(bus
, -EINVAL
);
1916 assert_return(m
, -EINVAL
);
1917 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1918 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1919 assert_return(!bus_error_is_dirty(error
), -EINVAL
);
1920 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1921 assert_return(!bus
->is_kernel
|| !(bus
->hello_flags
& KDBUS_HELLO_MONITOR
), -EROFS
);
1923 if (!BUS_IS_OPEN(bus
->state
))
1926 r
= bus_ensure_running(bus
);
1930 i
= bus
->rqueue_size
;
1932 r
= bus_seal_message(bus
, m
, usec
);
1936 r
= bus_remarshal_message(bus
, &m
);
1940 r
= bus_send_internal(bus
, m
, &cookie
, true);
1944 timeout
= calc_elapse(m
->timeout
);
1949 while (i
< bus
->rqueue_size
) {
1950 sd_bus_message
*incoming
= NULL
;
1952 incoming
= bus
->rqueue
[i
];
1954 if (incoming
->reply_cookie
== cookie
) {
1955 /* Found a match! */
1957 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
1960 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
1962 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
1966 sd_bus_message_unref(incoming
);
1971 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1973 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
)
1974 r
= sd_bus_error_copy(error
, &incoming
->error
);
1978 sd_bus_message_unref(incoming
);
1981 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
1984 streq(bus
->unique_name
, incoming
->sender
)) {
1986 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
1989 /* Our own message? Somebody is trying
1990 * to send its own client a message,
1991 * let's not dead-lock, let's fail
1994 sd_bus_message_unref(incoming
);
1998 /* Try to read more, right-away */
2002 r
= bus_read_message(bus
, false, 0);
2004 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2005 bus_enter_closing(bus
);
2017 n
= now(CLOCK_MONOTONIC
);
2023 left
= (uint64_t) -1;
2025 r
= bus_poll(bus
, true, left
);
2031 r
= dispatch_wqueue(bus
);
2033 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2034 bus_enter_closing(bus
);
2043 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2045 assert_return(bus
, -EINVAL
);
2046 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2047 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2049 return bus
->input_fd
;
2052 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2055 assert_return(bus
, -EINVAL
);
2056 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2058 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2061 if (bus
->state
== BUS_OPENING
)
2063 else if (bus
->state
== BUS_AUTHENTICATING
) {
2065 if (bus_socket_auth_needs_write(bus
))
2070 } else if (bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
) {
2071 if (bus
->rqueue_size
<= 0)
2073 if (bus
->wqueue_size
> 0)
2080 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2081 struct reply_callback
*c
;
2083 assert_return(bus
, -EINVAL
);
2084 assert_return(timeout_usec
, -EINVAL
);
2085 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2087 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2090 if (bus
->track_queue
) {
2095 if (bus
->state
== BUS_CLOSING
) {
2100 if (bus
->state
== BUS_AUTHENTICATING
) {
2101 *timeout_usec
= bus
->auth_timeout
;
2105 if (bus
->state
!= BUS_RUNNING
&& bus
->state
!= BUS_HELLO
) {
2106 *timeout_usec
= (uint64_t) -1;
2110 if (bus
->rqueue_size
> 0) {
2115 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2117 *timeout_usec
= (uint64_t) -1;
2121 if (c
->timeout
== 0) {
2122 *timeout_usec
= (uint64_t) -1;
2126 *timeout_usec
= c
->timeout
;
2130 static int process_timeout(sd_bus
*bus
) {
2131 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2132 _cleanup_bus_message_unref_ sd_bus_message
* m
= NULL
;
2133 struct reply_callback
*c
;
2140 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2144 n
= now(CLOCK_MONOTONIC
);
2148 r
= bus_message_new_synthetic_error(
2151 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2156 r
= bus_seal_synthetic_message(bus
, m
);
2160 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2163 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2166 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2168 bus
->iteration_counter
++;
2170 bus
->current_message
= m
;
2171 bus
->current_slot
= sd_bus_slot_ref(slot
);
2172 bus
->current_handler
= c
->callback
;
2173 bus
->current_userdata
= slot
->userdata
;
2174 r
= c
->callback(bus
, m
, slot
->userdata
, &error_buffer
);
2175 bus
->current_userdata
= NULL
;
2176 bus
->current_handler
= NULL
;
2177 bus
->current_slot
= NULL
;
2178 bus
->current_message
= NULL
;
2180 if (slot
->floating
) {
2181 bus_slot_disconnect(slot
);
2182 sd_bus_slot_unref(slot
);
2185 sd_bus_slot_unref(slot
);
2187 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2190 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2194 if (bus
->state
!= BUS_HELLO
)
2197 /* Let's make sure the first message on the bus is the HELLO
2198 * reply. But note that we don't actually parse the message
2199 * here (we leave that to the usual handling), we just verify
2200 * we don't let any earlier msg through. */
2202 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2203 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2206 if (m
->reply_cookie
!= 1)
2212 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2213 _cleanup_bus_message_unref_ sd_bus_message
*synthetic_reply
= NULL
;
2214 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2215 struct reply_callback
*c
;
2222 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_RETURN
&&
2223 m
->header
->type
!= SD_BUS_MESSAGE_METHOD_ERROR
)
2226 if (bus
->is_kernel
&& (bus
->hello_flags
& KDBUS_HELLO_MONITOR
))
2229 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2232 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2238 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2240 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2242 /* If the reply contained a file descriptor which we
2243 * didn't want we pass an error instead. */
2245 r
= bus_message_new_synthetic_error(
2248 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2253 /* Copy over original timestamp */
2254 synthetic_reply
->realtime
= m
->realtime
;
2255 synthetic_reply
->monotonic
= m
->monotonic
;
2256 synthetic_reply
->seqnum
= m
->seqnum
;
2258 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2262 m
= synthetic_reply
;
2264 r
= sd_bus_message_rewind(m
, true);
2269 if (c
->timeout
!= 0) {
2270 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2274 bus
->current_slot
= sd_bus_slot_ref(slot
);
2275 bus
->current_handler
= c
->callback
;
2276 bus
->current_userdata
= slot
->userdata
;
2277 r
= c
->callback(bus
, m
, slot
->userdata
, &error_buffer
);
2278 bus
->current_userdata
= NULL
;
2279 bus
->current_handler
= NULL
;
2280 bus
->current_slot
= NULL
;
2282 if (slot
->floating
) {
2283 bus_slot_disconnect(slot
);
2284 sd_bus_slot_unref(slot
);
2287 sd_bus_slot_unref(slot
);
2289 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2292 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2293 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2294 struct filter_callback
*l
;
2301 bus
->filter_callbacks_modified
= false;
2303 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2306 if (bus
->filter_callbacks_modified
)
2309 /* Don't run this more than once per iteration */
2310 if (l
->last_iteration
== bus
->iteration_counter
)
2313 l
->last_iteration
= bus
->iteration_counter
;
2315 r
= sd_bus_message_rewind(m
, true);
2319 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2321 bus
->current_slot
= sd_bus_slot_ref(slot
);
2322 bus
->current_handler
= l
->callback
;
2323 bus
->current_userdata
= slot
->userdata
;
2324 r
= l
->callback(bus
, m
, slot
->userdata
, &error_buffer
);
2325 bus
->current_userdata
= NULL
;
2326 bus
->current_handler
= NULL
;
2327 bus
->current_slot
= sd_bus_slot_unref(slot
);
2329 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2335 } while (bus
->filter_callbacks_modified
);
2340 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2347 bus
->match_callbacks_modified
= false;
2349 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2353 } while (bus
->match_callbacks_modified
);
2358 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2359 _cleanup_bus_message_unref_ sd_bus_message
*reply
= NULL
;
2365 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2368 if (bus
->manual_peer_interface
)
2371 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2374 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2377 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2380 if (streq_ptr(m
->member
, "Ping"))
2381 r
= sd_bus_message_new_method_return(m
, &reply
);
2382 else if (streq_ptr(m
->member
, "GetMachineId")) {
2386 r
= sd_id128_get_machine(&id
);
2390 r
= sd_bus_message_new_method_return(m
, &reply
);
2394 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2396 r
= sd_bus_message_new_method_errorf(
2398 SD_BUS_ERROR_UNKNOWN_METHOD
,
2399 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2405 r
= sd_bus_send(bus
, reply
, NULL
);
2412 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2416 /* If we got a message with a file descriptor which we didn't
2417 * want to accept, then let's drop it. How can this even
2418 * happen? For example, when the kernel queues a message into
2419 * an activatable names's queue which allows fds, and then is
2420 * delivered to us later even though we ourselves did not
2423 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2429 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2432 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2433 return 1; /* just eat it up */
2435 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2438 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2444 bus
->current_message
= m
;
2445 bus
->iteration_counter
++;
2447 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error=%s",
2448 bus_message_type_to_string(m
->header
->type
),
2449 strna(sd_bus_message_get_sender(m
)),
2450 strna(sd_bus_message_get_destination(m
)),
2451 strna(sd_bus_message_get_path(m
)),
2452 strna(sd_bus_message_get_interface(m
)),
2453 strna(sd_bus_message_get_member(m
)),
2454 BUS_MESSAGE_COOKIE(m
),
2456 strna(m
->error
.message
));
2458 r
= process_hello(bus
, m
);
2462 r
= process_reply(bus
, m
);
2466 r
= process_fd_check(bus
, m
);
2470 r
= process_filter(bus
, m
);
2474 r
= process_match(bus
, m
);
2478 r
= process_builtin(bus
, m
);
2482 r
= bus_process_object(bus
, m
);
2485 bus
->current_message
= NULL
;
2489 static int dispatch_track(sd_bus
*bus
) {
2492 if (!bus
->track_queue
)
2495 bus_track_dispatch(bus
->track_queue
);
2499 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2500 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2504 assert(bus
->state
== BUS_RUNNING
|| bus
->state
== BUS_HELLO
);
2506 r
= process_timeout(bus
);
2510 r
= dispatch_wqueue(bus
);
2514 r
= dispatch_track(bus
);
2518 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2524 r
= process_message(bus
, m
);
2529 r
= sd_bus_message_rewind(m
, true);
2538 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2540 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2541 strna(sd_bus_message_get_sender(m
)),
2542 strna(sd_bus_message_get_path(m
)),
2543 strna(sd_bus_message_get_interface(m
)),
2544 strna(sd_bus_message_get_member(m
)));
2546 r
= sd_bus_reply_method_errorf(
2548 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2549 "Unknown object '%s'.", m
->path
);
2563 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2564 _cleanup_bus_message_unref_ sd_bus_message
*m
= NULL
;
2565 struct reply_callback
*c
;
2569 assert(bus
->state
== BUS_CLOSING
);
2571 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2573 _cleanup_bus_error_free_ sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2576 /* First, fail all outstanding method calls */
2577 r
= bus_message_new_synthetic_error(
2580 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2585 r
= bus_seal_synthetic_message(bus
, m
);
2589 if (c
->timeout
!= 0) {
2590 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2594 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2597 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2599 bus
->iteration_counter
++;
2601 bus
->current_message
= m
;
2602 bus
->current_slot
= sd_bus_slot_ref(slot
);
2603 bus
->current_handler
= c
->callback
;
2604 bus
->current_userdata
= slot
->userdata
;
2605 r
= c
->callback(bus
, m
, slot
->userdata
, &error_buffer
);
2606 bus
->current_userdata
= NULL
;
2607 bus
->current_handler
= NULL
;
2608 bus
->current_slot
= NULL
;
2609 bus
->current_message
= NULL
;
2611 if (slot
->floating
) {
2612 bus_slot_disconnect(slot
);
2613 sd_bus_slot_unref(slot
);
2616 sd_bus_slot_unref(slot
);
2618 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2621 /* Then, synthesize a Disconnected message */
2622 r
= sd_bus_message_new_signal(
2625 "/org/freedesktop/DBus/Local",
2626 "org.freedesktop.DBus.Local",
2631 bus_message_set_sender_local(bus
, m
);
2633 r
= bus_seal_synthetic_message(bus
, m
);
2639 bus
->current_message
= m
;
2640 bus
->iteration_counter
++;
2642 r
= process_filter(bus
, m
);
2646 r
= process_match(bus
, m
);
2658 bus
->current_message
= NULL
;
2663 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2664 BUS_DONT_DESTROY(bus
);
2667 /* Returns 0 when we didn't do anything. This should cause the
2668 * caller to invoke sd_bus_wait() before returning the next
2669 * time. Returns > 0 when we did something, which possibly
2670 * means *ret is filled in with an unprocessed message. */
2672 assert_return(bus
, -EINVAL
);
2673 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2675 /* We don't allow recursively invoking sd_bus_process(). */
2676 assert_return(!bus
->current_message
, -EBUSY
);
2677 assert(!bus
->current_slot
);
2679 switch (bus
->state
) {
2688 r
= bus_socket_process_opening(bus
);
2689 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2690 bus_enter_closing(bus
);
2698 case BUS_AUTHENTICATING
:
2699 r
= bus_socket_process_authenticating(bus
);
2700 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2701 bus_enter_closing(bus
);
2713 r
= process_running(bus
, hint_priority
, priority
, ret
);
2714 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2715 bus_enter_closing(bus
);
2725 return process_closing(bus
, ret
);
2728 assert_not_reached("Unknown state");
2731 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2732 return bus_process_internal(bus
, false, 0, ret
);
2735 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2736 return bus_process_internal(bus
, true, priority
, ret
);
2739 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2740 struct pollfd p
[2] = {};
2743 usec_t m
= USEC_INFINITY
;
2747 if (bus
->state
== BUS_CLOSING
)
2750 if (!BUS_IS_OPEN(bus
->state
))
2753 e
= sd_bus_get_events(bus
);
2758 /* The caller really needs some more data, he doesn't
2759 * care about what's already read, or any timeouts
2760 * except its own. */
2764 /* The caller wants to process if there's something to
2765 * process, but doesn't care otherwise */
2767 r
= sd_bus_get_timeout(bus
, &until
);
2772 nw
= now(CLOCK_MONOTONIC
);
2773 m
= until
> nw
? until
- nw
: 0;
2777 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2780 p
[0].fd
= bus
->input_fd
;
2781 if (bus
->output_fd
== bus
->input_fd
) {
2785 p
[0].events
= e
& POLLIN
;
2786 p
[1].fd
= bus
->output_fd
;
2787 p
[1].events
= e
& POLLOUT
;
2791 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2795 return r
> 0 ? 1 : 0;
2798 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2800 assert_return(bus
, -EINVAL
);
2801 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2803 if (bus
->state
== BUS_CLOSING
)
2806 if (!BUS_IS_OPEN(bus
->state
))
2809 if (bus
->rqueue_size
> 0)
2812 return bus_poll(bus
, false, timeout_usec
);
2815 _public_
int sd_bus_flush(sd_bus
*bus
) {
2818 assert_return(bus
, -EINVAL
);
2819 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2821 if (bus
->state
== BUS_CLOSING
)
2824 if (!BUS_IS_OPEN(bus
->state
))
2827 r
= bus_ensure_running(bus
);
2831 if (bus
->wqueue_size
<= 0)
2835 r
= dispatch_wqueue(bus
);
2837 if (r
== -ENOTCONN
|| r
== -ECONNRESET
|| r
== -EPIPE
|| r
== -ESHUTDOWN
) {
2838 bus_enter_closing(bus
);
2845 if (bus
->wqueue_size
<= 0)
2848 r
= bus_poll(bus
, false, (uint64_t) -1);
2854 _public_
int sd_bus_add_filter(
2857 sd_bus_message_handler_t callback
,
2862 assert_return(bus
, -EINVAL
);
2863 assert_return(callback
, -EINVAL
);
2864 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2866 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2870 s
->filter_callback
.callback
= callback
;
2872 bus
->filter_callbacks_modified
= true;
2873 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2881 _public_
int sd_bus_add_match(
2885 sd_bus_message_handler_t callback
,
2888 struct bus_match_component
*components
= NULL
;
2889 unsigned n_components
= 0;
2890 sd_bus_slot
*s
= NULL
;
2893 assert_return(bus
, -EINVAL
);
2894 assert_return(match
, -EINVAL
);
2895 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2897 r
= bus_match_parse(match
, &components
, &n_components
);
2901 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2907 s
->match_callback
.callback
= callback
;
2908 s
->match_callback
.cookie
= ++bus
->match_cookie
;
2910 if (bus
->bus_client
) {
2912 if (!bus
->is_kernel
) {
2913 /* When this is not a kernel transport, we
2914 * store the original match string, so that we
2915 * can use it to remove the match again */
2917 s
->match_callback
.match_string
= strdup(match
);
2918 if (!s
->match_callback
.match_string
) {
2924 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
, s
->match_callback
.cookie
);
2929 bus
->match_callbacks_modified
= true;
2930 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2939 bus_match_parse_free(components
, n_components
);
2940 sd_bus_slot_unref(s
);
2945 int bus_remove_match_by_string(
2948 sd_bus_message_handler_t callback
,
2951 struct bus_match_component
*components
= NULL
;
2952 unsigned n_components
= 0;
2953 struct match_callback
*c
;
2956 assert_return(bus
, -EINVAL
);
2957 assert_return(match
, -EINVAL
);
2958 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2960 r
= bus_match_parse(match
, &components
, &n_components
);
2964 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
2968 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
2971 bus_match_parse_free(components
, n_components
);
2976 bool bus_pid_changed(sd_bus
*bus
) {
2979 /* We don't support people creating a bus connection and
2980 * keeping it around over a fork(). Let's complain. */
2982 return bus
->original_pid
!= getpid();
2985 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
2986 sd_bus
*bus
= userdata
;
2991 r
= sd_bus_process(bus
, NULL
);
2998 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
2999 sd_bus
*bus
= userdata
;
3004 r
= sd_bus_process(bus
, NULL
);
3011 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3012 sd_bus
*bus
= userdata
;
3019 e
= sd_bus_get_events(bus
);
3023 if (bus
->output_fd
!= bus
->input_fd
) {
3025 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3029 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3033 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3038 r
= sd_bus_get_timeout(bus
, &until
);
3044 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3049 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3056 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3057 sd_bus
*bus
= userdata
;
3067 static int attach_io_events(sd_bus
*bus
) {
3072 if (bus
->input_fd
< 0)
3078 if (!bus
->input_io_event_source
) {
3079 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3083 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3087 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3091 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3093 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3098 if (bus
->output_fd
!= bus
->input_fd
) {
3099 assert(bus
->output_fd
>= 0);
3101 if (!bus
->output_io_event_source
) {
3102 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3106 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3110 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3112 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3121 static void detach_io_events(sd_bus
*bus
) {
3124 if (bus
->input_io_event_source
) {
3125 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3126 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3129 if (bus
->output_io_event_source
) {
3130 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3131 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3135 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3138 assert_return(bus
, -EINVAL
);
3139 assert_return(!bus
->event
, -EBUSY
);
3141 assert(!bus
->input_io_event_source
);
3142 assert(!bus
->output_io_event_source
);
3143 assert(!bus
->time_event_source
);
3146 bus
->event
= sd_event_ref(event
);
3148 r
= sd_event_default(&bus
->event
);
3153 bus
->event_priority
= priority
;
3155 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3159 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3163 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3167 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3171 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3175 r
= attach_io_events(bus
);
3182 sd_bus_detach_event(bus
);
3186 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3187 assert_return(bus
, -EINVAL
);
3192 detach_io_events(bus
);
3194 if (bus
->time_event_source
) {
3195 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3196 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3199 if (bus
->quit_event_source
) {
3200 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3201 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3204 bus
->event
= sd_event_unref(bus
->event
);
3208 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3209 assert_return(bus
, NULL
);
3214 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3215 assert_return(bus
, NULL
);
3217 return bus
->current_message
;
3220 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3221 assert_return(bus
, NULL
);
3223 return bus
->current_slot
;
3226 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3227 assert_return(bus
, NULL
);
3229 return bus
->current_handler
;
3232 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3233 assert_return(bus
, NULL
);
3235 return bus
->current_userdata
;
3238 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3243 assert(default_bus
);
3246 return !!*default_bus
;
3249 *ret
= sd_bus_ref(*default_bus
);
3257 b
->default_bus_ptr
= default_bus
;
3265 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3266 static thread_local sd_bus
*default_system_bus
= NULL
;
3268 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3271 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3272 static thread_local sd_bus
*default_user_bus
= NULL
;
3274 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3277 _public_
int sd_bus_default(sd_bus
**ret
) {
3281 /* Let's try our best to reuse another cached connection. If
3282 * the starter bus type is set, connect via our normal
3283 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3284 * we can share the connection with the user/system default
3287 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3289 if (streq(e
, "system"))
3290 return sd_bus_default_system(ret
);
3291 else if (STR_IN_SET(e
, "user", "session"))
3292 return sd_bus_default_user(ret
);
3295 /* No type is specified, so we have not other option than to
3296 * use the starter address if it is set. */
3298 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3300 static thread_local sd_bus
*default_starter_bus
= NULL
;
3302 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3305 /* Finally, if nothing is set use the cached connection for
3306 * the right scope */
3308 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3309 return sd_bus_default_user(ret
);
3311 return sd_bus_default_system(ret
);
3314 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3315 assert_return(b
, -EINVAL
);
3316 assert_return(tid
, -EINVAL
);
3317 assert_return(!bus_pid_changed(b
), -ECHILD
);
3325 return sd_event_get_tid(b
->event
, tid
);
3330 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3331 _cleanup_free_
char *e
= NULL
;
3334 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3335 assert_return(external_id
, -EINVAL
);
3336 assert_return(ret_path
, -EINVAL
);
3338 e
= bus_label_escape(external_id
);
3342 ret
= strjoin(prefix
, "/", e
, NULL
);
3350 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3354 assert_return(object_path_is_valid(path
), -EINVAL
);
3355 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3356 assert_return(external_id
, -EINVAL
);
3358 e
= object_path_startswith(path
, prefix
);
3360 *external_id
= NULL
;
3364 ret
= bus_label_unescape(e
);
3372 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3375 assert_return(bus
, -EINVAL
);
3376 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3378 if (!bus
->is_kernel
)
3381 if (!BUS_IS_OPEN(bus
->state
))
3384 if (bus
->rqueue_size
> 0)
3387 if (bus
->wqueue_size
> 0)
3390 r
= bus_kernel_try_close(bus
);
3398 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3399 assert_return(bus
, -EINVAL
);
3400 assert_return(description
, -EINVAL
);
3401 assert_return(bus
->description
, -ENXIO
);
3402 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3404 *description
= bus
->description
;
3408 int bus_get_root_path(sd_bus
*bus
) {
3411 if (bus
->cgroup_root
)
3414 r
= cg_get_root_path(&bus
->cgroup_root
);
3416 bus
->cgroup_root
= strdup("/");
3417 if (!bus
->cgroup_root
)
3426 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3429 assert_return(bus
, -EINVAL
);
3430 assert_return(scope
, -EINVAL
);
3431 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3433 if (bus
->is_kernel
) {
3434 _cleanup_free_
char *n
= NULL
;
3437 r
= bus_kernel_get_bus_name(bus
, &n
);
3441 if (streq(n
, "0-system")) {
3446 dash
= strchr(n
, '-');
3447 if (streq_ptr(dash
, "-user")) {
3458 if (bus
->is_system
) {
3466 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3468 assert_return(bus
, -EINVAL
);
3469 assert_return(address
, -EINVAL
);
3470 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3473 *address
= bus
->address
;
3480 int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3481 assert_return(bus
, -EINVAL
);
3482 assert_return(mask
, -EINVAL
);
3483 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3485 *mask
= bus
->creds_mask
;
3489 int sd_bus_is_bus_client(sd_bus
*bus
) {
3490 assert_return(bus
, -EINVAL
);
3491 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3493 return bus
->bus_client
;
3496 int sd_bus_is_server(sd_bus
*bus
) {
3497 assert_return(bus
, -EINVAL
);
3498 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3500 return bus
->is_server
;
3503 int sd_bus_is_anonymous(sd_bus
*bus
) {
3504 assert_return(bus
, -EINVAL
);
3505 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3507 return bus
->anonymous_auth
;
3510 int sd_bus_is_trusted(sd_bus
*bus
) {
3511 assert_return(bus
, -EINVAL
);
3512 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3514 return bus
->trusted
;
3517 int sd_bus_is_monitor(sd_bus
*bus
) {
3518 assert_return(bus
, -EINVAL
);
3519 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3521 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);