1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2013 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
31 #include "alloc-util.h"
32 #include "bus-container.h"
33 #include "bus-control.h"
34 #include "bus-internal.h"
35 #include "bus-kernel.h"
36 #include "bus-label.h"
37 #include "bus-message.h"
38 #include "bus-objects.h"
39 #include "bus-protocol.h"
41 #include "bus-socket.h"
42 #include "bus-track.h"
45 #include "cgroup-util.h"
48 #include "hexdecoct.h"
49 #include "hostname-util.h"
52 #include "parse-util.h"
53 #include "string-util.h"
57 #define log_debug_bus_message(m) \
59 sd_bus_message *_mm = (m); \
60 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error-name=%s error-message=%s", \
61 bus_message_type_to_string(_mm->header->type), \
62 strna(sd_bus_message_get_sender(_mm)), \
63 strna(sd_bus_message_get_destination(_mm)), \
64 strna(sd_bus_message_get_path(_mm)), \
65 strna(sd_bus_message_get_interface(_mm)), \
66 strna(sd_bus_message_get_member(_mm)), \
67 BUS_MESSAGE_COOKIE(_mm), \
69 strna(_mm->error.name), \
70 strna(_mm->error.message)); \
73 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
74 static int attach_io_events(sd_bus
*b
);
75 static void detach_io_events(sd_bus
*b
);
77 static thread_local sd_bus
*default_system_bus
= NULL
;
78 static thread_local sd_bus
*default_user_bus
= NULL
;
79 static thread_local sd_bus
*default_starter_bus
= NULL
;
81 static void bus_close_fds(sd_bus
*b
) {
86 if (b
->input_fd
!= b
->output_fd
)
87 safe_close(b
->output_fd
);
88 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
91 static void bus_reset_queues(sd_bus
*b
) {
94 while (b
->rqueue_size
> 0)
95 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
97 b
->rqueue
= mfree(b
->rqueue
);
98 b
->rqueue_allocated
= 0;
100 while (b
->wqueue_size
> 0)
101 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
103 b
->wqueue
= mfree(b
->wqueue
);
104 b
->wqueue_allocated
= 0;
107 static void bus_free(sd_bus
*b
) {
111 assert(!b
->track_queue
);
114 b
->state
= BUS_CLOSED
;
116 sd_bus_detach_event(b
);
118 while ((s
= b
->slots
)) {
119 /* At this point only floating slots can still be
120 * around, because the non-floating ones keep a
121 * reference to the bus, and we thus couldn't be
122 * destructing right now... We forcibly disconnect the
123 * slots here, so that they still can be referenced by
124 * apps, but are dead. */
127 bus_slot_disconnect(s
);
128 sd_bus_slot_unref(s
);
131 if (b
->default_bus_ptr
)
132 *b
->default_bus_ptr
= NULL
;
138 free(b
->unique_name
);
139 free(b
->auth_buffer
);
142 free(b
->cgroup_root
);
143 free(b
->description
);
146 strv_free(b
->exec_argv
);
148 close_many(b
->fds
, b
->n_fds
);
153 ordered_hashmap_free_free(b
->reply_callbacks
);
154 prioq_free(b
->reply_callbacks_prioq
);
156 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
157 bus_match_free(&b
->match_callbacks
);
159 hashmap_free_free(b
->vtable_methods
);
160 hashmap_free_free(b
->vtable_properties
);
162 assert(hashmap_isempty(b
->nodes
));
163 hashmap_free(b
->nodes
);
167 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
172 _public_
int sd_bus_new(sd_bus
**ret
) {
175 assert_return(ret
, -EINVAL
);
181 r
->n_ref
= REFCNT_INIT
;
182 r
->input_fd
= r
->output_fd
= -1;
183 r
->message_version
= 1;
184 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
185 r
->hello_flags
|= KDBUS_HELLO_ACCEPT_FD
;
186 r
->attach_flags
|= KDBUS_ATTACH_NAMES
;
187 r
->original_pid
= getpid_cached();
189 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
191 /* We guarantee that wqueue always has space for at least one
193 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
202 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
205 assert_return(bus
, -EINVAL
);
206 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
207 assert_return(address
, -EINVAL
);
208 assert_return(!bus_pid_changed(bus
), -ECHILD
);
220 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
221 assert_return(bus
, -EINVAL
);
222 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
223 assert_return(input_fd
>= 0, -EBADF
);
224 assert_return(output_fd
>= 0, -EBADF
);
225 assert_return(!bus_pid_changed(bus
), -ECHILD
);
227 bus
->input_fd
= input_fd
;
228 bus
->output_fd
= output_fd
;
232 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
235 assert_return(bus
, -EINVAL
);
236 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
237 assert_return(path
, -EINVAL
);
238 assert_return(!strv_isempty(argv
), -EINVAL
);
239 assert_return(!bus_pid_changed(bus
), -ECHILD
);
251 free(bus
->exec_path
);
252 strv_free(bus
->exec_argv
);
260 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
261 assert_return(bus
, -EINVAL
);
262 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
263 assert_return(!bus_pid_changed(bus
), -ECHILD
);
265 bus
->bus_client
= !!b
;
269 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
270 assert_return(bus
, -EINVAL
);
271 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
272 assert_return(!bus_pid_changed(bus
), -ECHILD
);
274 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_MONITOR
, b
);
278 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
279 assert_return(bus
, -EINVAL
);
280 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
281 assert_return(!bus_pid_changed(bus
), -ECHILD
);
283 SET_FLAG(bus
->hello_flags
, KDBUS_HELLO_ACCEPT_FD
, b
);
287 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
289 assert_return(bus
, -EINVAL
);
290 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
291 assert_return(!bus_pid_changed(bus
), -ECHILD
);
293 new_flags
= bus
->attach_flags
;
294 SET_FLAG(new_flags
, KDBUS_ATTACH_TIMESTAMP
, b
);
296 if (bus
->attach_flags
== new_flags
)
299 bus
->attach_flags
= new_flags
;
304 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
307 assert_return(bus
, -EINVAL
);
308 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
309 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
310 assert_return(!bus_pid_changed(bus
), -ECHILD
);
312 SET_FLAG(bus
->creds_mask
, mask
, b
);
314 /* The well knowns we need unconditionally, so that matches can work */
315 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
317 /* Make sure we don't lose the timestamp flag */
318 new_flags
= (bus
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) | attach_flags_to_kdbus(bus
->creds_mask
);
319 if (bus
->attach_flags
== new_flags
)
322 bus
->attach_flags
= new_flags
;
327 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
328 assert_return(bus
, -EINVAL
);
329 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
330 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
331 assert_return(!bus_pid_changed(bus
), -ECHILD
);
333 bus
->is_server
= !!b
;
334 bus
->server_id
= server_id
;
338 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
339 assert_return(bus
, -EINVAL
);
340 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
341 assert_return(!bus_pid_changed(bus
), -ECHILD
);
343 bus
->anonymous_auth
= !!b
;
347 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
348 assert_return(bus
, -EINVAL
);
349 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
350 assert_return(!bus_pid_changed(bus
), -ECHILD
);
356 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
357 assert_return(bus
, -EINVAL
);
358 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
359 assert_return(!bus_pid_changed(bus
), -ECHILD
);
361 return free_and_strdup(&bus
->description
, description
);
364 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
365 assert_return(bus
, -EINVAL
);
366 assert_return(!bus_pid_changed(bus
), -ECHILD
);
368 bus
->allow_interactive_authorization
= !!b
;
372 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
373 assert_return(bus
, -EINVAL
);
374 assert_return(!bus_pid_changed(bus
), -ECHILD
);
376 return bus
->allow_interactive_authorization
;
379 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
387 assert(IN_SET(bus
->state
, BUS_HELLO
, BUS_CLOSING
));
389 r
= sd_bus_message_get_errno(reply
);
393 r
= sd_bus_message_read(reply
, "s", &s
);
397 if (!service_name_is_valid(s
) || s
[0] != ':')
400 bus
->unique_name
= strdup(s
);
401 if (!bus
->unique_name
)
404 if (bus
->state
== BUS_HELLO
)
405 bus
->state
= BUS_RUNNING
;
410 static int bus_send_hello(sd_bus
*bus
) {
411 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
416 if (!bus
->bus_client
)
419 r
= sd_bus_message_new_method_call(
422 "org.freedesktop.DBus",
423 "/org/freedesktop/DBus",
424 "org.freedesktop.DBus",
429 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
432 int bus_start_running(sd_bus
*bus
) {
435 if (bus
->bus_client
) {
436 bus
->state
= BUS_HELLO
;
440 bus
->state
= BUS_RUNNING
;
444 static int parse_address_key(const char **p
, const char *key
, char **value
) {
445 size_t l
, n
= 0, allocated
= 0;
455 if (strncmp(*p
, key
, l
) != 0)
468 while (!IN_SET(*a
, ';', ',', 0)) {
486 c
= (char) ((x
<< 4) | y
);
493 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
517 static void skip_address_key(const char **p
) {
521 *p
+= strcspn(*p
, ",");
527 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
528 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
537 while (!IN_SET(**p
, 0, ';')) {
538 r
= parse_address_key(p
, "guid", guid
);
544 r
= parse_address_key(p
, "path", &path
);
550 r
= parse_address_key(p
, "abstract", &abstract
);
559 if (!path
&& !abstract
)
562 if (path
&& abstract
)
567 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
570 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
571 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
572 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
573 } else if (abstract
) {
574 l
= strlen(abstract
);
575 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
578 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
579 b
->sockaddr
.un
.sun_path
[0] = 0;
580 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
581 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
589 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
590 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
592 struct addrinfo
*result
, hints
= {
593 .ai_socktype
= SOCK_STREAM
,
594 .ai_flags
= AI_ADDRCONFIG
,
602 while (!IN_SET(**p
, 0, ';')) {
603 r
= parse_address_key(p
, "guid", guid
);
609 r
= parse_address_key(p
, "host", &host
);
615 r
= parse_address_key(p
, "port", &port
);
621 r
= parse_address_key(p
, "family", &family
);
634 if (streq(family
, "ipv4"))
635 hints
.ai_family
= AF_INET
;
636 else if (streq(family
, "ipv6"))
637 hints
.ai_family
= AF_INET6
;
642 r
= getaddrinfo(host
, port
, &hints
, &result
);
646 return -EADDRNOTAVAIL
;
648 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
649 b
->sockaddr_size
= result
->ai_addrlen
;
651 freeaddrinfo(result
);
658 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
660 unsigned n_argv
= 0, j
;
662 size_t allocated
= 0;
670 while (!IN_SET(**p
, 0, ';')) {
671 r
= parse_address_key(p
, "guid", guid
);
677 r
= parse_address_key(p
, "path", &path
);
683 if (startswith(*p
, "argv")) {
687 ul
= strtoul(*p
+ 4, (char**) p
, 10);
688 if (errno
> 0 || **p
!= '=' || ul
> 256) {
696 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
704 r
= parse_address_key(p
, NULL
, argv
+ ul
);
719 /* Make sure there are no holes in the array, with the
720 * exception of argv[0] */
721 for (j
= 1; j
< n_argv
; j
++)
727 if (argv
&& argv
[0] == NULL
) {
728 argv
[0] = strdup(path
);
743 for (j
= 0; j
< n_argv
; j
++)
751 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
752 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
760 while (!IN_SET(**p
, 0, ';')) {
761 r
= parse_address_key(p
, "guid", guid
);
767 r
= parse_address_key(p
, "machine", &machine
);
773 r
= parse_address_key(p
, "pid", &pid
);
782 if (!machine
== !pid
)
786 if (!machine_name_is_valid(machine
))
789 free_and_replace(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 (!IN_SET(bus
->state
, BUS_OPENING
, BUS_AUTHENTICATING
, BUS_HELLO
, BUS_RUNNING
))
1325 bus
->state
= BUS_CLOSING
;
1328 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1333 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1338 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1344 i
= REFCNT_DEC(bus
->n_ref
);
1352 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1354 assert_return(bus
, -EINVAL
);
1355 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1357 return BUS_IS_OPEN(bus
->state
);
1360 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1363 assert_return(bus
, -EINVAL
);
1364 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1365 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1367 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
1370 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1371 if (!(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
))
1374 r
= bus_ensure_running(bus
);
1378 return bus
->can_fds
;
1381 return bus_type_is_valid(type
);
1384 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1387 assert_return(bus
, -EINVAL
);
1388 assert_return(id
, -EINVAL
);
1389 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1391 r
= bus_ensure_running(bus
);
1395 *id
= bus
->server_id
;
1399 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1404 /* If we copy the same message to multiple
1405 * destinations, avoid using the same cookie
1407 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1412 timeout
= BUS_DEFAULT_TIMEOUT
;
1414 return sd_bus_message_seal(m
, ++b
->cookie
, timeout
);
1417 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1418 bool remarshal
= false;
1422 /* wrong packet version */
1423 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1426 /* wrong packet endianness */
1427 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1430 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1433 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1437 /* Fake some timestamps, if they were requested, and not
1438 * already initialized */
1439 if (b
->attach_flags
& KDBUS_ATTACH_TIMESTAMP
) {
1440 if (m
->realtime
<= 0)
1441 m
->realtime
= now(CLOCK_REALTIME
);
1443 if (m
->monotonic
<= 0)
1444 m
->monotonic
= now(CLOCK_MONOTONIC
);
1447 /* The bus specification says the serial number cannot be 0,
1448 * hence let's fill something in for synthetic messages. Since
1449 * synthetic messages might have a fake sender and we don't
1450 * want to interfere with the real sender's serial numbers we
1451 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1452 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1453 * even though kdbus can do 64bit. */
1454 return sd_bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1457 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, bool hint_sync_call
, size_t *idx
) {
1463 r
= bus_socket_write_message(bus
, m
, idx
);
1467 if (*idx
>= BUS_MESSAGE_SIZE(m
))
1468 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" error-name=%s error-message=%s",
1469 bus_message_type_to_string(m
->header
->type
),
1470 strna(sd_bus_message_get_sender(m
)),
1471 strna(sd_bus_message_get_destination(m
)),
1472 strna(sd_bus_message_get_path(m
)),
1473 strna(sd_bus_message_get_interface(m
)),
1474 strna(sd_bus_message_get_member(m
)),
1475 BUS_MESSAGE_COOKIE(m
),
1477 strna(m
->error
.name
),
1478 strna(m
->error
.message
));
1483 static int dispatch_wqueue(sd_bus
*bus
) {
1487 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
1489 while (bus
->wqueue_size
> 0) {
1491 r
= bus_write_message(bus
, bus
->wqueue
[0], false, &bus
->windex
);
1495 /* Didn't do anything this time */
1497 else if (bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1498 /* Fully written. Let's drop the entry from
1501 * This isn't particularly optimized, but
1502 * well, this is supposed to be our worst-case
1503 * buffer only, and the socket buffer is
1504 * supposed to be our primary buffer, and if
1505 * it got full, then all bets are off
1509 sd_bus_message_unref(bus
->wqueue
[0]);
1510 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1520 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1523 return bus_socket_read_message(bus
);
1526 int bus_rqueue_make_room(sd_bus
*bus
) {
1529 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1532 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1538 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1543 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
1545 /* Note that the priority logic is only available on kdbus,
1546 * where the rqueue is unused. We check the rqueue here
1547 * anyway, because it's simple... */
1550 if (bus
->rqueue_size
> 0) {
1551 /* Dispatch a queued message */
1553 *m
= bus
->rqueue
[0];
1555 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1559 /* Try to read a new message */
1560 r
= bus_read_message(bus
, hint_priority
, priority
);
1570 static int bus_send_internal(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
, bool hint_sync_call
) {
1571 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1574 assert_return(m
, -EINVAL
);
1579 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1581 if (!BUS_IS_OPEN(bus
->state
))
1585 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1592 /* If the cookie number isn't kept, then we know that no reply
1594 if (!cookie
&& !m
->sealed
)
1595 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1597 r
= bus_seal_message(bus
, m
, 0);
1601 /* Remarshall if we have to. This will possibly unref the
1602 * message and place a replacement in m */
1603 r
= bus_remarshal_message(bus
, &m
);
1607 /* If this is a reply and no reply was requested, then let's
1608 * suppress this, if we can */
1612 if (IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1615 r
= bus_write_message(bus
, m
, hint_sync_call
, &idx
);
1617 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1618 bus_enter_closing(bus
);
1625 if (idx
< BUS_MESSAGE_SIZE(m
)) {
1626 /* Wasn't fully written. So let's remember how
1627 * much was written. Note that the first entry
1628 * of the wqueue array is always allocated so
1629 * that we always can remember how much was
1631 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1632 bus
->wqueue_size
= 1;
1637 /* Just append it to the queue. */
1639 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1642 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1645 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1650 *cookie
= BUS_MESSAGE_COOKIE(m
);
1655 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*m
, uint64_t *cookie
) {
1656 return bus_send_internal(bus
, m
, cookie
, false);
1659 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1662 assert_return(m
, -EINVAL
);
1667 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1669 if (!BUS_IS_OPEN(bus
->state
))
1672 if (!streq_ptr(m
->destination
, destination
)) {
1677 r
= sd_bus_message_set_destination(m
, destination
);
1682 return sd_bus_send(bus
, m
, cookie
);
1685 static usec_t
calc_elapse(uint64_t usec
) {
1686 if (usec
== (uint64_t) -1)
1689 return now(CLOCK_MONOTONIC
) + usec
;
1692 static int timeout_compare(const void *a
, const void *b
) {
1693 const struct reply_callback
*x
= a
, *y
= b
;
1695 if (x
->timeout
!= 0 && y
->timeout
== 0)
1698 if (x
->timeout
== 0 && y
->timeout
!= 0)
1701 if (x
->timeout
< y
->timeout
)
1704 if (x
->timeout
> y
->timeout
)
1710 _public_
int sd_bus_call_async(
1714 sd_bus_message_handler_t callback
,
1718 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1719 _cleanup_(sd_bus_slot_unrefp
) sd_bus_slot
*s
= NULL
;
1722 assert_return(m
, -EINVAL
);
1723 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1724 assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
);
1725 assert_return(callback
, -EINVAL
);
1730 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1732 if (!BUS_IS_OPEN(bus
->state
))
1735 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1739 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1743 r
= bus_seal_message(bus
, m
, usec
);
1747 r
= bus_remarshal_message(bus
, &m
);
1751 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
1755 s
->reply_callback
.callback
= callback
;
1757 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
1758 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
1760 s
->reply_callback
.cookie
= 0;
1764 s
->reply_callback
.timeout
= calc_elapse(m
->timeout
);
1765 if (s
->reply_callback
.timeout
!= 0) {
1766 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
1768 s
->reply_callback
.timeout
= 0;
1773 r
= sd_bus_send(bus
, m
, &s
->reply_callback
.cookie
);
1784 int bus_ensure_running(sd_bus
*bus
) {
1789 if (IN_SET(bus
->state
, BUS_UNSET
, BUS_CLOSED
, BUS_CLOSING
))
1791 if (bus
->state
== BUS_RUNNING
)
1795 r
= sd_bus_process(bus
, NULL
);
1798 if (bus
->state
== BUS_RUNNING
)
1803 r
= sd_bus_wait(bus
, (uint64_t) -1);
1809 _public_
int sd_bus_call(
1813 sd_bus_error
*error
,
1814 sd_bus_message
**reply
) {
1816 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1822 bus_assert_return(m
, -EINVAL
, error
);
1823 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
1824 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
1825 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
1830 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
1832 if (!BUS_IS_OPEN(bus
->state
)) {
1837 r
= bus_ensure_running(bus
);
1841 i
= bus
->rqueue_size
;
1843 r
= bus_seal_message(bus
, m
, usec
);
1847 r
= bus_remarshal_message(bus
, &m
);
1851 r
= bus_send_internal(bus
, m
, &cookie
, true);
1855 timeout
= calc_elapse(m
->timeout
);
1860 while (i
< bus
->rqueue_size
) {
1861 sd_bus_message
*incoming
= NULL
;
1863 incoming
= bus
->rqueue
[i
];
1865 if (incoming
->reply_cookie
== cookie
) {
1866 /* Found a match! */
1868 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
1870 log_debug_bus_message(incoming
);
1872 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
1874 if (incoming
->n_fds
<= 0 || (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
1878 sd_bus_message_unref(incoming
);
1883 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1884 sd_bus_message_unref(incoming
);
1887 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
1888 r
= sd_bus_error_copy(error
, &incoming
->error
);
1889 sd_bus_message_unref(incoming
);
1896 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
1899 streq(bus
->unique_name
, incoming
->sender
)) {
1901 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
1904 /* Our own message? Somebody is trying
1905 * to send its own client a message,
1906 * let's not dead-lock, let's fail
1909 sd_bus_message_unref(incoming
);
1914 /* Try to read more, right-away */
1918 r
= bus_read_message(bus
, false, 0);
1920 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1921 bus_enter_closing(bus
);
1933 n
= now(CLOCK_MONOTONIC
);
1941 left
= (uint64_t) -1;
1943 r
= bus_poll(bus
, true, left
);
1951 r
= dispatch_wqueue(bus
);
1953 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1954 bus_enter_closing(bus
);
1963 return sd_bus_error_set_errno(error
, r
);
1966 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
1968 assert_return(bus
, -EINVAL
);
1969 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
1970 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1972 return bus
->input_fd
;
1975 _public_
int sd_bus_get_events(sd_bus
*bus
) {
1978 assert_return(bus
, -EINVAL
);
1979 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1981 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
1984 if (bus
->state
== BUS_OPENING
)
1986 else if (bus
->state
== BUS_AUTHENTICATING
) {
1988 if (bus_socket_auth_needs_write(bus
))
1993 } else if (IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
)) {
1994 if (bus
->rqueue_size
<= 0)
1996 if (bus
->wqueue_size
> 0)
2003 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2004 struct reply_callback
*c
;
2006 assert_return(bus
, -EINVAL
);
2007 assert_return(timeout_usec
, -EINVAL
);
2008 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2010 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2013 if (bus
->track_queue
) {
2018 if (bus
->state
== BUS_CLOSING
) {
2023 if (bus
->state
== BUS_AUTHENTICATING
) {
2024 *timeout_usec
= bus
->auth_timeout
;
2028 if (!IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
)) {
2029 *timeout_usec
= (uint64_t) -1;
2033 if (bus
->rqueue_size
> 0) {
2038 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2040 *timeout_usec
= (uint64_t) -1;
2044 if (c
->timeout
== 0) {
2045 *timeout_usec
= (uint64_t) -1;
2049 *timeout_usec
= c
->timeout
;
2053 static int process_timeout(sd_bus
*bus
) {
2054 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2055 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
* m
= NULL
;
2056 struct reply_callback
*c
;
2063 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2067 n
= now(CLOCK_MONOTONIC
);
2071 r
= bus_message_new_synthetic_error(
2074 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2079 r
= bus_seal_synthetic_message(bus
, m
);
2083 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2086 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2089 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2091 bus
->iteration_counter
++;
2093 bus
->current_message
= m
;
2094 bus
->current_slot
= sd_bus_slot_ref(slot
);
2095 bus
->current_handler
= c
->callback
;
2096 bus
->current_userdata
= slot
->userdata
;
2097 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2098 bus
->current_userdata
= NULL
;
2099 bus
->current_handler
= NULL
;
2100 bus
->current_slot
= NULL
;
2101 bus
->current_message
= NULL
;
2103 if (slot
->floating
) {
2104 bus_slot_disconnect(slot
);
2105 sd_bus_slot_unref(slot
);
2108 sd_bus_slot_unref(slot
);
2110 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2113 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2117 if (bus
->state
!= BUS_HELLO
)
2120 /* Let's make sure the first message on the bus is the HELLO
2121 * reply. But note that we don't actually parse the message
2122 * here (we leave that to the usual handling), we just verify
2123 * we don't let any earlier msg through. */
2125 if (!IN_SET(m
->header
->type
, SD_BUS_MESSAGE_METHOD_RETURN
, SD_BUS_MESSAGE_METHOD_ERROR
))
2128 if (m
->reply_cookie
!= 1)
2134 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2135 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*synthetic_reply
= NULL
;
2136 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2137 struct reply_callback
*c
;
2144 if (!IN_SET(m
->header
->type
, SD_BUS_MESSAGE_METHOD_RETURN
, SD_BUS_MESSAGE_METHOD_ERROR
))
2147 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2150 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2156 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2158 if (m
->n_fds
> 0 && !(bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)) {
2160 /* If the reply contained a file descriptor which we
2161 * didn't want we pass an error instead. */
2163 r
= bus_message_new_synthetic_error(
2166 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2171 /* Copy over original timestamp */
2172 synthetic_reply
->realtime
= m
->realtime
;
2173 synthetic_reply
->monotonic
= m
->monotonic
;
2174 synthetic_reply
->seqnum
= m
->seqnum
;
2176 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2180 m
= synthetic_reply
;
2182 r
= sd_bus_message_rewind(m
, true);
2187 if (c
->timeout
!= 0) {
2188 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2192 bus
->current_slot
= sd_bus_slot_ref(slot
);
2193 bus
->current_handler
= c
->callback
;
2194 bus
->current_userdata
= slot
->userdata
;
2195 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2196 bus
->current_userdata
= NULL
;
2197 bus
->current_handler
= NULL
;
2198 bus
->current_slot
= NULL
;
2200 if (slot
->floating
) {
2201 bus_slot_disconnect(slot
);
2202 sd_bus_slot_unref(slot
);
2205 sd_bus_slot_unref(slot
);
2207 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2210 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2211 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2212 struct filter_callback
*l
;
2219 bus
->filter_callbacks_modified
= false;
2221 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2224 if (bus
->filter_callbacks_modified
)
2227 /* Don't run this more than once per iteration */
2228 if (l
->last_iteration
== bus
->iteration_counter
)
2231 l
->last_iteration
= bus
->iteration_counter
;
2233 r
= sd_bus_message_rewind(m
, true);
2237 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2239 bus
->current_slot
= sd_bus_slot_ref(slot
);
2240 bus
->current_handler
= l
->callback
;
2241 bus
->current_userdata
= slot
->userdata
;
2242 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2243 bus
->current_userdata
= NULL
;
2244 bus
->current_handler
= NULL
;
2245 bus
->current_slot
= sd_bus_slot_unref(slot
);
2247 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2253 } while (bus
->filter_callbacks_modified
);
2258 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2265 bus
->match_callbacks_modified
= false;
2267 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2271 } while (bus
->match_callbacks_modified
);
2276 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2277 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2283 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2286 if (bus
->manual_peer_interface
)
2289 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2292 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2295 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2298 if (streq_ptr(m
->member
, "Ping"))
2299 r
= sd_bus_message_new_method_return(m
, &reply
);
2300 else if (streq_ptr(m
->member
, "GetMachineId")) {
2304 r
= sd_id128_get_machine(&id
);
2308 r
= sd_bus_message_new_method_return(m
, &reply
);
2312 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2314 r
= sd_bus_message_new_method_errorf(
2316 SD_BUS_ERROR_UNKNOWN_METHOD
,
2317 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2323 r
= sd_bus_send(bus
, reply
, NULL
);
2330 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2334 /* If we got a message with a file descriptor which we didn't
2335 * want to accept, then let's drop it. How can this even
2336 * happen? For example, when the kernel queues a message into
2337 * an activatable names's queue which allows fds, and then is
2338 * delivered to us later even though we ourselves did not
2341 if (bus
->hello_flags
& KDBUS_HELLO_MONITOR
)
2347 if (bus
->hello_flags
& KDBUS_HELLO_ACCEPT_FD
)
2350 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2351 return 1; /* just eat it up */
2353 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2356 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2362 bus
->current_message
= m
;
2363 bus
->iteration_counter
++;
2365 log_debug_bus_message(m
);
2367 r
= process_hello(bus
, m
);
2371 r
= process_reply(bus
, m
);
2375 r
= process_fd_check(bus
, m
);
2379 r
= process_filter(bus
, m
);
2383 r
= process_match(bus
, m
);
2387 r
= process_builtin(bus
, m
);
2391 r
= bus_process_object(bus
, m
);
2394 bus
->current_message
= NULL
;
2398 static int dispatch_track(sd_bus
*bus
) {
2401 if (!bus
->track_queue
)
2404 bus_track_dispatch(bus
->track_queue
);
2408 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2409 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2413 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
2415 r
= process_timeout(bus
);
2419 r
= dispatch_wqueue(bus
);
2423 r
= dispatch_track(bus
);
2427 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2433 r
= process_message(bus
, m
);
2438 r
= sd_bus_message_rewind(m
, true);
2447 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2449 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2450 strna(sd_bus_message_get_sender(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
)));
2455 r
= sd_bus_reply_method_errorf(
2457 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2458 "Unknown object '%s'.", m
->path
);
2472 static int bus_exit_now(sd_bus
*bus
) {
2475 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2476 * sd_event_exit(), otherwise invokes libc exit(). */
2478 if (bus
->exited
) /* did we already exit? */
2480 if (!bus
->exit_triggered
) /* was the exit condition triggered? */
2482 if (!bus
->exit_on_disconnect
) /* Shall we actually exit on disconnection? */
2485 bus
->exited
= true; /* never exit more than once */
2487 log_debug("Bus connection disconnected, exiting.");
2490 return sd_event_exit(bus
->event
, EXIT_FAILURE
);
2494 assert_not_reached("exit() didn't exit?");
2497 static int process_closing_reply_callback(sd_bus
*bus
, struct reply_callback
*c
) {
2498 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2499 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2506 r
= bus_message_new_synthetic_error(
2509 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2514 r
= bus_seal_synthetic_message(bus
, m
);
2518 if (c
->timeout
!= 0) {
2519 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2523 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2526 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2528 bus
->iteration_counter
++;
2530 bus
->current_message
= m
;
2531 bus
->current_slot
= sd_bus_slot_ref(slot
);
2532 bus
->current_handler
= c
->callback
;
2533 bus
->current_userdata
= slot
->userdata
;
2534 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2535 bus
->current_userdata
= NULL
;
2536 bus
->current_handler
= NULL
;
2537 bus
->current_slot
= NULL
;
2538 bus
->current_message
= NULL
;
2540 if (slot
->floating
) {
2541 bus_slot_disconnect(slot
);
2542 sd_bus_slot_unref(slot
);
2545 sd_bus_slot_unref(slot
);
2547 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2550 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2551 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2552 struct reply_callback
*c
;
2556 assert(bus
->state
== BUS_CLOSING
);
2558 /* First, fail all outstanding method calls */
2559 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2561 return process_closing_reply_callback(bus
, c
);
2563 /* Then, fake-drop all remaining bus tracking references */
2565 bus_track_close(bus
->tracks
);
2569 /* Then, synthesize a Disconnected message */
2570 r
= sd_bus_message_new_signal(
2573 "/org/freedesktop/DBus/Local",
2574 "org.freedesktop.DBus.Local",
2579 bus_message_set_sender_local(bus
, m
);
2581 r
= bus_seal_synthetic_message(bus
, m
);
2587 bus
->current_message
= m
;
2588 bus
->iteration_counter
++;
2590 r
= process_filter(bus
, m
);
2594 r
= process_match(bus
, m
);
2598 /* Nothing else to do, exit now, if the condition holds */
2599 bus
->exit_triggered
= true;
2600 (void) bus_exit_now(bus
);
2610 bus
->current_message
= NULL
;
2615 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2616 BUS_DONT_DESTROY(bus
);
2619 /* Returns 0 when we didn't do anything. This should cause the
2620 * caller to invoke sd_bus_wait() before returning the next
2621 * time. Returns > 0 when we did something, which possibly
2622 * means *ret is filled in with an unprocessed message. */
2624 assert_return(bus
, -EINVAL
);
2625 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2627 /* We don't allow recursively invoking sd_bus_process(). */
2628 assert_return(!bus
->current_message
, -EBUSY
);
2629 assert(!bus
->current_slot
);
2631 switch (bus
->state
) {
2640 r
= bus_socket_process_opening(bus
);
2641 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2642 bus_enter_closing(bus
);
2650 case BUS_AUTHENTICATING
:
2651 r
= bus_socket_process_authenticating(bus
);
2652 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2653 bus_enter_closing(bus
);
2665 r
= process_running(bus
, hint_priority
, priority
, ret
);
2666 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2667 bus_enter_closing(bus
);
2677 return process_closing(bus
, ret
);
2680 assert_not_reached("Unknown state");
2683 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2684 return bus_process_internal(bus
, false, 0, ret
);
2687 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2688 return bus_process_internal(bus
, true, priority
, ret
);
2691 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2692 struct pollfd p
[2] = {};
2695 usec_t m
= USEC_INFINITY
;
2699 if (bus
->state
== BUS_CLOSING
)
2702 if (!BUS_IS_OPEN(bus
->state
))
2705 e
= sd_bus_get_events(bus
);
2710 /* The caller really needs some more data, he doesn't
2711 * care about what's already read, or any timeouts
2712 * except its own. */
2716 /* The caller wants to process if there's something to
2717 * process, but doesn't care otherwise */
2719 r
= sd_bus_get_timeout(bus
, &until
);
2724 nw
= now(CLOCK_MONOTONIC
);
2725 m
= until
> nw
? until
- nw
: 0;
2729 if (timeout_usec
!= (uint64_t) -1 && (m
== (uint64_t) -1 || timeout_usec
< m
))
2732 p
[0].fd
= bus
->input_fd
;
2733 if (bus
->output_fd
== bus
->input_fd
) {
2737 p
[0].events
= e
& POLLIN
;
2738 p
[1].fd
= bus
->output_fd
;
2739 p
[1].events
= e
& POLLOUT
;
2743 r
= ppoll(p
, n
, m
== (uint64_t) -1 ? NULL
: timespec_store(&ts
, m
), NULL
);
2747 return r
> 0 ? 1 : 0;
2750 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
2752 assert_return(bus
, -EINVAL
);
2753 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2755 if (bus
->state
== BUS_CLOSING
)
2758 if (!BUS_IS_OPEN(bus
->state
))
2761 if (bus
->rqueue_size
> 0)
2764 return bus_poll(bus
, false, timeout_usec
);
2767 _public_
int sd_bus_flush(sd_bus
*bus
) {
2770 assert_return(bus
, -EINVAL
);
2771 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2773 if (bus
->state
== BUS_CLOSING
)
2776 if (!BUS_IS_OPEN(bus
->state
))
2779 r
= bus_ensure_running(bus
);
2783 if (bus
->wqueue_size
<= 0)
2787 r
= dispatch_wqueue(bus
);
2789 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2790 bus_enter_closing(bus
);
2797 if (bus
->wqueue_size
<= 0)
2800 r
= bus_poll(bus
, false, (uint64_t) -1);
2806 _public_
int sd_bus_add_filter(
2809 sd_bus_message_handler_t callback
,
2814 assert_return(bus
, -EINVAL
);
2815 assert_return(callback
, -EINVAL
);
2816 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2818 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
2822 s
->filter_callback
.callback
= callback
;
2824 bus
->filter_callbacks_modified
= true;
2825 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
2833 _public_
int sd_bus_add_match(
2837 sd_bus_message_handler_t callback
,
2840 struct bus_match_component
*components
= NULL
;
2841 unsigned n_components
= 0;
2842 sd_bus_slot
*s
= NULL
;
2845 assert_return(bus
, -EINVAL
);
2846 assert_return(match
, -EINVAL
);
2847 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2849 r
= bus_match_parse(match
, &components
, &n_components
);
2853 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
2859 s
->match_callback
.callback
= callback
;
2861 if (bus
->bus_client
) {
2862 enum bus_match_scope scope
;
2864 scope
= bus_match_get_scope(components
, n_components
);
2866 /* Do not install server-side matches for matches
2867 * against the local service, interface or bus path. */
2868 if (scope
!= BUS_MATCH_LOCAL
) {
2870 /* We store the original match string, so that
2871 * we can use it to remove the match again. */
2873 s
->match_callback
.match_string
= strdup(match
);
2874 if (!s
->match_callback
.match_string
) {
2879 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
, components
, n_components
);
2883 s
->match_added
= true;
2887 bus
->match_callbacks_modified
= true;
2888 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
2897 bus_match_parse_free(components
, n_components
);
2898 sd_bus_slot_unref(s
);
2903 int bus_remove_match_by_string(
2906 sd_bus_message_handler_t callback
,
2909 struct bus_match_component
*components
= NULL
;
2910 unsigned n_components
= 0;
2911 struct match_callback
*c
;
2914 assert_return(bus
, -EINVAL
);
2915 assert_return(match
, -EINVAL
);
2916 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2918 r
= bus_match_parse(match
, &components
, &n_components
);
2922 r
= bus_match_find(&bus
->match_callbacks
, components
, n_components
, NULL
, NULL
, &c
);
2926 sd_bus_slot_unref(container_of(c
, sd_bus_slot
, match_callback
));
2929 bus_match_parse_free(components
, n_components
);
2934 bool bus_pid_changed(sd_bus
*bus
) {
2937 /* We don't support people creating a bus connection and
2938 * keeping it around over a fork(). Let's complain. */
2940 return bus
->original_pid
!= getpid_cached();
2943 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
2944 sd_bus
*bus
= userdata
;
2949 r
= sd_bus_process(bus
, NULL
);
2956 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
2957 sd_bus
*bus
= userdata
;
2962 r
= sd_bus_process(bus
, NULL
);
2969 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
2970 sd_bus
*bus
= userdata
;
2977 e
= sd_bus_get_events(bus
);
2981 if (bus
->output_fd
!= bus
->input_fd
) {
2983 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
2987 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
2991 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
2996 r
= sd_bus_get_timeout(bus
, &until
);
3002 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3007 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3014 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3015 sd_bus
*bus
= userdata
;
3025 static int attach_io_events(sd_bus
*bus
) {
3030 if (bus
->input_fd
< 0)
3036 if (!bus
->input_io_event_source
) {
3037 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3041 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3045 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3049 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3051 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3056 if (bus
->output_fd
!= bus
->input_fd
) {
3057 assert(bus
->output_fd
>= 0);
3059 if (!bus
->output_io_event_source
) {
3060 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3064 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3068 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3070 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3079 static void detach_io_events(sd_bus
*bus
) {
3082 if (bus
->input_io_event_source
) {
3083 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3084 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3087 if (bus
->output_io_event_source
) {
3088 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3089 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3093 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3096 assert_return(bus
, -EINVAL
);
3097 assert_return(!bus
->event
, -EBUSY
);
3099 assert(!bus
->input_io_event_source
);
3100 assert(!bus
->output_io_event_source
);
3101 assert(!bus
->time_event_source
);
3104 bus
->event
= sd_event_ref(event
);
3106 r
= sd_event_default(&bus
->event
);
3111 bus
->event_priority
= priority
;
3113 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3117 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3121 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3125 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3129 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3133 r
= attach_io_events(bus
);
3140 sd_bus_detach_event(bus
);
3144 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3145 assert_return(bus
, -EINVAL
);
3150 detach_io_events(bus
);
3152 if (bus
->time_event_source
) {
3153 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3154 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3157 if (bus
->quit_event_source
) {
3158 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3159 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3162 bus
->event
= sd_event_unref(bus
->event
);
3166 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3167 assert_return(bus
, NULL
);
3172 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3173 assert_return(bus
, NULL
);
3175 return bus
->current_message
;
3178 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3179 assert_return(bus
, NULL
);
3181 return bus
->current_slot
;
3184 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3185 assert_return(bus
, NULL
);
3187 return bus
->current_handler
;
3190 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3191 assert_return(bus
, NULL
);
3193 return bus
->current_userdata
;
3196 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3201 assert(default_bus
);
3204 return !!*default_bus
;
3207 *ret
= sd_bus_ref(*default_bus
);
3215 b
->default_bus_ptr
= default_bus
;
3223 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3224 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3228 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3229 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3232 _public_
int sd_bus_default(sd_bus
**ret
) {
3236 /* Let's try our best to reuse another cached connection. If
3237 * the starter bus type is set, connect via our normal
3238 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3239 * we can share the connection with the user/system default
3242 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
3244 if (streq(e
, "system"))
3245 return sd_bus_default_system(ret
);
3246 else if (STR_IN_SET(e
, "user", "session"))
3247 return sd_bus_default_user(ret
);
3250 /* No type is specified, so we have not other option than to
3251 * use the starter address if it is set. */
3253 e
= secure_getenv("DBUS_STARTER_ADDRESS");
3256 return bus_default(sd_bus_open
, &default_starter_bus
, ret
);
3259 /* Finally, if nothing is set use the cached connection for
3260 * the right scope */
3262 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
3263 return sd_bus_default_user(ret
);
3265 return sd_bus_default_system(ret
);
3268 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3269 assert_return(b
, -EINVAL
);
3270 assert_return(tid
, -EINVAL
);
3271 assert_return(!bus_pid_changed(b
), -ECHILD
);
3279 return sd_event_get_tid(b
->event
, tid
);
3284 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3285 _cleanup_free_
char *e
= NULL
;
3288 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3289 assert_return(external_id
, -EINVAL
);
3290 assert_return(ret_path
, -EINVAL
);
3292 e
= bus_label_escape(external_id
);
3296 ret
= strjoin(prefix
, "/", e
);
3304 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3308 assert_return(object_path_is_valid(path
), -EINVAL
);
3309 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3310 assert_return(external_id
, -EINVAL
);
3312 e
= object_path_startswith(path
, prefix
);
3314 *external_id
= NULL
;
3318 ret
= bus_label_unescape(e
);
3326 _public_
int sd_bus_path_encode_many(char **out
, const char *path_template
, ...) {
3327 _cleanup_strv_free_
char **labels
= NULL
;
3328 char *path
, *path_pos
, **label_pos
;
3329 const char *sep
, *template_pos
;
3334 assert_return(out
, -EINVAL
);
3335 assert_return(path_template
, -EINVAL
);
3337 path_length
= strlen(path_template
);
3339 va_start(list
, path_template
);
3340 for (sep
= strchr(path_template
, '%'); sep
; sep
= strchr(sep
+ 1, '%')) {
3344 arg
= va_arg(list
, const char *);
3350 label
= bus_label_escape(arg
);
3356 r
= strv_consume(&labels
, label
);
3362 /* add label length, but account for the format character */
3363 path_length
+= strlen(label
) - 1;
3367 path
= malloc(path_length
+ 1);
3374 for (template_pos
= path_template
; *template_pos
; ) {
3375 sep
= strchrnul(template_pos
, '%');
3376 path_pos
= mempcpy(path_pos
, template_pos
, sep
- template_pos
);
3380 path_pos
= stpcpy(path_pos
, *label_pos
++);
3381 template_pos
= sep
+ 1;
3389 _public_
int sd_bus_path_decode_many(const char *path
, const char *path_template
, ...) {
3390 _cleanup_strv_free_
char **labels
= NULL
;
3391 const char *template_pos
, *path_pos
;
3397 * This decodes an object-path based on a template argument. The
3398 * template consists of a verbatim path, optionally including special
3401 * - Each occurrence of '%' in the template matches an arbitrary
3402 * substring of a label in the given path. At most one such
3403 * directive is allowed per label. For each such directive, the
3404 * caller must provide an output parameter (char **) via va_arg. If
3405 * NULL is passed, the given label is verified, but not returned.
3406 * For each matched label, the *decoded* label is stored in the
3407 * passed output argument, and the caller is responsible to free
3408 * it. Note that the output arguments are only modified if the
3409 * actualy path matched the template. Otherwise, they're left
3412 * This function returns <0 on error, 0 if the path does not match the
3413 * template, 1 if it matched.
3416 assert_return(path
, -EINVAL
);
3417 assert_return(path_template
, -EINVAL
);
3421 for (template_pos
= path_template
; *template_pos
; ) {
3426 /* verify everything until the next '%' matches verbatim */
3427 sep
= strchrnul(template_pos
, '%');
3428 length
= sep
- template_pos
;
3429 if (strncmp(path_pos
, template_pos
, length
))
3433 template_pos
+= length
;
3438 /* We found the next '%' character. Everything up until here
3439 * matched. We now skip ahead to the end of this label and make
3440 * sure it matches the tail of the label in the path. Then we
3441 * decode the string in-between and save it for later use. */
3443 ++template_pos
; /* skip over '%' */
3445 sep
= strchrnul(template_pos
, '/');
3446 length
= sep
- template_pos
; /* length of suffix to match verbatim */
3448 /* verify the suffixes match */
3449 sep
= strchrnul(path_pos
, '/');
3450 if (sep
- path_pos
< (ssize_t
)length
||
3451 strncmp(sep
- length
, template_pos
, length
))
3454 template_pos
+= length
; /* skip over matched label */
3455 length
= sep
- path_pos
- length
; /* length of sub-label to decode */
3457 /* store unescaped label for later use */
3458 label
= bus_label_unescape_n(path_pos
, length
);
3462 r
= strv_consume(&labels
, label
);
3466 path_pos
= sep
; /* skip decoded label and suffix */
3469 /* end of template must match end of path */
3473 /* copy the labels over to the caller */
3474 va_start(list
, path_template
);
3475 for (label_pos
= labels
; label_pos
&& *label_pos
; ++label_pos
) {
3478 arg
= va_arg(list
, char **);
3491 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3492 assert_return(bus
, -EINVAL
);
3493 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3498 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3499 assert_return(bus
, -EINVAL
);
3500 assert_return(description
, -EINVAL
);
3501 assert_return(bus
->description
, -ENXIO
);
3502 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3504 *description
= bus
->description
;
3508 int bus_get_root_path(sd_bus
*bus
) {
3511 if (bus
->cgroup_root
)
3514 r
= cg_get_root_path(&bus
->cgroup_root
);
3516 bus
->cgroup_root
= strdup("/");
3517 if (!bus
->cgroup_root
)
3526 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3527 assert_return(bus
, -EINVAL
);
3528 assert_return(scope
, -EINVAL
);
3529 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3536 if (bus
->is_system
) {
3544 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3546 assert_return(bus
, -EINVAL
);
3547 assert_return(address
, -EINVAL
);
3548 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3551 *address
= bus
->address
;
3558 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3559 assert_return(bus
, -EINVAL
);
3560 assert_return(mask
, -EINVAL
);
3561 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3563 *mask
= bus
->creds_mask
;
3567 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3568 assert_return(bus
, -EINVAL
);
3569 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3571 return bus
->bus_client
;
3574 _public_
int sd_bus_is_server(sd_bus
*bus
) {
3575 assert_return(bus
, -EINVAL
);
3576 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3578 return bus
->is_server
;
3581 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
3582 assert_return(bus
, -EINVAL
);
3583 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3585 return bus
->anonymous_auth
;
3588 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
3589 assert_return(bus
, -EINVAL
);
3590 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3592 return bus
->trusted
;
3595 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
3596 assert_return(bus
, -EINVAL
);
3597 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3599 return !!(bus
->hello_flags
& KDBUS_HELLO_MONITOR
);
3602 static void flush_close(sd_bus
*bus
) {
3606 /* Flushes and closes the specified bus. We take a ref before,
3607 * to ensure the flushing does not cause the bus to be
3610 sd_bus_flush_close_unref(sd_bus_ref(bus
));
3613 _public_
void sd_bus_default_flush_close(void) {
3614 flush_close(default_starter_bus
);
3615 flush_close(default_user_bus
);
3616 flush_close(default_system_bus
);
3619 _public_
int sd_bus_set_exit_on_disconnect(sd_bus
*bus
, int b
) {
3620 assert_return(bus
, -EINVAL
);
3622 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
3623 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
3624 * from the client side. */
3625 bus
->exit_on_disconnect
= b
;
3627 /* If the exit condition was triggered already, exit immediately. */
3628 return bus_exit_now(bus
);
3631 _public_
int sd_bus_get_exit_on_disconnect(sd_bus
*bus
) {
3632 assert_return(bus
, -EINVAL
);
3634 return bus
->exit_on_disconnect
;