1 /* SPDX-License-Identifier: LGPL-2.1+ */
15 #include "alloc-util.h"
16 #include "bus-container.h"
17 #include "bus-control.h"
18 #include "bus-internal.h"
19 #include "bus-kernel.h"
20 #include "bus-label.h"
21 #include "bus-message.h"
22 #include "bus-objects.h"
23 #include "bus-protocol.h"
25 #include "bus-socket.h"
26 #include "bus-track.h"
29 #include "cgroup-util.h"
32 #include "hexdecoct.h"
33 #include "hostname-util.h"
36 #include "parse-util.h"
37 #include "process-util.h"
38 #include "string-util.h"
42 #define log_debug_bus_message(m) \
44 sd_bus_message *_mm = (m); \
45 log_debug("Got message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " signature=%s error-name=%s error-message=%s", \
46 bus_message_type_to_string(_mm->header->type), \
47 strna(sd_bus_message_get_sender(_mm)), \
48 strna(sd_bus_message_get_destination(_mm)), \
49 strna(sd_bus_message_get_path(_mm)), \
50 strna(sd_bus_message_get_interface(_mm)), \
51 strna(sd_bus_message_get_member(_mm)), \
52 BUS_MESSAGE_COOKIE(_mm), \
54 strna(_mm->root_container.signature), \
55 strna(_mm->error.name), \
56 strna(_mm->error.message)); \
59 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
60 static void bus_detach_io_events(sd_bus
*b
);
61 static void bus_detach_inotify_event(sd_bus
*b
);
63 static thread_local sd_bus
*default_system_bus
= NULL
;
64 static thread_local sd_bus
*default_user_bus
= NULL
;
65 static thread_local sd_bus
*default_starter_bus
= NULL
;
67 static sd_bus
**bus_choose_default(int (**bus_open
)(sd_bus
**)) {
70 /* Let's try our best to reuse another cached connection. If
71 * the starter bus type is set, connect via our normal
72 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
73 * we can share the connection with the user/system default
76 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
78 if (streq(e
, "system")) {
80 *bus_open
= sd_bus_open_system
;
81 return &default_system_bus
;
82 } else if (STR_IN_SET(e
, "user", "session")) {
84 *bus_open
= sd_bus_open_user
;
85 return &default_user_bus
;
89 /* No type is specified, so we have not other option than to
90 * use the starter address if it is set. */
91 e
= secure_getenv("DBUS_STARTER_ADDRESS");
94 *bus_open
= sd_bus_open
;
95 return &default_starter_bus
;
98 /* Finally, if nothing is set use the cached connection for
101 if (cg_pid_get_owner_uid(0, NULL
) >= 0) {
103 *bus_open
= sd_bus_open_user
;
104 return &default_user_bus
;
107 *bus_open
= sd_bus_open_system
;
108 return &default_system_bus
;
112 sd_bus
*bus_resolve(sd_bus
*bus
) {
113 switch ((uintptr_t) bus
) {
114 case (uintptr_t) SD_BUS_DEFAULT
:
115 return *(bus_choose_default(NULL
));
116 case (uintptr_t) SD_BUS_DEFAULT_USER
:
117 return default_user_bus
;
118 case (uintptr_t) SD_BUS_DEFAULT_SYSTEM
:
119 return default_system_bus
;
125 void bus_close_io_fds(sd_bus
*b
) {
128 bus_detach_io_events(b
);
130 if (b
->input_fd
!= b
->output_fd
)
131 safe_close(b
->output_fd
);
132 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
135 void bus_close_inotify_fd(sd_bus
*b
) {
138 bus_detach_inotify_event(b
);
140 b
->inotify_fd
= safe_close(b
->inotify_fd
);
141 b
->inotify_watches
= mfree(b
->inotify_watches
);
142 b
->n_inotify_watches
= 0;
145 static void bus_reset_queues(sd_bus
*b
) {
148 while (b
->rqueue_size
> 0)
149 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
151 b
->rqueue
= mfree(b
->rqueue
);
152 b
->rqueue_allocated
= 0;
154 while (b
->wqueue_size
> 0)
155 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
157 b
->wqueue
= mfree(b
->wqueue
);
158 b
->wqueue_allocated
= 0;
161 static sd_bus
* bus_free(sd_bus
*b
) {
165 assert(!b
->track_queue
);
168 b
->state
= BUS_CLOSED
;
170 sd_bus_detach_event(b
);
172 while ((s
= b
->slots
)) {
173 /* At this point only floating slots can still be
174 * around, because the non-floating ones keep a
175 * reference to the bus, and we thus couldn't be
176 * destructing right now... We forcibly disconnect the
177 * slots here, so that they still can be referenced by
178 * apps, but are dead. */
181 bus_slot_disconnect(s
, true);
184 if (b
->default_bus_ptr
)
185 *b
->default_bus_ptr
= NULL
;
188 bus_close_inotify_fd(b
);
193 free(b
->unique_name
);
194 free(b
->auth_buffer
);
197 free(b
->cgroup_root
);
198 free(b
->description
);
199 free(b
->patch_sender
);
202 strv_free(b
->exec_argv
);
204 close_many(b
->fds
, b
->n_fds
);
209 ordered_hashmap_free_free(b
->reply_callbacks
);
210 prioq_free(b
->reply_callbacks_prioq
);
212 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
213 bus_match_free(&b
->match_callbacks
);
215 hashmap_free_free(b
->vtable_methods
);
216 hashmap_free_free(b
->vtable_properties
);
218 assert(hashmap_isempty(b
->nodes
));
219 hashmap_free(b
->nodes
);
223 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
228 DEFINE_TRIVIAL_CLEANUP_FUNC(sd_bus
*, bus_free
);
230 _public_
int sd_bus_new(sd_bus
**ret
) {
231 _cleanup_free_ sd_bus
*b
= NULL
;
233 assert_return(ret
, -EINVAL
);
240 .n_ref
= REFCNT_INIT
,
244 .message_version
= 1,
245 .creds_mask
= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
,
247 .original_pid
= getpid_cached(),
248 .n_groups
= (size_t) -1,
249 .close_on_exit
= true,
252 assert_se(pthread_mutex_init(&b
->memfd_cache_mutex
, NULL
) == 0);
254 /* We guarantee that wqueue always has space for at least one entry */
255 if (!GREEDY_REALLOC(b
->wqueue
, b
->wqueue_allocated
, 1))
262 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
263 assert_return(bus
, -EINVAL
);
264 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
265 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
266 assert_return(address
, -EINVAL
);
267 assert_return(!bus_pid_changed(bus
), -ECHILD
);
269 return free_and_strdup(&bus
->address
, address
);
272 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
273 assert_return(bus
, -EINVAL
);
274 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
275 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
276 assert_return(input_fd
>= 0, -EBADF
);
277 assert_return(output_fd
>= 0, -EBADF
);
278 assert_return(!bus_pid_changed(bus
), -ECHILD
);
280 bus
->input_fd
= input_fd
;
281 bus
->output_fd
= output_fd
;
285 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
286 _cleanup_strv_free_
char **a
= NULL
;
289 assert_return(bus
, -EINVAL
);
290 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
291 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
292 assert_return(path
, -EINVAL
);
293 assert_return(!strv_isempty(argv
), -EINVAL
);
294 assert_return(!bus_pid_changed(bus
), -ECHILD
);
300 r
= free_and_strdup(&bus
->exec_path
, path
);
304 return strv_free_and_replace(bus
->exec_argv
, a
);
307 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
308 assert_return(bus
, -EINVAL
);
309 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
310 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
311 assert_return(!bus
->patch_sender
, -EPERM
);
312 assert_return(!bus_pid_changed(bus
), -ECHILD
);
314 bus
->bus_client
= !!b
;
318 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
319 assert_return(bus
, -EINVAL
);
320 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
321 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
322 assert_return(!bus_pid_changed(bus
), -ECHILD
);
324 bus
->is_monitor
= !!b
;
328 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
329 assert_return(bus
, -EINVAL
);
330 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
331 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
332 assert_return(!bus_pid_changed(bus
), -ECHILD
);
334 bus
->accept_fd
= !!b
;
338 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
339 assert_return(bus
, -EINVAL
);
340 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
341 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
342 assert_return(!bus_pid_changed(bus
), -ECHILD
);
344 /* This is not actually supported by any of our transports these days, but we do honour it for synthetic
345 * replies, and maybe one day classic D-Bus learns this too */
346 bus
->attach_timestamp
= !!b
;
351 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
352 assert_return(bus
, -EINVAL
);
353 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
354 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
355 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
356 assert_return(!bus_pid_changed(bus
), -ECHILD
);
358 SET_FLAG(bus
->creds_mask
, mask
, b
);
360 /* The well knowns we need unconditionally, so that matches can work */
361 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
366 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
367 assert_return(bus
, -EINVAL
);
368 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
369 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
370 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
371 assert_return(!bus_pid_changed(bus
), -ECHILD
);
373 bus
->is_server
= !!b
;
374 bus
->server_id
= server_id
;
378 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
379 assert_return(bus
, -EINVAL
);
380 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
381 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
382 assert_return(!bus_pid_changed(bus
), -ECHILD
);
384 bus
->anonymous_auth
= !!b
;
388 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
389 assert_return(bus
, -EINVAL
);
390 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
391 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
392 assert_return(!bus_pid_changed(bus
), -ECHILD
);
398 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
399 assert_return(bus
, -EINVAL
);
400 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
401 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
402 assert_return(!bus_pid_changed(bus
), -ECHILD
);
404 return free_and_strdup(&bus
->description
, description
);
407 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
408 assert_return(bus
, -EINVAL
);
409 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
410 assert_return(!bus_pid_changed(bus
), -ECHILD
);
412 bus
->allow_interactive_authorization
= !!b
;
416 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
417 assert_return(bus
, -EINVAL
);
418 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
419 assert_return(!bus_pid_changed(bus
), -ECHILD
);
421 return bus
->allow_interactive_authorization
;
424 _public_
int sd_bus_set_watch_bind(sd_bus
*bus
, int b
) {
425 assert_return(bus
, -EINVAL
);
426 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
427 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
428 assert_return(!bus_pid_changed(bus
), -ECHILD
);
430 bus
->watch_bind
= !!b
;
434 _public_
int sd_bus_get_watch_bind(sd_bus
*bus
) {
435 assert_return(bus
, -EINVAL
);
436 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
437 assert_return(!bus_pid_changed(bus
), -ECHILD
);
439 return bus
->watch_bind
;
442 _public_
int sd_bus_set_connected_signal(sd_bus
*bus
, int b
) {
443 assert_return(bus
, -EINVAL
);
444 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
445 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
446 assert_return(!bus_pid_changed(bus
), -ECHILD
);
448 bus
->connected_signal
= !!b
;
452 _public_
int sd_bus_get_connected_signal(sd_bus
*bus
) {
453 assert_return(bus
, -EINVAL
);
454 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
455 assert_return(!bus_pid_changed(bus
), -ECHILD
);
457 return bus
->connected_signal
;
460 static int synthesize_connected_signal(sd_bus
*bus
) {
461 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
466 /* If enabled, synthesizes a local "Connected" signal mirroring the local "Disconnected" signal. This is called
467 * whenever we fully established a connection, i.e. after the authorization phase, and after receiving the
468 * Hello() reply. Or in other words, whenver we enter BUS_RUNNING state.
470 * This is useful so that clients can start doing stuff whenver the connection is fully established in a way
471 * that works independently from whether we connected to a full bus or just a direct connection. */
473 if (!bus
->connected_signal
)
476 r
= sd_bus_message_new_signal(
479 "/org/freedesktop/DBus/Local",
480 "org.freedesktop.DBus.Local",
485 bus_message_set_sender_local(bus
, m
);
487 r
= bus_seal_synthetic_message(bus
, m
);
491 r
= bus_rqueue_make_room(bus
);
495 /* Insert at the very front */
496 memmove(bus
->rqueue
+ 1, bus
->rqueue
, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
497 bus
->rqueue
[0] = TAKE_PTR(m
);
503 void bus_set_state(sd_bus
*bus
, enum bus_state state
) {
505 static const char * const table
[_BUS_STATE_MAX
] = {
506 [BUS_UNSET
] = "UNSET",
507 [BUS_WATCH_BIND
] = "WATCH_BIND",
508 [BUS_OPENING
] = "OPENING",
509 [BUS_AUTHENTICATING
] = "AUTHENTICATING",
510 [BUS_HELLO
] = "HELLO",
511 [BUS_RUNNING
] = "RUNNING",
512 [BUS_CLOSING
] = "CLOSING",
513 [BUS_CLOSED
] = "CLOSED",
517 assert(state
< _BUS_STATE_MAX
);
519 if (state
== bus
->state
)
522 log_debug("Bus %s: changing state %s → %s", strna(bus
->description
), table
[bus
->state
], table
[state
]);
526 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
534 assert(IN_SET(bus
->state
, BUS_HELLO
, BUS_CLOSING
));
536 r
= sd_bus_message_get_errno(reply
);
540 r
= sd_bus_message_read(reply
, "s", &s
);
544 if (!service_name_is_valid(s
) || s
[0] != ':')
547 r
= free_and_strdup(&bus
->unique_name
, s
);
551 if (bus
->state
== BUS_HELLO
) {
552 bus_set_state(bus
, BUS_RUNNING
);
554 r
= synthesize_connected_signal(bus
);
562 static int bus_send_hello(sd_bus
*bus
) {
563 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
568 if (!bus
->bus_client
)
571 r
= sd_bus_message_new_method_call(
574 "org.freedesktop.DBus",
575 "/org/freedesktop/DBus",
576 "org.freedesktop.DBus",
581 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
584 int bus_start_running(sd_bus
*bus
) {
585 struct reply_callback
*c
;
591 assert(bus
->state
< BUS_HELLO
);
593 /* We start all method call timeouts when we enter BUS_HELLO or BUS_RUNNING mode. At this point let's convert
594 * all relative to absolute timestamps. Note that we do not reshuffle the reply callback priority queue since
595 * adding a fixed value to all entries should not alter the internal order. */
597 n
= now(CLOCK_MONOTONIC
);
598 ORDERED_HASHMAP_FOREACH(c
, bus
->reply_callbacks
, i
) {
599 if (c
->timeout_usec
== 0)
602 c
->timeout_usec
= usec_add(n
, c
->timeout_usec
);
605 if (bus
->bus_client
) {
606 bus_set_state(bus
, BUS_HELLO
);
610 bus_set_state(bus
, BUS_RUNNING
);
612 r
= synthesize_connected_signal(bus
);
619 static int parse_address_key(const char **p
, const char *key
, char **value
) {
620 size_t l
, n
= 0, allocated
= 0;
621 _cleanup_free_
char *r
= NULL
;
630 if (strncmp(*p
, key
, l
) != 0)
643 while (!IN_SET(*a
, ';', ',', 0)) {
657 c
= (char) ((x
<< 4) | y
);
664 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
682 free_and_replace(*value
, r
);
687 static void skip_address_key(const char **p
) {
691 *p
+= strcspn(*p
, ",");
697 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
698 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
707 while (!IN_SET(**p
, 0, ';')) {
708 r
= parse_address_key(p
, "guid", guid
);
714 r
= parse_address_key(p
, "path", &path
);
720 r
= parse_address_key(p
, "abstract", &abstract
);
729 if (!path
&& !abstract
)
732 if (path
&& abstract
)
737 if (l
>= sizeof(b
->sockaddr
.un
.sun_path
)) /* We insist on NUL termination */
740 b
->sockaddr
.un
= (struct sockaddr_un
) {
741 .sun_family
= AF_UNIX
,
744 memcpy(b
->sockaddr
.un
.sun_path
, path
, l
);
745 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
+ 1;
750 l
= strlen(abstract
);
751 if (l
>= sizeof(b
->sockaddr
.un
.sun_path
) - 1) /* We insist on NUL termination */
754 b
->sockaddr
.un
= (struct sockaddr_un
) {
755 .sun_family
= AF_UNIX
,
758 memcpy(b
->sockaddr
.un
.sun_path
+1, abstract
, l
);
759 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
767 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
768 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
770 struct addrinfo
*result
, hints
= {
771 .ai_socktype
= SOCK_STREAM
,
772 .ai_flags
= AI_ADDRCONFIG
,
780 while (!IN_SET(**p
, 0, ';')) {
781 r
= parse_address_key(p
, "guid", guid
);
787 r
= parse_address_key(p
, "host", &host
);
793 r
= parse_address_key(p
, "port", &port
);
799 r
= parse_address_key(p
, "family", &family
);
812 if (streq(family
, "ipv4"))
813 hints
.ai_family
= AF_INET
;
814 else if (streq(family
, "ipv6"))
815 hints
.ai_family
= AF_INET6
;
820 r
= getaddrinfo(host
, port
, &hints
, &result
);
824 return -EADDRNOTAVAIL
;
826 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
827 b
->sockaddr_size
= result
->ai_addrlen
;
829 freeaddrinfo(result
);
836 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
838 unsigned n_argv
= 0, j
;
840 size_t allocated
= 0;
848 while (!IN_SET(**p
, 0, ';')) {
849 r
= parse_address_key(p
, "guid", guid
);
855 r
= parse_address_key(p
, "path", &path
);
861 if (startswith(*p
, "argv")) {
865 ul
= strtoul(*p
+ 4, (char**) p
, 10);
866 if (errno
> 0 || **p
!= '=' || ul
> 256) {
874 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
882 r
= parse_address_key(p
, NULL
, argv
+ ul
);
897 /* Make sure there are no holes in the array, with the
898 * exception of argv[0] */
899 for (j
= 1; j
< n_argv
; j
++)
905 if (argv
&& argv
[0] == NULL
) {
906 argv
[0] = strdup(path
);
921 for (j
= 0; j
< n_argv
; j
++)
929 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
930 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
938 while (!IN_SET(**p
, 0, ';')) {
939 r
= parse_address_key(p
, "guid", guid
);
945 r
= parse_address_key(p
, "machine", &machine
);
951 r
= parse_address_key(p
, "pid", &pid
);
960 if (!machine
== !pid
)
964 if (!streq(machine
, ".host") && !machine_name_is_valid(machine
))
967 free_and_replace(b
->machine
, machine
);
969 b
->machine
= mfree(b
->machine
);
973 r
= parse_pid(pid
, &b
->nspid
);
979 b
->sockaddr
.un
= (struct sockaddr_un
) {
980 .sun_family
= AF_UNIX
,
981 /* Note that we use the old /var/run prefix here, to increase compatibility with really old containers */
982 .sun_path
= "/var/run/dbus/system_bus_socket",
984 b
->sockaddr_size
= SOCKADDR_UN_LEN(b
->sockaddr
.un
);
990 static void bus_reset_parsed_address(sd_bus
*b
) {
994 b
->sockaddr_size
= 0;
995 b
->exec_argv
= strv_free(b
->exec_argv
);
996 b
->exec_path
= mfree(b
->exec_path
);
997 b
->server_id
= SD_ID128_NULL
;
998 b
->machine
= mfree(b
->machine
);
1002 static int bus_parse_next_address(sd_bus
*b
) {
1003 _cleanup_free_
char *guid
= NULL
;
1011 if (b
->address
[b
->address_index
] == 0)
1014 bus_reset_parsed_address(b
);
1016 a
= b
->address
+ b
->address_index
;
1025 if (startswith(a
, "unix:")) {
1028 r
= parse_unix_address(b
, &a
, &guid
);
1033 } else if (startswith(a
, "tcp:")) {
1036 r
= parse_tcp_address(b
, &a
, &guid
);
1042 } else if (startswith(a
, "unixexec:")) {
1045 r
= parse_exec_address(b
, &a
, &guid
);
1051 } else if (startswith(a
, "x-machine-unix:")) {
1054 r
= parse_container_unix_address(b
, &a
, &guid
);
1067 r
= sd_id128_from_string(guid
, &b
->server_id
);
1072 b
->address_index
= a
- b
->address
;
1076 static void bus_kill_exec(sd_bus
*bus
) {
1077 if (pid_is_valid(bus
->busexec_pid
) > 0) {
1078 sigterm_wait(bus
->busexec_pid
);
1079 bus
->busexec_pid
= 0;
1083 static int bus_start_address(sd_bus
*b
) {
1089 bus_close_io_fds(b
);
1090 bus_close_inotify_fd(b
);
1094 /* If you provide multiple different bus-addresses, we
1095 * try all of them in order and use the first one that
1099 r
= bus_socket_exec(b
);
1100 else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1101 r
= bus_container_connect_socket(b
);
1102 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1103 r
= bus_socket_connect(b
);
1110 q
= bus_attach_io_events(b
);
1114 q
= bus_attach_inotify_event(b
);
1121 b
->last_connect_error
= -r
;
1124 r
= bus_parse_next_address(b
);
1128 return b
->last_connect_error
> 0 ? -b
->last_connect_error
: -ECONNREFUSED
;
1132 int bus_next_address(sd_bus
*b
) {
1135 bus_reset_parsed_address(b
);
1136 return bus_start_address(b
);
1139 static int bus_start_fd(sd_bus
*b
) {
1144 assert(b
->input_fd
>= 0);
1145 assert(b
->output_fd
>= 0);
1147 r
= fd_nonblock(b
->input_fd
, true);
1151 r
= fd_cloexec(b
->input_fd
, true);
1155 if (b
->input_fd
!= b
->output_fd
) {
1156 r
= fd_nonblock(b
->output_fd
, true);
1160 r
= fd_cloexec(b
->output_fd
, true);
1165 if (fstat(b
->input_fd
, &st
) < 0)
1168 return bus_socket_take_fd(b
);
1171 _public_
int sd_bus_start(sd_bus
*bus
) {
1174 assert_return(bus
, -EINVAL
);
1175 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1176 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1177 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1179 bus_set_state(bus
, BUS_OPENING
);
1181 if (bus
->is_server
&& bus
->bus_client
)
1184 if (bus
->input_fd
>= 0)
1185 r
= bus_start_fd(bus
);
1186 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->machine
)
1187 r
= bus_start_address(bus
);
1196 return bus_send_hello(bus
);
1199 _public_
int sd_bus_open_with_description(sd_bus
**ret
, const char *description
) {
1201 _cleanup_(bus_freep
) sd_bus
*b
= NULL
;
1204 assert_return(ret
, -EINVAL
);
1206 /* Let's connect to the starter bus if it is set, and
1207 * otherwise to the bus that is appropropriate for the scope
1208 * we are running in */
1210 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1212 if (streq(e
, "system"))
1213 return sd_bus_open_system_with_description(ret
, description
);
1214 else if (STR_IN_SET(e
, "session", "user"))
1215 return sd_bus_open_user_with_description(ret
, description
);
1218 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1220 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1221 return sd_bus_open_user_with_description(ret
, description
);
1223 return sd_bus_open_system_with_description(ret
, description
);
1230 r
= sd_bus_set_address(b
, e
);
1234 b
->bus_client
= true;
1236 /* We don't know whether the bus is trusted or not, so better
1237 * be safe, and authenticate everything */
1239 b
->is_local
= false;
1240 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1242 r
= sd_bus_start(b
);
1250 _public_
int sd_bus_open(sd_bus
**ret
) {
1251 return sd_bus_open_with_description(ret
, NULL
);
1254 int bus_set_address_system(sd_bus
*b
) {
1258 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1260 return sd_bus_set_address(b
, e
);
1262 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1265 _public_
int sd_bus_open_system_with_description(sd_bus
**ret
, const char *description
) {
1266 _cleanup_(bus_freep
) sd_bus
*b
= NULL
;
1269 assert_return(ret
, -EINVAL
);
1276 r
= sd_bus_set_description(b
, description
);
1281 r
= bus_set_address_system(b
);
1285 b
->bus_client
= true;
1286 b
->is_system
= true;
1288 /* Let's do per-method access control on the system bus. We
1289 * need the caller's UID and capability set for that. */
1291 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1294 r
= sd_bus_start(b
);
1302 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1303 return sd_bus_open_system_with_description(ret
, NULL
);
1306 int bus_set_address_user(sd_bus
*b
) {
1308 _cleanup_free_
char *ee
= NULL
, *s
= NULL
;
1312 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1314 return sd_bus_set_address(b
, e
);
1316 e
= secure_getenv("XDG_RUNTIME_DIR");
1320 ee
= bus_address_escape(e
);
1324 if (asprintf(&s
, DEFAULT_USER_BUS_ADDRESS_FMT
, ee
) < 0)
1327 b
->address
= TAKE_PTR(s
);
1332 _public_
int sd_bus_open_user_with_description(sd_bus
**ret
, const char *description
) {
1333 _cleanup_(bus_freep
) sd_bus
*b
= NULL
;
1336 assert_return(ret
, -EINVAL
);
1343 r
= sd_bus_set_description(b
, description
);
1348 r
= bus_set_address_user(b
);
1352 b
->bus_client
= true;
1355 /* We don't do any per-method access control on the user
1360 r
= sd_bus_start(b
);
1368 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1369 return sd_bus_open_user_with_description(ret
, NULL
);
1372 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1373 _cleanup_free_
char *e
= NULL
;
1374 char *m
= NULL
, *c
= NULL
, *a
, *rbracket
= NULL
, *p
= NULL
;
1379 /* Skip ":"s in ipv6 addresses */
1383 rbracket
= strchr(host
, ']');
1386 t
= strndupa(host
+ 1, rbracket
- host
- 1);
1387 e
= bus_address_escape(t
);
1390 } else if ((a
= strchr(host
, '@'))) {
1391 if (*(a
+ 1) == '[') {
1392 _cleanup_free_
char *t
= NULL
;
1394 rbracket
= strchr(a
+ 1, ']');
1397 t
= new0(char, strlen(host
));
1400 strncat(t
, host
, a
- host
+ 1);
1401 strncat(t
, a
+ 2, rbracket
- a
- 2);
1402 e
= bus_address_escape(t
);
1405 } else if (*(a
+ 1) == '\0' || strchr(a
+ 1, '@'))
1409 /* Let's see if a port was given */
1410 m
= strchr(rbracket
? rbracket
+ 1 : host
, ':');
1413 bool got_forward_slash
= false;
1419 p
= strndupa(p
, t
- p
);
1420 got_forward_slash
= true;
1423 if (!in_charset(p
, "0123456789") || *p
== '\0') {
1424 if (!machine_name_is_valid(p
) || got_forward_slash
)
1428 goto interpret_port_as_machine_old_syntax
;
1432 /* Let's see if a machine was given */
1433 m
= strchr(rbracket
? rbracket
+ 1 : host
, '/');
1436 interpret_port_as_machine_old_syntax
:
1437 /* Let's make sure this is not a port of some kind,
1438 * and is a valid machine name. */
1439 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
))
1440 c
= strjoina(",argv", p
? "7" : "5", "=--machine=", m
);
1446 t
= strndupa(host
, strcspn(host
, ":/"));
1448 e
= bus_address_escape(t
);
1453 a
= strjoin("unixexec:path=ssh,argv1=-xT", p
? ",argv2=-p,argv3=" : "", strempty(p
),
1454 ",argv", p
? "4" : "2", "=--,argv", p
? "5" : "3", "=", e
,
1455 ",argv", p
? "6" : "4", "=systemd-stdio-bridge", c
);
1459 return free_and_replace(b
->address
, a
);
1462 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1463 _cleanup_(bus_freep
) sd_bus
*b
= NULL
;
1466 assert_return(host
, -EINVAL
);
1467 assert_return(ret
, -EINVAL
);
1473 r
= bus_set_address_system_remote(b
, host
);
1477 b
->bus_client
= true;
1479 b
->is_system
= true;
1480 b
->is_local
= false;
1482 r
= sd_bus_start(b
);
1490 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1491 _cleanup_free_
char *e
= NULL
;
1497 e
= bus_address_escape(machine
);
1501 a
= strjoin("x-machine-unix:machine=", e
);
1505 return free_and_replace(b
->address
, a
);
1508 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1509 _cleanup_(bus_freep
) sd_bus
*b
= NULL
;
1512 assert_return(machine
, -EINVAL
);
1513 assert_return(ret
, -EINVAL
);
1514 assert_return(streq(machine
, ".host") || machine_name_is_valid(machine
), -EINVAL
);
1520 r
= bus_set_address_system_machine(b
, machine
);
1524 b
->bus_client
= true;
1526 b
->is_system
= true;
1527 b
->is_local
= false;
1529 r
= sd_bus_start(b
);
1537 _public_
void sd_bus_close(sd_bus
*bus
) {
1540 if (bus
->state
== BUS_CLOSED
)
1542 if (bus_pid_changed(bus
))
1545 /* Don't leave ssh hanging around */
1548 bus_set_state(bus
, BUS_CLOSED
);
1550 sd_bus_detach_event(bus
);
1552 /* Drop all queued messages so that they drop references to
1553 * the bus object and the bus may be freed */
1554 bus_reset_queues(bus
);
1556 bus_close_io_fds(bus
);
1557 bus_close_inotify_fd(bus
);
1560 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1564 /* Have to do this before flush() to prevent hang */
1570 return sd_bus_unref(bus
);
1573 void bus_enter_closing(sd_bus
*bus
) {
1576 if (!IN_SET(bus
->state
, BUS_WATCH_BIND
, BUS_OPENING
, BUS_AUTHENTICATING
, BUS_HELLO
, BUS_RUNNING
))
1579 bus_set_state(bus
, BUS_CLOSING
);
1582 DEFINE_PUBLIC_ATOMIC_REF_UNREF_FUNC(sd_bus
, sd_bus
, bus_free
);
1584 _public_
int sd_bus_is_open(sd_bus
*bus
) {
1585 assert_return(bus
, -EINVAL
);
1586 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1587 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1589 return BUS_IS_OPEN(bus
->state
);
1592 _public_
int sd_bus_is_ready(sd_bus
*bus
) {
1593 assert_return(bus
, -EINVAL
);
1594 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1595 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1597 return bus
->state
== BUS_RUNNING
;
1600 _public_
int sd_bus_can_send(sd_bus
*bus
, char type
) {
1603 assert_return(bus
, -EINVAL
);
1604 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1605 assert_return(bus
->state
!= BUS_UNSET
, -ENOTCONN
);
1606 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1608 if (bus
->is_monitor
)
1611 if (type
== SD_BUS_TYPE_UNIX_FD
) {
1612 if (!bus
->accept_fd
)
1615 r
= bus_ensure_running(bus
);
1619 return bus
->can_fds
;
1622 return bus_type_is_valid(type
);
1625 _public_
int sd_bus_get_bus_id(sd_bus
*bus
, sd_id128_t
*id
) {
1628 assert_return(bus
, -EINVAL
);
1629 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1630 assert_return(id
, -EINVAL
);
1631 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1633 r
= bus_ensure_running(bus
);
1637 *id
= bus
->server_id
;
1641 static int bus_seal_message(sd_bus
*b
, sd_bus_message
*m
, usec_t timeout
) {
1648 /* If we copy the same message to multiple
1649 * destinations, avoid using the same cookie
1651 b
->cookie
= MAX(b
->cookie
, BUS_MESSAGE_COOKIE(m
));
1656 r
= sd_bus_get_method_call_timeout(b
, &timeout
);
1661 if (!m
->sender
&& b
->patch_sender
) {
1662 r
= sd_bus_message_set_sender(m
, b
->patch_sender
);
1667 return sd_bus_message_seal(m
, ++b
->cookie
, timeout
);
1670 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1671 bool remarshal
= false;
1675 /* wrong packet version */
1676 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1679 /* wrong packet endianness */
1680 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1683 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1686 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1690 /* Fake some timestamps, if they were requested, and not
1691 * already initialized */
1692 if (b
->attach_timestamp
) {
1693 if (m
->realtime
<= 0)
1694 m
->realtime
= now(CLOCK_REALTIME
);
1696 if (m
->monotonic
<= 0)
1697 m
->monotonic
= now(CLOCK_MONOTONIC
);
1700 /* The bus specification says the serial number cannot be 0,
1701 * hence let's fill something in for synthetic messages. Since
1702 * synthetic messages might have a fake sender and we don't
1703 * want to interfere with the real sender's serial numbers we
1704 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1705 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1706 * even though kdbus can do 64bit. */
1707 return sd_bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1710 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, size_t *idx
) {
1716 r
= bus_socket_write_message(bus
, m
, idx
);
1720 if (*idx
>= BUS_MESSAGE_SIZE(m
))
1721 log_debug("Sent message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64
" reply_cookie=%" PRIu64
" signature=%s error-name=%s error-message=%s",
1722 bus_message_type_to_string(m
->header
->type
),
1723 strna(sd_bus_message_get_sender(m
)),
1724 strna(sd_bus_message_get_destination(m
)),
1725 strna(sd_bus_message_get_path(m
)),
1726 strna(sd_bus_message_get_interface(m
)),
1727 strna(sd_bus_message_get_member(m
)),
1728 BUS_MESSAGE_COOKIE(m
),
1730 strna(m
->root_container
.signature
),
1731 strna(m
->error
.name
),
1732 strna(m
->error
.message
));
1737 static int dispatch_wqueue(sd_bus
*bus
) {
1741 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
1743 while (bus
->wqueue_size
> 0) {
1745 r
= bus_write_message(bus
, bus
->wqueue
[0], &bus
->windex
);
1749 /* Didn't do anything this time */
1751 else if (bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1752 /* Fully written. Let's drop the entry from
1755 * This isn't particularly optimized, but
1756 * well, this is supposed to be our worst-case
1757 * buffer only, and the socket buffer is
1758 * supposed to be our primary buffer, and if
1759 * it got full, then all bets are off
1763 sd_bus_message_unref(bus
->wqueue
[0]);
1764 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1774 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1777 return bus_socket_read_message(bus
);
1780 int bus_rqueue_make_room(sd_bus
*bus
) {
1783 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1786 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1792 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1797 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
1799 /* Note that the priority logic is only available on kdbus,
1800 * where the rqueue is unused. We check the rqueue here
1801 * anyway, because it's simple... */
1804 if (bus
->rqueue_size
> 0) {
1805 /* Dispatch a queued message */
1807 *m
= bus
->rqueue
[0];
1809 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1813 /* Try to read a new message */
1814 r
= bus_read_message(bus
, hint_priority
, priority
);
1824 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
) {
1825 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1828 assert_return(m
, -EINVAL
);
1833 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1835 if (!BUS_IS_OPEN(bus
->state
))
1839 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1846 /* If the cookie number isn't kept, then we know that no reply
1848 if (!cookie
&& !m
->sealed
)
1849 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1851 r
= bus_seal_message(bus
, m
, 0);
1855 /* Remarshall if we have to. This will possibly unref the
1856 * message and place a replacement in m */
1857 r
= bus_remarshal_message(bus
, &m
);
1861 /* If this is a reply and no reply was requested, then let's
1862 * suppress this, if we can */
1866 if (IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1869 r
= bus_write_message(bus
, m
, &idx
);
1871 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1872 bus_enter_closing(bus
);
1879 if (idx
< BUS_MESSAGE_SIZE(m
)) {
1880 /* Wasn't fully written. So let's remember how
1881 * much was written. Note that the first entry
1882 * of the wqueue array is always allocated so
1883 * that we always can remember how much was
1885 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1886 bus
->wqueue_size
= 1;
1891 /* Just append it to the queue. */
1893 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1896 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1899 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1904 *cookie
= BUS_MESSAGE_COOKIE(m
);
1909 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1912 assert_return(m
, -EINVAL
);
1917 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1919 if (!BUS_IS_OPEN(bus
->state
))
1922 if (!streq_ptr(m
->destination
, destination
)) {
1927 r
= sd_bus_message_set_destination(m
, destination
);
1932 return sd_bus_send(bus
, m
, cookie
);
1935 static usec_t
calc_elapse(sd_bus
*bus
, uint64_t usec
) {
1938 if (usec
== (uint64_t) -1)
1941 /* We start all timeouts the instant we enter BUS_HELLO/BUS_RUNNING state, so that the don't run in parallel
1942 * with any connection setup states. Hence, if a method callback is started earlier than that we just store the
1943 * relative timestamp, and afterwards the absolute one. */
1945 if (IN_SET(bus
->state
, BUS_WATCH_BIND
, BUS_OPENING
, BUS_AUTHENTICATING
))
1948 return now(CLOCK_MONOTONIC
) + usec
;
1951 static int timeout_compare(const void *a
, const void *b
) {
1952 const struct reply_callback
*x
= a
, *y
= b
;
1954 if (x
->timeout_usec
!= 0 && y
->timeout_usec
== 0)
1957 if (x
->timeout_usec
== 0 && y
->timeout_usec
!= 0)
1960 return CMP(x
->timeout_usec
, y
->timeout_usec
);
1963 _public_
int sd_bus_call_async(
1967 sd_bus_message_handler_t callback
,
1971 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1972 _cleanup_(sd_bus_slot_unrefp
) sd_bus_slot
*s
= NULL
;
1975 assert_return(m
, -EINVAL
);
1976 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1977 assert_return(!m
->sealed
|| (!!callback
== !(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)), -EINVAL
);
1982 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1984 if (!BUS_IS_OPEN(bus
->state
))
1987 /* If no callback is specified and there's no interest in a slot, then there's no reason to ask for a reply */
1988 if (!callback
&& !slot
&& !m
->sealed
)
1989 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1991 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1995 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
1999 r
= bus_seal_message(bus
, m
, usec
);
2003 r
= bus_remarshal_message(bus
, &m
);
2007 if (slot
|| callback
) {
2008 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
2012 s
->reply_callback
.callback
= callback
;
2014 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
2015 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
2017 s
->reply_callback
.cookie
= 0;
2021 s
->reply_callback
.timeout_usec
= calc_elapse(bus
, m
->timeout
);
2022 if (s
->reply_callback
.timeout_usec
!= 0) {
2023 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
2025 s
->reply_callback
.timeout_usec
= 0;
2031 r
= sd_bus_send(bus
, m
, s
? &s
->reply_callback
.cookie
: NULL
);
2042 int bus_ensure_running(sd_bus
*bus
) {
2047 if (IN_SET(bus
->state
, BUS_UNSET
, BUS_CLOSED
, BUS_CLOSING
))
2049 if (bus
->state
== BUS_RUNNING
)
2053 r
= sd_bus_process(bus
, NULL
);
2056 if (bus
->state
== BUS_RUNNING
)
2061 r
= sd_bus_wait(bus
, (uint64_t) -1);
2067 _public_
int sd_bus_call(
2071 sd_bus_error
*error
,
2072 sd_bus_message
**reply
) {
2074 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
2080 bus_assert_return(m
, -EINVAL
, error
);
2081 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
2082 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
2083 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
2088 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
2090 if (!BUS_IS_OPEN(bus
->state
)) {
2095 r
= bus_ensure_running(bus
);
2099 i
= bus
->rqueue_size
;
2101 r
= bus_seal_message(bus
, m
, usec
);
2105 r
= bus_remarshal_message(bus
, &m
);
2109 r
= sd_bus_send(bus
, m
, &cookie
);
2113 timeout
= calc_elapse(bus
, m
->timeout
);
2118 while (i
< bus
->rqueue_size
) {
2119 sd_bus_message
*incoming
= NULL
;
2121 incoming
= bus
->rqueue
[i
];
2123 if (incoming
->reply_cookie
== cookie
) {
2124 /* Found a match! */
2126 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2128 log_debug_bus_message(incoming
);
2130 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2132 if (incoming
->n_fds
<= 0 || bus
->accept_fd
) {
2136 sd_bus_message_unref(incoming
);
2141 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2142 sd_bus_message_unref(incoming
);
2145 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
2146 r
= sd_bus_error_copy(error
, &incoming
->error
);
2147 sd_bus_message_unref(incoming
);
2154 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2157 streq(bus
->unique_name
, incoming
->sender
)) {
2159 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2162 /* Our own message? Somebody is trying
2163 * to send its own client a message,
2164 * let's not dead-lock, let's fail
2167 sd_bus_message_unref(incoming
);
2172 /* Try to read more, right-away */
2176 r
= bus_read_message(bus
, false, 0);
2178 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2179 bus_enter_closing(bus
);
2191 n
= now(CLOCK_MONOTONIC
);
2199 left
= (uint64_t) -1;
2201 r
= bus_poll(bus
, true, left
);
2209 r
= dispatch_wqueue(bus
);
2211 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2212 bus_enter_closing(bus
);
2221 return sd_bus_error_set_errno(error
, r
);
2224 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2226 assert_return(bus
, -EINVAL
);
2227 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2228 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2229 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2231 if (bus
->state
== BUS_CLOSED
)
2234 if (bus
->inotify_fd
>= 0)
2235 return bus
->inotify_fd
;
2237 if (bus
->input_fd
>= 0)
2238 return bus
->input_fd
;
2243 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2246 assert_return(bus
, -EINVAL
);
2247 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2248 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2250 switch (bus
->state
) {
2256 case BUS_WATCH_BIND
:
2264 case BUS_AUTHENTICATING
:
2265 if (bus_socket_auth_needs_write(bus
))
2273 if (bus
->rqueue_size
<= 0)
2275 if (bus
->wqueue_size
> 0)
2283 assert_not_reached("Unknown state");
2289 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2290 struct reply_callback
*c
;
2292 assert_return(bus
, -EINVAL
);
2293 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2294 assert_return(timeout_usec
, -EINVAL
);
2295 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2297 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2300 if (bus
->track_queue
) {
2305 switch (bus
->state
) {
2307 case BUS_AUTHENTICATING
:
2308 *timeout_usec
= bus
->auth_timeout
;
2313 if (bus
->rqueue_size
> 0) {
2318 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2320 *timeout_usec
= (uint64_t) -1;
2324 if (c
->timeout_usec
== 0) {
2325 *timeout_usec
= (uint64_t) -1;
2329 *timeout_usec
= c
->timeout_usec
;
2336 case BUS_WATCH_BIND
:
2338 *timeout_usec
= (uint64_t) -1;
2342 assert_not_reached("Unknown or unexpected stat");
2346 static int process_timeout(sd_bus
*bus
) {
2347 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2348 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
* m
= NULL
;
2349 struct reply_callback
*c
;
2356 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
2358 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2362 n
= now(CLOCK_MONOTONIC
);
2363 if (c
->timeout_usec
> n
)
2366 r
= bus_message_new_synthetic_error(
2369 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2374 r
= bus_seal_synthetic_message(bus
, m
);
2378 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2379 c
->timeout_usec
= 0;
2381 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2384 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2386 bus
->iteration_counter
++;
2388 is_hello
= bus
->state
== BUS_HELLO
&& c
->callback
== hello_callback
;
2390 bus
->current_message
= m
;
2391 bus
->current_slot
= sd_bus_slot_ref(slot
);
2392 bus
->current_handler
= c
->callback
;
2393 bus
->current_userdata
= slot
->userdata
;
2394 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2395 bus
->current_userdata
= NULL
;
2396 bus
->current_handler
= NULL
;
2397 bus
->current_slot
= NULL
;
2398 bus
->current_message
= NULL
;
2401 bus_slot_disconnect(slot
, true);
2403 sd_bus_slot_unref(slot
);
2405 /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2406 * and ignore the callback handler's return value. */
2410 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2413 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2417 if (bus
->state
!= BUS_HELLO
)
2420 /* Let's make sure the first message on the bus is the HELLO
2421 * reply. But note that we don't actually parse the message
2422 * here (we leave that to the usual handling), we just verify
2423 * we don't let any earlier msg through. */
2425 if (!IN_SET(m
->header
->type
, SD_BUS_MESSAGE_METHOD_RETURN
, SD_BUS_MESSAGE_METHOD_ERROR
))
2428 if (m
->reply_cookie
!= 1)
2434 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2435 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*synthetic_reply
= NULL
;
2436 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2437 struct reply_callback
*c
;
2445 if (!IN_SET(m
->header
->type
, SD_BUS_MESSAGE_METHOD_RETURN
, SD_BUS_MESSAGE_METHOD_ERROR
))
2448 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2451 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2457 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2459 if (m
->n_fds
> 0 && !bus
->accept_fd
) {
2461 /* If the reply contained a file descriptor which we
2462 * didn't want we pass an error instead. */
2464 r
= bus_message_new_synthetic_error(
2467 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2472 /* Copy over original timestamp */
2473 synthetic_reply
->realtime
= m
->realtime
;
2474 synthetic_reply
->monotonic
= m
->monotonic
;
2475 synthetic_reply
->seqnum
= m
->seqnum
;
2477 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2481 m
= synthetic_reply
;
2483 r
= sd_bus_message_rewind(m
, true);
2488 if (c
->timeout_usec
!= 0) {
2489 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2490 c
->timeout_usec
= 0;
2493 is_hello
= bus
->state
== BUS_HELLO
&& c
->callback
== hello_callback
;
2495 bus
->current_slot
= sd_bus_slot_ref(slot
);
2496 bus
->current_handler
= c
->callback
;
2497 bus
->current_userdata
= slot
->userdata
;
2498 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2499 bus
->current_userdata
= NULL
;
2500 bus
->current_handler
= NULL
;
2501 bus
->current_slot
= NULL
;
2504 bus_slot_disconnect(slot
, true);
2506 sd_bus_slot_unref(slot
);
2508 /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2509 * ignore the callback handler's return value. */
2513 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2516 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2517 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2518 struct filter_callback
*l
;
2525 bus
->filter_callbacks_modified
= false;
2527 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2530 if (bus
->filter_callbacks_modified
)
2533 /* Don't run this more than once per iteration */
2534 if (l
->last_iteration
== bus
->iteration_counter
)
2537 l
->last_iteration
= bus
->iteration_counter
;
2539 r
= sd_bus_message_rewind(m
, true);
2543 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2545 bus
->current_slot
= sd_bus_slot_ref(slot
);
2546 bus
->current_handler
= l
->callback
;
2547 bus
->current_userdata
= slot
->userdata
;
2548 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2549 bus
->current_userdata
= NULL
;
2550 bus
->current_handler
= NULL
;
2551 bus
->current_slot
= sd_bus_slot_unref(slot
);
2553 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2559 } while (bus
->filter_callbacks_modified
);
2564 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2571 bus
->match_callbacks_modified
= false;
2573 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2577 } while (bus
->match_callbacks_modified
);
2582 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2583 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2589 if (bus
->is_monitor
)
2592 if (bus
->manual_peer_interface
)
2595 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2598 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2601 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2604 if (streq_ptr(m
->member
, "Ping"))
2605 r
= sd_bus_message_new_method_return(m
, &reply
);
2606 else if (streq_ptr(m
->member
, "GetMachineId")) {
2610 r
= sd_id128_get_machine(&id
);
2614 r
= sd_bus_message_new_method_return(m
, &reply
);
2618 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2620 r
= sd_bus_message_new_method_errorf(
2622 SD_BUS_ERROR_UNKNOWN_METHOD
,
2623 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2629 r
= sd_bus_send(bus
, reply
, NULL
);
2636 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2640 /* If we got a message with a file descriptor which we didn't
2641 * want to accept, then let's drop it. How can this even
2642 * happen? For example, when the kernel queues a message into
2643 * an activatable names's queue which allows fds, and then is
2644 * delivered to us later even though we ourselves did not
2647 if (bus
->is_monitor
)
2656 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2657 return 1; /* just eat it up */
2659 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2662 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2668 bus
->current_message
= m
;
2669 bus
->iteration_counter
++;
2671 log_debug_bus_message(m
);
2673 r
= process_hello(bus
, m
);
2677 r
= process_reply(bus
, m
);
2681 r
= process_fd_check(bus
, m
);
2685 r
= process_filter(bus
, m
);
2689 r
= process_match(bus
, m
);
2693 r
= process_builtin(bus
, m
);
2697 r
= bus_process_object(bus
, m
);
2700 bus
->current_message
= NULL
;
2704 static int dispatch_track(sd_bus
*bus
) {
2707 if (!bus
->track_queue
)
2710 bus_track_dispatch(bus
->track_queue
);
2714 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2715 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2719 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
2721 r
= process_timeout(bus
);
2725 r
= dispatch_wqueue(bus
);
2729 r
= dispatch_track(bus
);
2733 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2739 r
= process_message(bus
, m
);
2744 r
= sd_bus_message_rewind(m
, true);
2753 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2755 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2756 strna(sd_bus_message_get_sender(m
)),
2757 strna(sd_bus_message_get_path(m
)),
2758 strna(sd_bus_message_get_interface(m
)),
2759 strna(sd_bus_message_get_member(m
)));
2761 r
= sd_bus_reply_method_errorf(
2763 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2764 "Unknown object '%s'.", m
->path
);
2778 static int bus_exit_now(sd_bus
*bus
) {
2781 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2782 * sd_event_exit(), otherwise invokes libc exit(). */
2784 if (bus
->exited
) /* did we already exit? */
2786 if (!bus
->exit_triggered
) /* was the exit condition triggered? */
2788 if (!bus
->exit_on_disconnect
) /* Shall we actually exit on disconnection? */
2791 bus
->exited
= true; /* never exit more than once */
2793 log_debug("Bus connection disconnected, exiting.");
2796 return sd_event_exit(bus
->event
, EXIT_FAILURE
);
2800 assert_not_reached("exit() didn't exit?");
2803 static int process_closing_reply_callback(sd_bus
*bus
, struct reply_callback
*c
) {
2804 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2805 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2812 r
= bus_message_new_synthetic_error(
2815 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2820 r
= bus_seal_synthetic_message(bus
, m
);
2824 if (c
->timeout_usec
!= 0) {
2825 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2826 c
->timeout_usec
= 0;
2829 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2832 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2834 bus
->iteration_counter
++;
2836 bus
->current_message
= m
;
2837 bus
->current_slot
= sd_bus_slot_ref(slot
);
2838 bus
->current_handler
= c
->callback
;
2839 bus
->current_userdata
= slot
->userdata
;
2840 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2841 bus
->current_userdata
= NULL
;
2842 bus
->current_handler
= NULL
;
2843 bus
->current_slot
= NULL
;
2844 bus
->current_message
= NULL
;
2847 bus_slot_disconnect(slot
, true);
2849 sd_bus_slot_unref(slot
);
2851 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2854 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2855 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2856 struct reply_callback
*c
;
2860 assert(bus
->state
== BUS_CLOSING
);
2862 /* First, fail all outstanding method calls */
2863 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2865 return process_closing_reply_callback(bus
, c
);
2867 /* Then, fake-drop all remaining bus tracking references */
2869 bus_track_close(bus
->tracks
);
2873 /* Then, synthesize a Disconnected message */
2874 r
= sd_bus_message_new_signal(
2877 "/org/freedesktop/DBus/Local",
2878 "org.freedesktop.DBus.Local",
2883 bus_message_set_sender_local(bus
, m
);
2885 r
= bus_seal_synthetic_message(bus
, m
);
2891 bus
->current_message
= m
;
2892 bus
->iteration_counter
++;
2894 r
= process_filter(bus
, m
);
2898 r
= process_match(bus
, m
);
2902 /* Nothing else to do, exit now, if the condition holds */
2903 bus
->exit_triggered
= true;
2904 (void) bus_exit_now(bus
);
2912 bus
->current_message
= NULL
;
2917 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2920 /* Returns 0 when we didn't do anything. This should cause the
2921 * caller to invoke sd_bus_wait() before returning the next
2922 * time. Returns > 0 when we did something, which possibly
2923 * means *ret is filled in with an unprocessed message. */
2925 assert_return(bus
, -EINVAL
);
2926 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2927 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2929 /* We don't allow recursively invoking sd_bus_process(). */
2930 assert_return(!bus
->current_message
, -EBUSY
);
2931 assert(!bus
->current_slot
); /* This should be NULL whenever bus->current_message is */
2933 BUS_DONT_DESTROY(bus
);
2935 switch (bus
->state
) {
2943 case BUS_WATCH_BIND
:
2944 r
= bus_socket_process_watch_bind(bus
);
2948 r
= bus_socket_process_opening(bus
);
2951 case BUS_AUTHENTICATING
:
2952 r
= bus_socket_process_authenticating(bus
);
2957 r
= process_running(bus
, hint_priority
, priority
, ret
);
2961 /* This branch initializes *ret, hence we don't use the generic error checking below */
2965 return process_closing(bus
, ret
);
2968 assert_not_reached("Unknown state");
2971 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2972 bus_enter_closing(bus
);
2983 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2984 return bus_process_internal(bus
, false, 0, ret
);
2987 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2988 return bus_process_internal(bus
, true, priority
, ret
);
2991 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
2992 struct pollfd p
[2] = {};
2995 usec_t m
= USEC_INFINITY
;
2999 if (bus
->state
== BUS_CLOSING
)
3002 if (!BUS_IS_OPEN(bus
->state
))
3005 if (bus
->state
== BUS_WATCH_BIND
) {
3006 assert(bus
->inotify_fd
>= 0);
3008 p
[0].events
= POLLIN
;
3009 p
[0].fd
= bus
->inotify_fd
;
3014 e
= sd_bus_get_events(bus
);
3019 /* The caller really needs some more data, he doesn't
3020 * care about what's already read, or any timeouts
3021 * except its own. */
3025 /* The caller wants to process if there's something to
3026 * process, but doesn't care otherwise */
3028 r
= sd_bus_get_timeout(bus
, &until
);
3032 m
= usec_sub_unsigned(until
, now(CLOCK_MONOTONIC
));
3035 p
[0].fd
= bus
->input_fd
;
3036 if (bus
->output_fd
== bus
->input_fd
) {
3040 p
[0].events
= e
& POLLIN
;
3041 p
[1].fd
= bus
->output_fd
;
3042 p
[1].events
= e
& POLLOUT
;
3047 if (timeout_usec
!= (uint64_t) -1 && (m
== USEC_INFINITY
|| timeout_usec
< m
))
3050 r
= ppoll(p
, n
, m
== USEC_INFINITY
? NULL
: timespec_store(&ts
, m
), NULL
);
3054 return r
> 0 ? 1 : 0;
3057 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
3059 assert_return(bus
, -EINVAL
);
3060 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3061 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3063 if (bus
->state
== BUS_CLOSING
)
3066 if (!BUS_IS_OPEN(bus
->state
))
3069 if (bus
->rqueue_size
> 0)
3072 return bus_poll(bus
, false, timeout_usec
);
3075 _public_
int sd_bus_flush(sd_bus
*bus
) {
3078 assert_return(bus
, -EINVAL
);
3079 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3080 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3082 if (bus
->state
== BUS_CLOSING
)
3085 if (!BUS_IS_OPEN(bus
->state
))
3088 /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
3089 if (bus
->state
== BUS_WATCH_BIND
)
3092 r
= bus_ensure_running(bus
);
3096 if (bus
->wqueue_size
<= 0)
3100 r
= dispatch_wqueue(bus
);
3102 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
3103 bus_enter_closing(bus
);
3110 if (bus
->wqueue_size
<= 0)
3113 r
= bus_poll(bus
, false, (uint64_t) -1);
3119 _public_
int sd_bus_add_filter(
3122 sd_bus_message_handler_t callback
,
3127 assert_return(bus
, -EINVAL
);
3128 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3129 assert_return(callback
, -EINVAL
);
3130 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3132 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
3136 s
->filter_callback
.callback
= callback
;
3138 bus
->filter_callbacks_modified
= true;
3139 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
3147 static int add_match_callback(
3150 sd_bus_error
*ret_error
) {
3152 sd_bus_slot
*match_slot
= userdata
;
3153 bool failed
= false;
3159 sd_bus_slot_ref(match_slot
);
3161 if (sd_bus_message_is_method_error(m
, NULL
)) {
3162 log_debug_errno(sd_bus_message_get_errno(m
),
3163 "Unable to add match %s, failing connection: %s",
3164 match_slot
->match_callback
.match_string
,
3165 sd_bus_message_get_error(m
)->message
);
3169 log_debug("Match %s successfully installed.", match_slot
->match_callback
.match_string
);
3171 if (match_slot
->match_callback
.install_callback
) {
3174 bus
= sd_bus_message_get_bus(m
);
3176 /* This function has been called as slot handler, and we want to call another slot handler. Let's
3177 * update the slot callback metadata temporarily with our own data, and then revert back to the old
3180 assert(bus
->current_slot
== match_slot
->match_callback
.install_slot
);
3181 assert(bus
->current_handler
== add_match_callback
);
3182 assert(bus
->current_userdata
== userdata
);
3184 bus
->current_slot
= match_slot
;
3185 bus
->current_handler
= match_slot
->match_callback
.install_callback
;
3186 bus
->current_userdata
= match_slot
->userdata
;
3188 r
= match_slot
->match_callback
.install_callback(m
, match_slot
->userdata
, ret_error
);
3190 bus
->current_slot
= match_slot
->match_callback
.install_slot
;
3191 bus
->current_handler
= add_match_callback
;
3192 bus
->current_userdata
= userdata
;
3194 match_slot
->match_callback
.install_slot
= sd_bus_slot_unref(match_slot
->match_callback
.install_slot
);
3196 if (failed
) /* Generic failure handling: destroy the connection */
3197 bus_enter_closing(sd_bus_message_get_bus(m
));
3202 if (failed
&& match_slot
->floating
)
3203 bus_slot_disconnect(match_slot
, true);
3205 sd_bus_slot_unref(match_slot
);
3210 static int bus_add_match_full(
3215 sd_bus_message_handler_t callback
,
3216 sd_bus_message_handler_t install_callback
,
3219 struct bus_match_component
*components
= NULL
;
3220 unsigned n_components
= 0;
3221 sd_bus_slot
*s
= NULL
;
3224 assert_return(bus
, -EINVAL
);
3225 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3226 assert_return(match
, -EINVAL
);
3227 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3229 r
= bus_match_parse(match
, &components
, &n_components
);
3233 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
3239 s
->match_callback
.callback
= callback
;
3240 s
->match_callback
.install_callback
= install_callback
;
3242 if (bus
->bus_client
) {
3243 enum bus_match_scope scope
;
3245 scope
= bus_match_get_scope(components
, n_components
);
3247 /* Do not install server-side matches for matches against the local service, interface or bus path. */
3248 if (scope
!= BUS_MATCH_LOCAL
) {
3250 /* We store the original match string, so that we can use it to remove the match again. */
3252 s
->match_callback
.match_string
= strdup(match
);
3253 if (!s
->match_callback
.match_string
) {
3259 r
= bus_add_match_internal_async(bus
,
3260 &s
->match_callback
.install_slot
,
3261 s
->match_callback
.match_string
,
3268 /* Make the slot of the match call floating now. We need the reference, but we don't
3269 * want that this match pins the bus object, hence we first create it non-floating, but
3270 * then make it floating. */
3271 r
= sd_bus_slot_set_floating(s
->match_callback
.install_slot
, true);
3273 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
);
3277 s
->match_added
= true;
3281 bus
->match_callbacks_modified
= true;
3282 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
3291 bus_match_parse_free(components
, n_components
);
3292 sd_bus_slot_unref(s
);
3297 _public_
int sd_bus_add_match(
3301 sd_bus_message_handler_t callback
,
3304 return bus_add_match_full(bus
, slot
, false, match
, callback
, NULL
, userdata
);
3307 _public_
int sd_bus_add_match_async(
3311 sd_bus_message_handler_t callback
,
3312 sd_bus_message_handler_t install_callback
,
3315 return bus_add_match_full(bus
, slot
, true, match
, callback
, install_callback
, userdata
);
3318 bool bus_pid_changed(sd_bus
*bus
) {
3321 /* We don't support people creating a bus connection and
3322 * keeping it around over a fork(). Let's complain. */
3324 return bus
->original_pid
!= getpid_cached();
3327 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3328 sd_bus
*bus
= userdata
;
3333 /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3335 r
= sd_bus_process(bus
, NULL
);
3337 log_debug_errno(r
, "Processing of bus failed, closing down: %m");
3338 bus_enter_closing(bus
);
3344 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3345 sd_bus
*bus
= userdata
;
3350 r
= sd_bus_process(bus
, NULL
);
3352 log_debug_errno(r
, "Processing of bus failed, closing down: %m");
3353 bus_enter_closing(bus
);
3359 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3360 sd_bus
*bus
= userdata
;
3367 e
= sd_bus_get_events(bus
);
3373 if (bus
->output_fd
!= bus
->input_fd
) {
3375 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3379 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3381 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3385 r
= sd_bus_get_timeout(bus
, &until
);
3391 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3398 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3405 log_debug_errno(r
, "Preparing of bus events failed, closing down: %m");
3406 bus_enter_closing(bus
);
3411 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3412 sd_bus
*bus
= userdata
;
3416 if (bus
->close_on_exit
) {
3424 int bus_attach_io_events(sd_bus
*bus
) {
3429 if (bus
->input_fd
< 0)
3435 if (!bus
->input_io_event_source
) {
3436 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3440 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3444 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3448 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3450 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3455 if (bus
->output_fd
!= bus
->input_fd
) {
3456 assert(bus
->output_fd
>= 0);
3458 if (!bus
->output_io_event_source
) {
3459 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3463 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3467 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3469 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3478 static void bus_detach_io_events(sd_bus
*bus
) {
3481 if (bus
->input_io_event_source
) {
3482 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3483 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3486 if (bus
->output_io_event_source
) {
3487 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3488 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3492 int bus_attach_inotify_event(sd_bus
*bus
) {
3497 if (bus
->inotify_fd
< 0)
3503 if (!bus
->inotify_event_source
) {
3504 r
= sd_event_add_io(bus
->event
, &bus
->inotify_event_source
, bus
->inotify_fd
, EPOLLIN
, io_callback
, bus
);
3508 r
= sd_event_source_set_priority(bus
->inotify_event_source
, bus
->event_priority
);
3512 r
= sd_event_source_set_description(bus
->inotify_event_source
, "bus-inotify");
3514 r
= sd_event_source_set_io_fd(bus
->inotify_event_source
, bus
->inotify_fd
);
3521 static void bus_detach_inotify_event(sd_bus
*bus
) {
3524 if (bus
->inotify_event_source
) {
3525 sd_event_source_set_enabled(bus
->inotify_event_source
, SD_EVENT_OFF
);
3526 bus
->inotify_event_source
= sd_event_source_unref(bus
->inotify_event_source
);
3530 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3533 assert_return(bus
, -EINVAL
);
3534 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3535 assert_return(!bus
->event
, -EBUSY
);
3537 assert(!bus
->input_io_event_source
);
3538 assert(!bus
->output_io_event_source
);
3539 assert(!bus
->time_event_source
);
3542 bus
->event
= sd_event_ref(event
);
3544 r
= sd_event_default(&bus
->event
);
3549 bus
->event_priority
= priority
;
3551 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3555 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3559 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3563 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3567 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3571 r
= bus_attach_io_events(bus
);
3575 r
= bus_attach_inotify_event(bus
);
3582 sd_bus_detach_event(bus
);
3586 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3587 assert_return(bus
, -EINVAL
);
3588 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3593 bus_detach_io_events(bus
);
3594 bus_detach_inotify_event(bus
);
3596 if (bus
->time_event_source
) {
3597 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3598 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3601 if (bus
->quit_event_source
) {
3602 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3603 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3606 bus
->event
= sd_event_unref(bus
->event
);
3610 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3611 assert_return(bus
, NULL
);
3616 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3617 assert_return(bus
, NULL
);
3619 return bus
->current_message
;
3622 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3623 assert_return(bus
, NULL
);
3625 return bus
->current_slot
;
3628 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3629 assert_return(bus
, NULL
);
3631 return bus
->current_handler
;
3634 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3635 assert_return(bus
, NULL
);
3637 return bus
->current_userdata
;
3640 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3645 assert(default_bus
);
3648 return !!*default_bus
;
3651 *ret
= sd_bus_ref(*default_bus
);
3659 b
->default_bus_ptr
= default_bus
;
3667 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3668 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3671 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3672 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3675 _public_
int sd_bus_default(sd_bus
**ret
) {
3676 int (*bus_open
)(sd_bus
**) = NULL
;
3679 busp
= bus_choose_default(&bus_open
);
3680 return bus_default(bus_open
, busp
, ret
);
3683 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3684 assert_return(b
, -EINVAL
);
3685 assert_return(tid
, -EINVAL
);
3686 assert_return(!bus_pid_changed(b
), -ECHILD
);
3694 return sd_event_get_tid(b
->event
, tid
);
3699 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3700 _cleanup_free_
char *e
= NULL
;
3703 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3704 assert_return(external_id
, -EINVAL
);
3705 assert_return(ret_path
, -EINVAL
);
3707 e
= bus_label_escape(external_id
);
3711 ret
= strjoin(prefix
, "/", e
);
3719 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3723 assert_return(object_path_is_valid(path
), -EINVAL
);
3724 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3725 assert_return(external_id
, -EINVAL
);
3727 e
= object_path_startswith(path
, prefix
);
3729 *external_id
= NULL
;
3733 ret
= bus_label_unescape(e
);
3741 _public_
int sd_bus_path_encode_many(char **out
, const char *path_template
, ...) {
3742 _cleanup_strv_free_
char **labels
= NULL
;
3743 char *path
, *path_pos
, **label_pos
;
3744 const char *sep
, *template_pos
;
3749 assert_return(out
, -EINVAL
);
3750 assert_return(path_template
, -EINVAL
);
3752 path_length
= strlen(path_template
);
3754 va_start(list
, path_template
);
3755 for (sep
= strchr(path_template
, '%'); sep
; sep
= strchr(sep
+ 1, '%')) {
3759 arg
= va_arg(list
, const char *);
3765 label
= bus_label_escape(arg
);
3771 r
= strv_consume(&labels
, label
);
3777 /* add label length, but account for the format character */
3778 path_length
+= strlen(label
) - 1;
3782 path
= malloc(path_length
+ 1);
3789 for (template_pos
= path_template
; *template_pos
; ) {
3790 sep
= strchrnul(template_pos
, '%');
3791 path_pos
= mempcpy(path_pos
, template_pos
, sep
- template_pos
);
3795 path_pos
= stpcpy(path_pos
, *label_pos
++);
3796 template_pos
= sep
+ 1;
3804 _public_
int sd_bus_path_decode_many(const char *path
, const char *path_template
, ...) {
3805 _cleanup_strv_free_
char **labels
= NULL
;
3806 const char *template_pos
, *path_pos
;
3812 * This decodes an object-path based on a template argument. The
3813 * template consists of a verbatim path, optionally including special
3816 * - Each occurrence of '%' in the template matches an arbitrary
3817 * substring of a label in the given path. At most one such
3818 * directive is allowed per label. For each such directive, the
3819 * caller must provide an output parameter (char **) via va_arg. If
3820 * NULL is passed, the given label is verified, but not returned.
3821 * For each matched label, the *decoded* label is stored in the
3822 * passed output argument, and the caller is responsible to free
3823 * it. Note that the output arguments are only modified if the
3824 * actualy path matched the template. Otherwise, they're left
3827 * This function returns <0 on error, 0 if the path does not match the
3828 * template, 1 if it matched.
3831 assert_return(path
, -EINVAL
);
3832 assert_return(path_template
, -EINVAL
);
3836 for (template_pos
= path_template
; *template_pos
; ) {
3841 /* verify everything until the next '%' matches verbatim */
3842 sep
= strchrnul(template_pos
, '%');
3843 length
= sep
- template_pos
;
3844 if (strncmp(path_pos
, template_pos
, length
))
3848 template_pos
+= length
;
3853 /* We found the next '%' character. Everything up until here
3854 * matched. We now skip ahead to the end of this label and make
3855 * sure it matches the tail of the label in the path. Then we
3856 * decode the string in-between and save it for later use. */
3858 ++template_pos
; /* skip over '%' */
3860 sep
= strchrnul(template_pos
, '/');
3861 length
= sep
- template_pos
; /* length of suffix to match verbatim */
3863 /* verify the suffixes match */
3864 sep
= strchrnul(path_pos
, '/');
3865 if (sep
- path_pos
< (ssize_t
)length
||
3866 strncmp(sep
- length
, template_pos
, length
))
3869 template_pos
+= length
; /* skip over matched label */
3870 length
= sep
- path_pos
- length
; /* length of sub-label to decode */
3872 /* store unescaped label for later use */
3873 label
= bus_label_unescape_n(path_pos
, length
);
3877 r
= strv_consume(&labels
, label
);
3881 path_pos
= sep
; /* skip decoded label and suffix */
3884 /* end of template must match end of path */
3888 /* copy the labels over to the caller */
3889 va_start(list
, path_template
);
3890 for (label_pos
= labels
; label_pos
&& *label_pos
; ++label_pos
) {
3893 arg
= va_arg(list
, char **);
3901 labels
= mfree(labels
);
3905 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3906 assert_return(bus
, -EINVAL
);
3907 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3908 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3913 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3914 assert_return(bus
, -EINVAL
);
3915 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3916 assert_return(description
, -EINVAL
);
3917 assert_return(bus
->description
, -ENXIO
);
3918 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3920 if (bus
->description
)
3921 *description
= bus
->description
;
3922 else if (bus
->is_system
)
3923 *description
= "system";
3924 else if (bus
->is_user
)
3925 *description
= "user";
3927 *description
= NULL
;
3932 int bus_get_root_path(sd_bus
*bus
) {
3935 if (bus
->cgroup_root
)
3938 r
= cg_get_root_path(&bus
->cgroup_root
);
3940 bus
->cgroup_root
= strdup("/");
3941 if (!bus
->cgroup_root
)
3950 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3951 assert_return(bus
, -EINVAL
);
3952 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3953 assert_return(scope
, -EINVAL
);
3954 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3961 if (bus
->is_system
) {
3969 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3971 assert_return(bus
, -EINVAL
);
3972 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3973 assert_return(address
, -EINVAL
);
3974 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3977 *address
= bus
->address
;
3984 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3985 assert_return(bus
, -EINVAL
);
3986 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3987 assert_return(mask
, -EINVAL
);
3988 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3990 *mask
= bus
->creds_mask
;
3994 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3995 assert_return(bus
, -EINVAL
);
3996 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3997 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3999 return bus
->bus_client
;
4002 _public_
int sd_bus_is_server(sd_bus
*bus
) {
4003 assert_return(bus
, -EINVAL
);
4004 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4005 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4007 return bus
->is_server
;
4010 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
4011 assert_return(bus
, -EINVAL
);
4012 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4013 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4015 return bus
->anonymous_auth
;
4018 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
4019 assert_return(bus
, -EINVAL
);
4020 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4021 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4023 return bus
->trusted
;
4026 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
4027 assert_return(bus
, -EINVAL
);
4028 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4029 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4031 return bus
->is_monitor
;
4034 static void flush_close(sd_bus
*bus
) {
4038 /* Flushes and closes the specified bus. We take a ref before,
4039 * to ensure the flushing does not cause the bus to be
4042 sd_bus_flush_close_unref(sd_bus_ref(bus
));
4045 _public_
void sd_bus_default_flush_close(void) {
4046 flush_close(default_starter_bus
);
4047 flush_close(default_user_bus
);
4048 flush_close(default_system_bus
);
4051 _public_
int sd_bus_set_exit_on_disconnect(sd_bus
*bus
, int b
) {
4052 assert_return(bus
, -EINVAL
);
4053 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4055 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
4056 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
4057 * from the client side. */
4058 bus
->exit_on_disconnect
= b
;
4060 /* If the exit condition was triggered already, exit immediately. */
4061 return bus_exit_now(bus
);
4064 _public_
int sd_bus_get_exit_on_disconnect(sd_bus
*bus
) {
4065 assert_return(bus
, -EINVAL
);
4066 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4068 return bus
->exit_on_disconnect
;
4071 _public_
int sd_bus_set_sender(sd_bus
*bus
, const char *sender
) {
4072 assert_return(bus
, -EINVAL
);
4073 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4074 assert_return(!bus
->bus_client
, -EPERM
);
4075 assert_return(!sender
|| service_name_is_valid(sender
), -EINVAL
);
4077 return free_and_strdup(&bus
->patch_sender
, sender
);
4080 _public_
int sd_bus_get_sender(sd_bus
*bus
, const char **ret
) {
4081 assert_return(bus
, -EINVAL
);
4082 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4083 assert_return(ret
, -EINVAL
);
4085 if (!bus
->patch_sender
)
4088 *ret
= bus
->patch_sender
;
4092 _public_
int sd_bus_get_n_queued_read(sd_bus
*bus
, uint64_t *ret
) {
4093 assert_return(bus
, -EINVAL
);
4094 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4095 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4096 assert_return(ret
, -EINVAL
);
4098 *ret
= bus
->rqueue_size
;
4102 _public_
int sd_bus_get_n_queued_write(sd_bus
*bus
, uint64_t *ret
) {
4103 assert_return(bus
, -EINVAL
);
4104 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4105 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4106 assert_return(ret
, -EINVAL
);
4108 *ret
= bus
->wqueue_size
;
4112 _public_
int sd_bus_set_method_call_timeout(sd_bus
*bus
, uint64_t usec
) {
4113 assert_return(bus
, -EINVAL
);
4114 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4116 bus
->method_call_timeout
= usec
;
4120 _public_
int sd_bus_get_method_call_timeout(sd_bus
*bus
, uint64_t *ret
) {
4124 assert_return(bus
, -EINVAL
);
4125 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4126 assert_return(ret
, -EINVAL
);
4128 if (bus
->method_call_timeout
!= 0) {
4129 *ret
= bus
->method_call_timeout
;
4133 e
= secure_getenv("SYSTEMD_BUS_TIMEOUT");
4134 if (e
&& parse_sec(e
, &usec
) >= 0 && usec
!= 0) {
4135 /* Save the parsed value to avoid multiple parsing. To change the timeout value,
4136 * use sd_bus_set_method_call_timeout() instead of setenv(). */
4137 *ret
= bus
->method_call_timeout
= usec
;
4141 *ret
= bus
->method_call_timeout
= BUS_DEFAULT_TIMEOUT
;
4145 _public_
int sd_bus_set_close_on_exit(sd_bus
*bus
, int b
) {
4146 assert_return(bus
, -EINVAL
);
4147 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4149 bus
->close_on_exit
= b
;
4153 _public_
int sd_bus_get_close_on_exit(sd_bus
*bus
) {
4154 assert_return(bus
, -EINVAL
);
4155 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4157 return bus
->close_on_exit
;