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/>.
33 #include "alloc-util.h"
34 #include "bus-container.h"
35 #include "bus-control.h"
36 #include "bus-internal.h"
37 #include "bus-kernel.h"
38 #include "bus-label.h"
39 #include "bus-message.h"
40 #include "bus-objects.h"
41 #include "bus-protocol.h"
43 #include "bus-socket.h"
44 #include "bus-track.h"
47 #include "cgroup-util.h"
50 #include "hexdecoct.h"
51 #include "hostname-util.h"
54 #include "parse-util.h"
55 #include "process-util.h"
56 #include "string-util.h"
60 #define log_debug_bus_message(m) \
62 sd_bus_message *_mm = (m); \
63 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", \
64 bus_message_type_to_string(_mm->header->type), \
65 strna(sd_bus_message_get_sender(_mm)), \
66 strna(sd_bus_message_get_destination(_mm)), \
67 strna(sd_bus_message_get_path(_mm)), \
68 strna(sd_bus_message_get_interface(_mm)), \
69 strna(sd_bus_message_get_member(_mm)), \
70 BUS_MESSAGE_COOKIE(_mm), \
72 strna(_mm->root_container.signature), \
73 strna(_mm->error.name), \
74 strna(_mm->error.message)); \
77 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
);
78 static void bus_detach_io_events(sd_bus
*b
);
79 static void bus_detach_inotify_event(sd_bus
*b
);
81 static thread_local sd_bus
*default_system_bus
= NULL
;
82 static thread_local sd_bus
*default_user_bus
= NULL
;
83 static thread_local sd_bus
*default_starter_bus
= NULL
;
85 static sd_bus
**bus_choose_default(int (**bus_open
)(sd_bus
**)) {
88 /* Let's try our best to reuse another cached connection. If
89 * the starter bus type is set, connect via our normal
90 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
91 * we can share the connection with the user/system default
94 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
96 if (streq(e
, "system")) {
98 *bus_open
= sd_bus_open_system
;
99 return &default_system_bus
;
100 } else if (STR_IN_SET(e
, "user", "session")) {
102 *bus_open
= sd_bus_open_user
;
103 return &default_user_bus
;
107 /* No type is specified, so we have not other option than to
108 * use the starter address if it is set. */
109 e
= secure_getenv("DBUS_STARTER_ADDRESS");
112 *bus_open
= sd_bus_open
;
113 return &default_starter_bus
;
116 /* Finally, if nothing is set use the cached connection for
119 if (cg_pid_get_owner_uid(0, NULL
) >= 0) {
121 *bus_open
= sd_bus_open_user
;
122 return &default_user_bus
;
125 *bus_open
= sd_bus_open_system
;
126 return &default_system_bus
;
130 sd_bus
*bus_resolve(sd_bus
*bus
) {
131 switch ((uintptr_t) bus
) {
132 case (uintptr_t) SD_BUS_DEFAULT
:
133 return *(bus_choose_default(NULL
));
134 case (uintptr_t) SD_BUS_DEFAULT_USER
:
135 return default_user_bus
;
136 case (uintptr_t) SD_BUS_DEFAULT_SYSTEM
:
137 return default_system_bus
;
143 void bus_close_io_fds(sd_bus
*b
) {
146 bus_detach_io_events(b
);
148 if (b
->input_fd
!= b
->output_fd
)
149 safe_close(b
->output_fd
);
150 b
->output_fd
= b
->input_fd
= safe_close(b
->input_fd
);
153 void bus_close_inotify_fd(sd_bus
*b
) {
156 bus_detach_inotify_event(b
);
158 b
->inotify_fd
= safe_close(b
->inotify_fd
);
159 b
->inotify_watches
= mfree(b
->inotify_watches
);
160 b
->n_inotify_watches
= 0;
163 static void bus_reset_queues(sd_bus
*b
) {
166 while (b
->rqueue_size
> 0)
167 sd_bus_message_unref(b
->rqueue
[--b
->rqueue_size
]);
169 b
->rqueue
= mfree(b
->rqueue
);
170 b
->rqueue_allocated
= 0;
172 while (b
->wqueue_size
> 0)
173 sd_bus_message_unref(b
->wqueue
[--b
->wqueue_size
]);
175 b
->wqueue
= mfree(b
->wqueue
);
176 b
->wqueue_allocated
= 0;
179 static void bus_free(sd_bus
*b
) {
183 assert(!b
->track_queue
);
186 b
->state
= BUS_CLOSED
;
188 sd_bus_detach_event(b
);
190 while ((s
= b
->slots
)) {
191 /* At this point only floating slots can still be
192 * around, because the non-floating ones keep a
193 * reference to the bus, and we thus couldn't be
194 * destructing right now... We forcibly disconnect the
195 * slots here, so that they still can be referenced by
196 * apps, but are dead. */
199 bus_slot_disconnect(s
);
200 sd_bus_slot_unref(s
);
203 if (b
->default_bus_ptr
)
204 *b
->default_bus_ptr
= NULL
;
207 bus_close_inotify_fd(b
);
212 free(b
->unique_name
);
213 free(b
->auth_buffer
);
216 free(b
->cgroup_root
);
217 free(b
->description
);
218 free(b
->patch_sender
);
221 strv_free(b
->exec_argv
);
223 close_many(b
->fds
, b
->n_fds
);
228 ordered_hashmap_free_free(b
->reply_callbacks
);
229 prioq_free(b
->reply_callbacks_prioq
);
231 assert(b
->match_callbacks
.type
== BUS_MATCH_ROOT
);
232 bus_match_free(&b
->match_callbacks
);
234 hashmap_free_free(b
->vtable_methods
);
235 hashmap_free_free(b
->vtable_properties
);
237 assert(hashmap_isempty(b
->nodes
));
238 hashmap_free(b
->nodes
);
242 assert_se(pthread_mutex_destroy(&b
->memfd_cache_mutex
) == 0);
247 _public_
int sd_bus_new(sd_bus
**ret
) {
250 assert_return(ret
, -EINVAL
);
256 r
->n_ref
= REFCNT_INIT
;
257 r
->input_fd
= r
->output_fd
= -1;
259 r
->message_version
= 1;
260 r
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
262 r
->original_pid
= getpid_cached();
263 r
->n_groups
= (size_t) -1;
265 assert_se(pthread_mutex_init(&r
->memfd_cache_mutex
, NULL
) == 0);
267 /* We guarantee that wqueue always has space for at least one
269 if (!GREEDY_REALLOC(r
->wqueue
, r
->wqueue_allocated
, 1)) {
278 _public_
int sd_bus_set_address(sd_bus
*bus
, const char *address
) {
281 assert_return(bus
, -EINVAL
);
282 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
283 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
284 assert_return(address
, -EINVAL
);
285 assert_return(!bus_pid_changed(bus
), -ECHILD
);
291 free_and_replace(bus
->address
, a
);
296 _public_
int sd_bus_set_fd(sd_bus
*bus
, int input_fd
, int output_fd
) {
297 assert_return(bus
, -EINVAL
);
298 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
299 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
300 assert_return(input_fd
>= 0, -EBADF
);
301 assert_return(output_fd
>= 0, -EBADF
);
302 assert_return(!bus_pid_changed(bus
), -ECHILD
);
304 bus
->input_fd
= input_fd
;
305 bus
->output_fd
= output_fd
;
309 _public_
int sd_bus_set_exec(sd_bus
*bus
, const char *path
, char *const argv
[]) {
312 assert_return(bus
, -EINVAL
);
313 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
314 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
315 assert_return(path
, -EINVAL
);
316 assert_return(!strv_isempty(argv
), -EINVAL
);
317 assert_return(!bus_pid_changed(bus
), -ECHILD
);
329 free_and_replace(bus
->exec_path
, p
);
331 strv_free(bus
->exec_argv
);
337 _public_
int sd_bus_set_bus_client(sd_bus
*bus
, int b
) {
338 assert_return(bus
, -EINVAL
);
339 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
340 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
341 assert_return(!bus
->patch_sender
, -EPERM
);
342 assert_return(!bus_pid_changed(bus
), -ECHILD
);
344 bus
->bus_client
= !!b
;
348 _public_
int sd_bus_set_monitor(sd_bus
*bus
, int b
) {
349 assert_return(bus
, -EINVAL
);
350 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
351 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
352 assert_return(!bus_pid_changed(bus
), -ECHILD
);
354 bus
->is_monitor
= !!b
;
358 _public_
int sd_bus_negotiate_fds(sd_bus
*bus
, int b
) {
359 assert_return(bus
, -EINVAL
);
360 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
361 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
362 assert_return(!bus_pid_changed(bus
), -ECHILD
);
364 bus
->accept_fd
= !!b
;
368 _public_
int sd_bus_negotiate_timestamp(sd_bus
*bus
, int b
) {
369 assert_return(bus
, -EINVAL
);
370 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
371 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
372 assert_return(!bus_pid_changed(bus
), -ECHILD
);
374 /* This is not actually supported by any of our transports these days, but we do honour it for synthetic
375 * replies, and maybe one day classic D-Bus learns this too */
376 bus
->attach_timestamp
= !!b
;
381 _public_
int sd_bus_negotiate_creds(sd_bus
*bus
, int b
, uint64_t mask
) {
382 assert_return(bus
, -EINVAL
);
383 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
384 assert_return(mask
<= _SD_BUS_CREDS_ALL
, -EINVAL
);
385 assert_return(!IN_SET(bus
->state
, BUS_CLOSING
, BUS_CLOSED
), -EPERM
);
386 assert_return(!bus_pid_changed(bus
), -ECHILD
);
388 SET_FLAG(bus
->creds_mask
, mask
, b
);
390 /* The well knowns we need unconditionally, so that matches can work */
391 bus
->creds_mask
|= SD_BUS_CREDS_WELL_KNOWN_NAMES
|SD_BUS_CREDS_UNIQUE_NAME
;
396 _public_
int sd_bus_set_server(sd_bus
*bus
, int b
, sd_id128_t server_id
) {
397 assert_return(bus
, -EINVAL
);
398 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
399 assert_return(b
|| sd_id128_equal(server_id
, SD_ID128_NULL
), -EINVAL
);
400 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
401 assert_return(!bus_pid_changed(bus
), -ECHILD
);
403 bus
->is_server
= !!b
;
404 bus
->server_id
= server_id
;
408 _public_
int sd_bus_set_anonymous(sd_bus
*bus
, int b
) {
409 assert_return(bus
, -EINVAL
);
410 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
411 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
412 assert_return(!bus_pid_changed(bus
), -ECHILD
);
414 bus
->anonymous_auth
= !!b
;
418 _public_
int sd_bus_set_trusted(sd_bus
*bus
, int b
) {
419 assert_return(bus
, -EINVAL
);
420 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
421 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
422 assert_return(!bus_pid_changed(bus
), -ECHILD
);
428 _public_
int sd_bus_set_description(sd_bus
*bus
, const char *description
) {
429 assert_return(bus
, -EINVAL
);
430 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
431 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
432 assert_return(!bus_pid_changed(bus
), -ECHILD
);
434 return free_and_strdup(&bus
->description
, description
);
437 _public_
int sd_bus_set_allow_interactive_authorization(sd_bus
*bus
, int b
) {
438 assert_return(bus
, -EINVAL
);
439 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
440 assert_return(!bus_pid_changed(bus
), -ECHILD
);
442 bus
->allow_interactive_authorization
= !!b
;
446 _public_
int sd_bus_get_allow_interactive_authorization(sd_bus
*bus
) {
447 assert_return(bus
, -EINVAL
);
448 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
449 assert_return(!bus_pid_changed(bus
), -ECHILD
);
451 return bus
->allow_interactive_authorization
;
454 _public_
int sd_bus_set_watch_bind(sd_bus
*bus
, int b
) {
455 assert_return(bus
, -EINVAL
);
456 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
457 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
458 assert_return(!bus_pid_changed(bus
), -ECHILD
);
460 bus
->watch_bind
= !!b
;
464 _public_
int sd_bus_get_watch_bind(sd_bus
*bus
) {
465 assert_return(bus
, -EINVAL
);
466 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
467 assert_return(!bus_pid_changed(bus
), -ECHILD
);
469 return bus
->watch_bind
;
472 _public_
int sd_bus_set_connected_signal(sd_bus
*bus
, int b
) {
473 assert_return(bus
, -EINVAL
);
474 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
475 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
476 assert_return(!bus_pid_changed(bus
), -ECHILD
);
478 bus
->connected_signal
= !!b
;
482 _public_
int sd_bus_get_connected_signal(sd_bus
*bus
) {
483 assert_return(bus
, -EINVAL
);
484 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
485 assert_return(!bus_pid_changed(bus
), -ECHILD
);
487 return bus
->connected_signal
;
490 static int synthesize_connected_signal(sd_bus
*bus
) {
491 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
496 /* If enabled, synthesizes a local "Connected" signal mirroring the local "Disconnected" signal. This is called
497 * whenever we fully established a connection, i.e. after the authorization phase, and after receiving the
498 * Hello() reply. Or in other words, whenver we enter BUS_RUNNING state.
500 * This is useful so that clients can start doing stuff whenver the connection is fully established in a way
501 * that works independently from whether we connected to a full bus or just a direct connection. */
503 if (!bus
->connected_signal
)
506 r
= sd_bus_message_new_signal(
509 "/org/freedesktop/DBus/Local",
510 "org.freedesktop.DBus.Local",
515 bus_message_set_sender_local(bus
, m
);
517 r
= bus_seal_synthetic_message(bus
, m
);
521 r
= bus_rqueue_make_room(bus
);
525 /* Insert at the very front */
526 memmove(bus
->rqueue
+ 1, bus
->rqueue
, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
534 void bus_set_state(sd_bus
*bus
, enum bus_state state
) {
536 static const char * const table
[_BUS_STATE_MAX
] = {
537 [BUS_UNSET
] = "UNSET",
538 [BUS_WATCH_BIND
] = "WATCH_BIND",
539 [BUS_OPENING
] = "OPENING",
540 [BUS_AUTHENTICATING
] = "AUTHENTICATING",
541 [BUS_HELLO
] = "HELLO",
542 [BUS_RUNNING
] = "RUNNING",
543 [BUS_CLOSING
] = "CLOSING",
544 [BUS_CLOSED
] = "CLOSED",
548 assert(state
< _BUS_STATE_MAX
);
550 if (state
== bus
->state
)
553 log_debug("Bus %s: changing state %s → %s", strna(bus
->description
), table
[bus
->state
], table
[state
]);
557 static int hello_callback(sd_bus_message
*reply
, void *userdata
, sd_bus_error
*error
) {
566 assert(IN_SET(bus
->state
, BUS_HELLO
, BUS_CLOSING
));
568 r
= sd_bus_message_get_errno(reply
);
572 r
= sd_bus_message_read(reply
, "s", &s
);
576 if (!service_name_is_valid(s
) || s
[0] != ':')
583 free_and_replace(bus
->unique_name
, t
);
585 if (bus
->state
== BUS_HELLO
) {
586 bus_set_state(bus
, BUS_RUNNING
);
588 r
= synthesize_connected_signal(bus
);
596 static int bus_send_hello(sd_bus
*bus
) {
597 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
602 if (!bus
->bus_client
)
605 r
= sd_bus_message_new_method_call(
608 "org.freedesktop.DBus",
609 "/org/freedesktop/DBus",
610 "org.freedesktop.DBus",
615 return sd_bus_call_async(bus
, NULL
, m
, hello_callback
, NULL
, 0);
618 int bus_start_running(sd_bus
*bus
) {
619 struct reply_callback
*c
;
625 assert(bus
->state
< BUS_HELLO
);
627 /* We start all method call timeouts when we enter BUS_HELLO or BUS_RUNNING mode. At this point let's convert
628 * all relative to absolute timestamps. Note that we do not reshuffle the reply callback priority queue since
629 * adding a fixed value to all entries should not alter the internal order. */
631 n
= now(CLOCK_MONOTONIC
);
632 ORDERED_HASHMAP_FOREACH(c
, bus
->reply_callbacks
, i
) {
633 if (c
->timeout_usec
== 0)
636 c
->timeout_usec
= usec_add(n
, c
->timeout_usec
);
639 if (bus
->bus_client
) {
640 bus_set_state(bus
, BUS_HELLO
);
644 bus_set_state(bus
, BUS_RUNNING
);
646 r
= synthesize_connected_signal(bus
);
653 static int parse_address_key(const char **p
, const char *key
, char **value
) {
654 size_t l
, n
= 0, allocated
= 0;
655 _cleanup_free_
char *r
= NULL
;
664 if (strncmp(*p
, key
, l
) != 0)
677 while (!IN_SET(*a
, ';', ',', 0)) {
691 c
= (char) ((x
<< 4) | y
);
698 if (!GREEDY_REALLOC(r
, allocated
, n
+ 2))
716 free_and_replace(*value
, r
);
721 static void skip_address_key(const char **p
) {
725 *p
+= strcspn(*p
, ",");
731 static int parse_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
732 _cleanup_free_
char *path
= NULL
, *abstract
= NULL
;
741 while (!IN_SET(**p
, 0, ';')) {
742 r
= parse_address_key(p
, "guid", guid
);
748 r
= parse_address_key(p
, "path", &path
);
754 r
= parse_address_key(p
, "abstract", &abstract
);
763 if (!path
&& !abstract
)
766 if (path
&& abstract
)
771 if (l
> sizeof(b
->sockaddr
.un
.sun_path
))
774 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
775 strncpy(b
->sockaddr
.un
.sun_path
, path
, sizeof(b
->sockaddr
.un
.sun_path
));
776 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + l
;
777 } else if (abstract
) {
778 l
= strlen(abstract
);
779 if (l
> sizeof(b
->sockaddr
.un
.sun_path
) - 1)
782 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
783 b
->sockaddr
.un
.sun_path
[0] = 0;
784 strncpy(b
->sockaddr
.un
.sun_path
+1, abstract
, sizeof(b
->sockaddr
.un
.sun_path
)-1);
785 b
->sockaddr_size
= offsetof(struct sockaddr_un
, sun_path
) + 1 + l
;
793 static int parse_tcp_address(sd_bus
*b
, const char **p
, char **guid
) {
794 _cleanup_free_
char *host
= NULL
, *port
= NULL
, *family
= NULL
;
796 struct addrinfo
*result
, hints
= {
797 .ai_socktype
= SOCK_STREAM
,
798 .ai_flags
= AI_ADDRCONFIG
,
806 while (!IN_SET(**p
, 0, ';')) {
807 r
= parse_address_key(p
, "guid", guid
);
813 r
= parse_address_key(p
, "host", &host
);
819 r
= parse_address_key(p
, "port", &port
);
825 r
= parse_address_key(p
, "family", &family
);
838 if (streq(family
, "ipv4"))
839 hints
.ai_family
= AF_INET
;
840 else if (streq(family
, "ipv6"))
841 hints
.ai_family
= AF_INET6
;
846 r
= getaddrinfo(host
, port
, &hints
, &result
);
850 return -EADDRNOTAVAIL
;
852 memcpy(&b
->sockaddr
, result
->ai_addr
, result
->ai_addrlen
);
853 b
->sockaddr_size
= result
->ai_addrlen
;
855 freeaddrinfo(result
);
862 static int parse_exec_address(sd_bus
*b
, const char **p
, char **guid
) {
864 unsigned n_argv
= 0, j
;
866 size_t allocated
= 0;
874 while (!IN_SET(**p
, 0, ';')) {
875 r
= parse_address_key(p
, "guid", guid
);
881 r
= parse_address_key(p
, "path", &path
);
887 if (startswith(*p
, "argv")) {
891 ul
= strtoul(*p
+ 4, (char**) p
, 10);
892 if (errno
> 0 || **p
!= '=' || ul
> 256) {
900 if (!GREEDY_REALLOC0(argv
, allocated
, ul
+ 2)) {
908 r
= parse_address_key(p
, NULL
, argv
+ ul
);
923 /* Make sure there are no holes in the array, with the
924 * exception of argv[0] */
925 for (j
= 1; j
< n_argv
; j
++)
931 if (argv
&& argv
[0] == NULL
) {
932 argv
[0] = strdup(path
);
947 for (j
= 0; j
< n_argv
; j
++)
955 static int parse_container_unix_address(sd_bus
*b
, const char **p
, char **guid
) {
956 _cleanup_free_
char *machine
= NULL
, *pid
= NULL
;
964 while (!IN_SET(**p
, 0, ';')) {
965 r
= parse_address_key(p
, "guid", guid
);
971 r
= parse_address_key(p
, "machine", &machine
);
977 r
= parse_address_key(p
, "pid", &pid
);
986 if (!machine
== !pid
)
990 if (!machine_name_is_valid(machine
))
993 free_and_replace(b
->machine
, machine
);
995 b
->machine
= mfree(b
->machine
);
999 r
= parse_pid(pid
, &b
->nspid
);
1005 b
->sockaddr
.un
.sun_family
= AF_UNIX
;
1006 /* Note that we use the old /var/run prefix here, to increase compatibility with really old containers */
1007 strncpy(b
->sockaddr
.un
.sun_path
, "/var/run/dbus/system_bus_socket", sizeof(b
->sockaddr
.un
.sun_path
));
1008 b
->sockaddr_size
= SOCKADDR_UN_LEN(b
->sockaddr
.un
);
1009 b
->is_local
= false;
1014 static void bus_reset_parsed_address(sd_bus
*b
) {
1018 b
->sockaddr_size
= 0;
1019 b
->exec_argv
= strv_free(b
->exec_argv
);
1020 b
->exec_path
= mfree(b
->exec_path
);
1021 b
->server_id
= SD_ID128_NULL
;
1022 b
->machine
= mfree(b
->machine
);
1026 static int bus_parse_next_address(sd_bus
*b
) {
1027 _cleanup_free_
char *guid
= NULL
;
1035 if (b
->address
[b
->address_index
] == 0)
1038 bus_reset_parsed_address(b
);
1040 a
= b
->address
+ b
->address_index
;
1049 if (startswith(a
, "unix:")) {
1052 r
= parse_unix_address(b
, &a
, &guid
);
1057 } else if (startswith(a
, "tcp:")) {
1060 r
= parse_tcp_address(b
, &a
, &guid
);
1066 } else if (startswith(a
, "unixexec:")) {
1069 r
= parse_exec_address(b
, &a
, &guid
);
1075 } else if (startswith(a
, "x-machine-unix:")) {
1078 r
= parse_container_unix_address(b
, &a
, &guid
);
1091 r
= sd_id128_from_string(guid
, &b
->server_id
);
1096 b
->address_index
= a
- b
->address
;
1100 static void bus_kill_exec(sd_bus
*bus
) {
1101 if (pid_is_valid(bus
->busexec_pid
) > 0) {
1102 sigterm_wait(bus
->busexec_pid
);
1103 bus
->busexec_pid
= 0;
1107 static int bus_start_address(sd_bus
*b
) {
1113 bus_close_io_fds(b
);
1114 bus_close_inotify_fd(b
);
1118 /* If you provide multiple different bus-addresses, we
1119 * try all of them in order and use the first one that
1123 r
= bus_socket_exec(b
);
1124 else if ((b
->nspid
> 0 || b
->machine
) && b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1125 r
= bus_container_connect_socket(b
);
1126 else if (b
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
)
1127 r
= bus_socket_connect(b
);
1134 q
= bus_attach_io_events(b
);
1138 q
= bus_attach_inotify_event(b
);
1145 b
->last_connect_error
= -r
;
1148 r
= bus_parse_next_address(b
);
1152 return b
->last_connect_error
> 0 ? -b
->last_connect_error
: -ECONNREFUSED
;
1156 int bus_next_address(sd_bus
*b
) {
1159 bus_reset_parsed_address(b
);
1160 return bus_start_address(b
);
1163 static int bus_start_fd(sd_bus
*b
) {
1168 assert(b
->input_fd
>= 0);
1169 assert(b
->output_fd
>= 0);
1171 r
= fd_nonblock(b
->input_fd
, true);
1175 r
= fd_cloexec(b
->input_fd
, true);
1179 if (b
->input_fd
!= b
->output_fd
) {
1180 r
= fd_nonblock(b
->output_fd
, true);
1184 r
= fd_cloexec(b
->output_fd
, true);
1189 if (fstat(b
->input_fd
, &st
) < 0)
1192 return bus_socket_take_fd(b
);
1195 _public_
int sd_bus_start(sd_bus
*bus
) {
1198 assert_return(bus
, -EINVAL
);
1199 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
1200 assert_return(bus
->state
== BUS_UNSET
, -EPERM
);
1201 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1203 bus_set_state(bus
, BUS_OPENING
);
1205 if (bus
->is_server
&& bus
->bus_client
)
1208 if (bus
->input_fd
>= 0)
1209 r
= bus_start_fd(bus
);
1210 else if (bus
->address
|| bus
->sockaddr
.sa
.sa_family
!= AF_UNSPEC
|| bus
->exec_path
|| bus
->machine
)
1211 r
= bus_start_address(bus
);
1220 return bus_send_hello(bus
);
1223 _public_
int sd_bus_open(sd_bus
**ret
) {
1228 assert_return(ret
, -EINVAL
);
1230 /* Let's connect to the starter bus if it is set, and
1231 * otherwise to the bus that is appropropriate for the scope
1232 * we are running in */
1234 e
= secure_getenv("DBUS_STARTER_BUS_TYPE");
1236 if (streq(e
, "system"))
1237 return sd_bus_open_system(ret
);
1238 else if (STR_IN_SET(e
, "session", "user"))
1239 return sd_bus_open_user(ret
);
1242 e
= secure_getenv("DBUS_STARTER_ADDRESS");
1244 if (cg_pid_get_owner_uid(0, NULL
) >= 0)
1245 return sd_bus_open_user(ret
);
1247 return sd_bus_open_system(ret
);
1254 r
= sd_bus_set_address(b
, e
);
1258 b
->bus_client
= true;
1260 /* We don't know whether the bus is trusted or not, so better
1261 * be safe, and authenticate everything */
1263 b
->is_local
= false;
1264 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1266 r
= sd_bus_start(b
);
1278 int bus_set_address_system(sd_bus
*b
) {
1282 e
= secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1284 return sd_bus_set_address(b
, e
);
1286 return sd_bus_set_address(b
, DEFAULT_SYSTEM_BUS_ADDRESS
);
1289 _public_
int sd_bus_open_system(sd_bus
**ret
) {
1293 assert_return(ret
, -EINVAL
);
1299 r
= bus_set_address_system(b
);
1303 b
->bus_client
= true;
1304 b
->is_system
= true;
1306 /* Let's do per-method access control on the system bus. We
1307 * need the caller's UID and capability set for that. */
1309 b
->creds_mask
|= SD_BUS_CREDS_UID
| SD_BUS_CREDS_EUID
| SD_BUS_CREDS_EFFECTIVE_CAPS
;
1312 r
= sd_bus_start(b
);
1324 int bus_set_address_user(sd_bus
*b
) {
1326 _cleanup_free_
char *ee
= NULL
, *s
= NULL
;
1330 e
= secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1332 return sd_bus_set_address(b
, e
);
1334 e
= secure_getenv("XDG_RUNTIME_DIR");
1338 ee
= bus_address_escape(e
);
1342 if (asprintf(&s
, DEFAULT_USER_BUS_ADDRESS_FMT
, ee
) < 0)
1351 _public_
int sd_bus_open_user(sd_bus
**ret
) {
1355 assert_return(ret
, -EINVAL
);
1361 r
= bus_set_address_user(b
);
1365 b
->bus_client
= true;
1368 /* We don't do any per-method access control on the user
1373 r
= sd_bus_start(b
);
1385 int bus_set_address_system_remote(sd_bus
*b
, const char *host
) {
1386 _cleanup_free_
char *e
= NULL
;
1387 char *m
= NULL
, *c
= NULL
, *a
;
1392 /* Let's see if we shall enter some container */
1393 m
= strchr(host
, ':');
1397 /* Let's make sure this is not a port of some kind,
1398 * and is a valid machine name. */
1399 if (!in_charset(m
, "0123456789") && machine_name_is_valid(m
)) {
1402 /* Cut out the host part */
1403 t
= strndupa(host
, m
- host
- 1);
1404 e
= bus_address_escape(t
);
1408 c
= strjoina(",argv5=--machine=", m
);
1413 e
= bus_address_escape(host
);
1418 a
= strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e
, ",argv4=systemd-stdio-bridge", c
);
1422 free_and_replace(b
->address
, a
);
1427 _public_
int sd_bus_open_system_remote(sd_bus
**ret
, const char *host
) {
1431 assert_return(host
, -EINVAL
);
1432 assert_return(ret
, -EINVAL
);
1434 r
= sd_bus_new(&bus
);
1438 r
= bus_set_address_system_remote(bus
, host
);
1442 bus
->bus_client
= true;
1443 bus
->trusted
= false;
1444 bus
->is_system
= true;
1445 bus
->is_local
= false;
1447 r
= sd_bus_start(bus
);
1459 int bus_set_address_system_machine(sd_bus
*b
, const char *machine
) {
1460 _cleanup_free_
char *e
= NULL
;
1466 e
= bus_address_escape(machine
);
1470 a
= strjoin("x-machine-unix:machine=", e
);
1474 free_and_replace(b
->address
, a
);
1479 _public_
int sd_bus_open_system_machine(sd_bus
**ret
, const char *machine
) {
1483 assert_return(machine
, -EINVAL
);
1484 assert_return(ret
, -EINVAL
);
1485 assert_return(machine_name_is_valid(machine
), -EINVAL
);
1487 r
= sd_bus_new(&bus
);
1491 r
= bus_set_address_system_machine(bus
, machine
);
1495 bus
->bus_client
= true;
1496 bus
->trusted
= false;
1497 bus
->is_system
= true;
1498 bus
->is_local
= false;
1500 r
= sd_bus_start(bus
);
1512 _public_
void sd_bus_close(sd_bus
*bus
) {
1516 if (bus
->state
== BUS_CLOSED
)
1518 if (bus_pid_changed(bus
))
1521 /* Don't leave ssh hanging around */
1524 bus_set_state(bus
, BUS_CLOSED
);
1526 sd_bus_detach_event(bus
);
1528 /* Drop all queued messages so that they drop references to
1529 * the bus object and the bus may be freed */
1530 bus_reset_queues(bus
);
1532 bus_close_io_fds(bus
);
1533 bus_close_inotify_fd(bus
);
1536 _public_ sd_bus
* sd_bus_flush_close_unref(sd_bus
*bus
) {
1541 /* Have to do this before flush() to prevent hang */
1547 return sd_bus_unref(bus
);
1550 void bus_enter_closing(sd_bus
*bus
) {
1553 if (!IN_SET(bus
->state
, BUS_WATCH_BIND
, BUS_OPENING
, BUS_AUTHENTICATING
, BUS_HELLO
, BUS_RUNNING
))
1556 bus_set_state(bus
, BUS_CLOSING
);
1559 _public_ sd_bus
*sd_bus_ref(sd_bus
*bus
) {
1564 assert_se(REFCNT_INC(bus
->n_ref
) >= 2);
1569 _public_ sd_bus
*sd_bus_unref(sd_bus
*bus
) {
1575 i
= REFCNT_DEC(bus
->n_ref
);
1583 _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 timeout
= BUS_DEFAULT_TIMEOUT
;
1658 if (!m
->sender
&& b
->patch_sender
) {
1659 r
= sd_bus_message_set_sender(m
, b
->patch_sender
);
1664 return sd_bus_message_seal(m
, ++b
->cookie
, timeout
);
1667 static int bus_remarshal_message(sd_bus
*b
, sd_bus_message
**m
) {
1668 bool remarshal
= false;
1672 /* wrong packet version */
1673 if (b
->message_version
!= 0 && b
->message_version
!= (*m
)->header
->version
)
1676 /* wrong packet endianness */
1677 if (b
->message_endian
!= 0 && b
->message_endian
!= (*m
)->header
->endian
)
1680 return remarshal
? bus_message_remarshal(b
, m
) : 0;
1683 int bus_seal_synthetic_message(sd_bus
*b
, sd_bus_message
*m
) {
1687 /* Fake some timestamps, if they were requested, and not
1688 * already initialized */
1689 if (b
->attach_timestamp
) {
1690 if (m
->realtime
<= 0)
1691 m
->realtime
= now(CLOCK_REALTIME
);
1693 if (m
->monotonic
<= 0)
1694 m
->monotonic
= now(CLOCK_MONOTONIC
);
1697 /* The bus specification says the serial number cannot be 0,
1698 * hence let's fill something in for synthetic messages. Since
1699 * synthetic messages might have a fake sender and we don't
1700 * want to interfere with the real sender's serial numbers we
1701 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1702 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1703 * even though kdbus can do 64bit. */
1704 return sd_bus_message_seal(m
, 0xFFFFFFFFULL
, 0);
1707 static int bus_write_message(sd_bus
*bus
, sd_bus_message
*m
, size_t *idx
) {
1713 r
= bus_socket_write_message(bus
, m
, idx
);
1717 if (*idx
>= BUS_MESSAGE_SIZE(m
))
1718 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",
1719 bus_message_type_to_string(m
->header
->type
),
1720 strna(sd_bus_message_get_sender(m
)),
1721 strna(sd_bus_message_get_destination(m
)),
1722 strna(sd_bus_message_get_path(m
)),
1723 strna(sd_bus_message_get_interface(m
)),
1724 strna(sd_bus_message_get_member(m
)),
1725 BUS_MESSAGE_COOKIE(m
),
1727 strna(m
->root_container
.signature
),
1728 strna(m
->error
.name
),
1729 strna(m
->error
.message
));
1734 static int dispatch_wqueue(sd_bus
*bus
) {
1738 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
1740 while (bus
->wqueue_size
> 0) {
1742 r
= bus_write_message(bus
, bus
->wqueue
[0], &bus
->windex
);
1746 /* Didn't do anything this time */
1748 else if (bus
->windex
>= BUS_MESSAGE_SIZE(bus
->wqueue
[0])) {
1749 /* Fully written. Let's drop the entry from
1752 * This isn't particularly optimized, but
1753 * well, this is supposed to be our worst-case
1754 * buffer only, and the socket buffer is
1755 * supposed to be our primary buffer, and if
1756 * it got full, then all bets are off
1760 sd_bus_message_unref(bus
->wqueue
[0]);
1761 memmove(bus
->wqueue
, bus
->wqueue
+ 1, sizeof(sd_bus_message
*) * bus
->wqueue_size
);
1771 static int bus_read_message(sd_bus
*bus
, bool hint_priority
, int64_t priority
) {
1774 return bus_socket_read_message(bus
);
1777 int bus_rqueue_make_room(sd_bus
*bus
) {
1780 if (bus
->rqueue_size
>= BUS_RQUEUE_MAX
)
1783 if (!GREEDY_REALLOC(bus
->rqueue
, bus
->rqueue_allocated
, bus
->rqueue_size
+ 1))
1789 static int dispatch_rqueue(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**m
) {
1794 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
1796 /* Note that the priority logic is only available on kdbus,
1797 * where the rqueue is unused. We check the rqueue here
1798 * anyway, because it's simple... */
1801 if (bus
->rqueue_size
> 0) {
1802 /* Dispatch a queued message */
1804 *m
= bus
->rqueue
[0];
1806 memmove(bus
->rqueue
, bus
->rqueue
+ 1, sizeof(sd_bus_message
*) * bus
->rqueue_size
);
1810 /* Try to read a new message */
1811 r
= bus_read_message(bus
, hint_priority
, priority
);
1821 _public_
int sd_bus_send(sd_bus
*bus
, sd_bus_message
*_m
, uint64_t *cookie
) {
1822 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1825 assert_return(m
, -EINVAL
);
1830 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1832 if (!BUS_IS_OPEN(bus
->state
))
1836 r
= sd_bus_can_send(bus
, SD_BUS_TYPE_UNIX_FD
);
1843 /* If the cookie number isn't kept, then we know that no reply
1845 if (!cookie
&& !m
->sealed
)
1846 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1848 r
= bus_seal_message(bus
, m
, 0);
1852 /* Remarshall if we have to. This will possibly unref the
1853 * message and place a replacement in m */
1854 r
= bus_remarshal_message(bus
, &m
);
1858 /* If this is a reply and no reply was requested, then let's
1859 * suppress this, if we can */
1863 if (IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
) && bus
->wqueue_size
<= 0) {
1866 r
= bus_write_message(bus
, m
, &idx
);
1868 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
1869 bus_enter_closing(bus
);
1876 if (idx
< BUS_MESSAGE_SIZE(m
)) {
1877 /* Wasn't fully written. So let's remember how
1878 * much was written. Note that the first entry
1879 * of the wqueue array is always allocated so
1880 * that we always can remember how much was
1882 bus
->wqueue
[0] = sd_bus_message_ref(m
);
1883 bus
->wqueue_size
= 1;
1888 /* Just append it to the queue. */
1890 if (bus
->wqueue_size
>= BUS_WQUEUE_MAX
)
1893 if (!GREEDY_REALLOC(bus
->wqueue
, bus
->wqueue_allocated
, bus
->wqueue_size
+ 1))
1896 bus
->wqueue
[bus
->wqueue_size
++] = sd_bus_message_ref(m
);
1901 *cookie
= BUS_MESSAGE_COOKIE(m
);
1906 _public_
int sd_bus_send_to(sd_bus
*bus
, sd_bus_message
*m
, const char *destination
, uint64_t *cookie
) {
1909 assert_return(m
, -EINVAL
);
1914 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1916 if (!BUS_IS_OPEN(bus
->state
))
1919 if (!streq_ptr(m
->destination
, destination
)) {
1924 r
= sd_bus_message_set_destination(m
, destination
);
1929 return sd_bus_send(bus
, m
, cookie
);
1932 static usec_t
calc_elapse(sd_bus
*bus
, uint64_t usec
) {
1935 if (usec
== (uint64_t) -1)
1938 /* We start all timeouts the instant we enter BUS_HELLO/BUS_RUNNING state, so that the don't run in parallel
1939 * with any connection setup states. Hence, if a method callback is started earlier than that we just store the
1940 * relative timestamp, and afterwards the absolute one. */
1942 if (IN_SET(bus
->state
, BUS_WATCH_BIND
, BUS_OPENING
, BUS_AUTHENTICATING
))
1945 return now(CLOCK_MONOTONIC
) + usec
;
1948 static int timeout_compare(const void *a
, const void *b
) {
1949 const struct reply_callback
*x
= a
, *y
= b
;
1951 if (x
->timeout_usec
!= 0 && y
->timeout_usec
== 0)
1954 if (x
->timeout_usec
== 0 && y
->timeout_usec
!= 0)
1957 if (x
->timeout_usec
< y
->timeout_usec
)
1960 if (x
->timeout_usec
> y
->timeout_usec
)
1966 _public_
int sd_bus_call_async(
1970 sd_bus_message_handler_t callback
,
1974 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
1975 _cleanup_(sd_bus_slot_unrefp
) sd_bus_slot
*s
= NULL
;
1978 assert_return(m
, -EINVAL
);
1979 assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
);
1980 assert_return(!m
->sealed
|| (!!callback
== !(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)), -EINVAL
);
1985 assert_return(!bus_pid_changed(bus
), -ECHILD
);
1987 if (!BUS_IS_OPEN(bus
->state
))
1990 /* If no callback is specified and there's no interest in a slot, then there's no reason to ask for a reply */
1991 if (!callback
&& !slot
&& !m
->sealed
)
1992 m
->header
->flags
|= BUS_MESSAGE_NO_REPLY_EXPECTED
;
1994 r
= ordered_hashmap_ensure_allocated(&bus
->reply_callbacks
, &uint64_hash_ops
);
1998 r
= prioq_ensure_allocated(&bus
->reply_callbacks_prioq
, timeout_compare
);
2002 r
= bus_seal_message(bus
, m
, usec
);
2006 r
= bus_remarshal_message(bus
, &m
);
2010 if (slot
|| callback
) {
2011 s
= bus_slot_allocate(bus
, !slot
, BUS_REPLY_CALLBACK
, sizeof(struct reply_callback
), userdata
);
2015 s
->reply_callback
.callback
= callback
;
2017 s
->reply_callback
.cookie
= BUS_MESSAGE_COOKIE(m
);
2018 r
= ordered_hashmap_put(bus
->reply_callbacks
, &s
->reply_callback
.cookie
, &s
->reply_callback
);
2020 s
->reply_callback
.cookie
= 0;
2024 s
->reply_callback
.timeout_usec
= calc_elapse(bus
, m
->timeout
);
2025 if (s
->reply_callback
.timeout_usec
!= 0) {
2026 r
= prioq_put(bus
->reply_callbacks_prioq
, &s
->reply_callback
, &s
->reply_callback
.prioq_idx
);
2028 s
->reply_callback
.timeout_usec
= 0;
2034 r
= sd_bus_send(bus
, m
, s
? &s
->reply_callback
.cookie
: NULL
);
2045 int bus_ensure_running(sd_bus
*bus
) {
2050 if (IN_SET(bus
->state
, BUS_UNSET
, BUS_CLOSED
, BUS_CLOSING
))
2052 if (bus
->state
== BUS_RUNNING
)
2056 r
= sd_bus_process(bus
, NULL
);
2059 if (bus
->state
== BUS_RUNNING
)
2064 r
= sd_bus_wait(bus
, (uint64_t) -1);
2070 _public_
int sd_bus_call(
2074 sd_bus_error
*error
,
2075 sd_bus_message
**reply
) {
2077 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= sd_bus_message_ref(_m
);
2083 bus_assert_return(m
, -EINVAL
, error
);
2084 bus_assert_return(m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
, -EINVAL
, error
);
2085 bus_assert_return(!(m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
), -EINVAL
, error
);
2086 bus_assert_return(!bus_error_is_dirty(error
), -EINVAL
, error
);
2091 bus_assert_return(!bus_pid_changed(bus
), -ECHILD
, error
);
2093 if (!BUS_IS_OPEN(bus
->state
)) {
2098 r
= bus_ensure_running(bus
);
2102 i
= bus
->rqueue_size
;
2104 r
= bus_seal_message(bus
, m
, usec
);
2108 r
= bus_remarshal_message(bus
, &m
);
2112 r
= sd_bus_send(bus
, m
, &cookie
);
2116 timeout
= calc_elapse(bus
, m
->timeout
);
2121 while (i
< bus
->rqueue_size
) {
2122 sd_bus_message
*incoming
= NULL
;
2124 incoming
= bus
->rqueue
[i
];
2126 if (incoming
->reply_cookie
== cookie
) {
2127 /* Found a match! */
2129 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2131 log_debug_bus_message(incoming
);
2133 if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_RETURN
) {
2135 if (incoming
->n_fds
<= 0 || bus
->accept_fd
) {
2139 sd_bus_message_unref(incoming
);
2144 r
= sd_bus_error_setf(error
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2145 sd_bus_message_unref(incoming
);
2148 } else if (incoming
->header
->type
== SD_BUS_MESSAGE_METHOD_ERROR
) {
2149 r
= sd_bus_error_copy(error
, &incoming
->error
);
2150 sd_bus_message_unref(incoming
);
2157 } else if (BUS_MESSAGE_COOKIE(incoming
) == cookie
&&
2160 streq(bus
->unique_name
, incoming
->sender
)) {
2162 memmove(bus
->rqueue
+ i
, bus
->rqueue
+ i
+ 1, sizeof(sd_bus_message
*) * (bus
->rqueue_size
- i
- 1));
2165 /* Our own message? Somebody is trying
2166 * to send its own client a message,
2167 * let's not dead-lock, let's fail
2170 sd_bus_message_unref(incoming
);
2175 /* Try to read more, right-away */
2179 r
= bus_read_message(bus
, false, 0);
2181 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2182 bus_enter_closing(bus
);
2194 n
= now(CLOCK_MONOTONIC
);
2202 left
= (uint64_t) -1;
2204 r
= bus_poll(bus
, true, left
);
2212 r
= dispatch_wqueue(bus
);
2214 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2215 bus_enter_closing(bus
);
2224 return sd_bus_error_set_errno(error
, r
);
2227 _public_
int sd_bus_get_fd(sd_bus
*bus
) {
2229 assert_return(bus
, -EINVAL
);
2230 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2231 assert_return(bus
->input_fd
== bus
->output_fd
, -EPERM
);
2232 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2234 if (bus
->state
== BUS_CLOSED
)
2237 if (bus
->inotify_fd
>= 0)
2238 return bus
->inotify_fd
;
2240 if (bus
->input_fd
>= 0)
2241 return bus
->input_fd
;
2246 _public_
int sd_bus_get_events(sd_bus
*bus
) {
2249 assert_return(bus
, -EINVAL
);
2250 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2251 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2253 switch (bus
->state
) {
2259 case BUS_WATCH_BIND
:
2267 case BUS_AUTHENTICATING
:
2268 if (bus_socket_auth_needs_write(bus
))
2276 if (bus
->rqueue_size
<= 0)
2278 if (bus
->wqueue_size
> 0)
2286 assert_not_reached("Unknown state");
2292 _public_
int sd_bus_get_timeout(sd_bus
*bus
, uint64_t *timeout_usec
) {
2293 struct reply_callback
*c
;
2295 assert_return(bus
, -EINVAL
);
2296 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2297 assert_return(timeout_usec
, -EINVAL
);
2298 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2300 if (!BUS_IS_OPEN(bus
->state
) && bus
->state
!= BUS_CLOSING
)
2303 if (bus
->track_queue
) {
2308 switch (bus
->state
) {
2310 case BUS_AUTHENTICATING
:
2311 *timeout_usec
= bus
->auth_timeout
;
2316 if (bus
->rqueue_size
> 0) {
2321 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2323 *timeout_usec
= (uint64_t) -1;
2327 if (c
->timeout_usec
== 0) {
2328 *timeout_usec
= (uint64_t) -1;
2332 *timeout_usec
= c
->timeout_usec
;
2339 case BUS_WATCH_BIND
:
2341 *timeout_usec
= (uint64_t) -1;
2345 assert_not_reached("Unknown or unexpected stat");
2349 static int process_timeout(sd_bus
*bus
) {
2350 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2351 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
* m
= NULL
;
2352 struct reply_callback
*c
;
2359 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
2361 c
= prioq_peek(bus
->reply_callbacks_prioq
);
2365 n
= now(CLOCK_MONOTONIC
);
2366 if (c
->timeout_usec
> n
)
2369 r
= bus_message_new_synthetic_error(
2372 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Method call timed out"),
2377 r
= bus_seal_synthetic_message(bus
, m
);
2381 assert_se(prioq_pop(bus
->reply_callbacks_prioq
) == c
);
2382 c
->timeout_usec
= 0;
2384 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2387 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2389 bus
->iteration_counter
++;
2391 is_hello
= bus
->state
== BUS_HELLO
&& c
->callback
== hello_callback
;
2393 bus
->current_message
= m
;
2394 bus
->current_slot
= sd_bus_slot_ref(slot
);
2395 bus
->current_handler
= c
->callback
;
2396 bus
->current_userdata
= slot
->userdata
;
2397 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2398 bus
->current_userdata
= NULL
;
2399 bus
->current_handler
= NULL
;
2400 bus
->current_slot
= NULL
;
2401 bus
->current_message
= NULL
;
2403 if (slot
->floating
) {
2404 bus_slot_disconnect(slot
);
2405 sd_bus_slot_unref(slot
);
2408 sd_bus_slot_unref(slot
);
2410 /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2411 * and ignore the callback handler's return value. */
2415 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2418 static int process_hello(sd_bus
*bus
, sd_bus_message
*m
) {
2422 if (bus
->state
!= BUS_HELLO
)
2425 /* Let's make sure the first message on the bus is the HELLO
2426 * reply. But note that we don't actually parse the message
2427 * here (we leave that to the usual handling), we just verify
2428 * we don't let any earlier msg through. */
2430 if (!IN_SET(m
->header
->type
, SD_BUS_MESSAGE_METHOD_RETURN
, SD_BUS_MESSAGE_METHOD_ERROR
))
2433 if (m
->reply_cookie
!= 1)
2439 static int process_reply(sd_bus
*bus
, sd_bus_message
*m
) {
2440 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*synthetic_reply
= NULL
;
2441 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2442 struct reply_callback
*c
;
2450 if (!IN_SET(m
->header
->type
, SD_BUS_MESSAGE_METHOD_RETURN
, SD_BUS_MESSAGE_METHOD_ERROR
))
2453 if (m
->destination
&& bus
->unique_name
&& !streq_ptr(m
->destination
, bus
->unique_name
))
2456 c
= ordered_hashmap_remove(bus
->reply_callbacks
, &m
->reply_cookie
);
2462 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2464 if (m
->n_fds
> 0 && !bus
->accept_fd
) {
2466 /* If the reply contained a file descriptor which we
2467 * didn't want we pass an error instead. */
2469 r
= bus_message_new_synthetic_error(
2472 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Reply message contained file descriptor"),
2477 /* Copy over original timestamp */
2478 synthetic_reply
->realtime
= m
->realtime
;
2479 synthetic_reply
->monotonic
= m
->monotonic
;
2480 synthetic_reply
->seqnum
= m
->seqnum
;
2482 r
= bus_seal_synthetic_message(bus
, synthetic_reply
);
2486 m
= synthetic_reply
;
2488 r
= sd_bus_message_rewind(m
, true);
2493 if (c
->timeout_usec
!= 0) {
2494 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2495 c
->timeout_usec
= 0;
2498 is_hello
= bus
->state
== BUS_HELLO
&& c
->callback
== hello_callback
;
2500 bus
->current_slot
= sd_bus_slot_ref(slot
);
2501 bus
->current_handler
= c
->callback
;
2502 bus
->current_userdata
= slot
->userdata
;
2503 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2504 bus
->current_userdata
= NULL
;
2505 bus
->current_handler
= NULL
;
2506 bus
->current_slot
= NULL
;
2508 if (slot
->floating
) {
2509 bus_slot_disconnect(slot
);
2510 sd_bus_slot_unref(slot
);
2513 sd_bus_slot_unref(slot
);
2515 /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2516 * ignore the callback handler's return value. */
2520 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2523 static int process_filter(sd_bus
*bus
, sd_bus_message
*m
) {
2524 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2525 struct filter_callback
*l
;
2532 bus
->filter_callbacks_modified
= false;
2534 LIST_FOREACH(callbacks
, l
, bus
->filter_callbacks
) {
2537 if (bus
->filter_callbacks_modified
)
2540 /* Don't run this more than once per iteration */
2541 if (l
->last_iteration
== bus
->iteration_counter
)
2544 l
->last_iteration
= bus
->iteration_counter
;
2546 r
= sd_bus_message_rewind(m
, true);
2550 slot
= container_of(l
, sd_bus_slot
, filter_callback
);
2552 bus
->current_slot
= sd_bus_slot_ref(slot
);
2553 bus
->current_handler
= l
->callback
;
2554 bus
->current_userdata
= slot
->userdata
;
2555 r
= l
->callback(m
, slot
->userdata
, &error_buffer
);
2556 bus
->current_userdata
= NULL
;
2557 bus
->current_handler
= NULL
;
2558 bus
->current_slot
= sd_bus_slot_unref(slot
);
2560 r
= bus_maybe_reply_error(m
, r
, &error_buffer
);
2566 } while (bus
->filter_callbacks_modified
);
2571 static int process_match(sd_bus
*bus
, sd_bus_message
*m
) {
2578 bus
->match_callbacks_modified
= false;
2580 r
= bus_match_run(bus
, &bus
->match_callbacks
, m
);
2584 } while (bus
->match_callbacks_modified
);
2589 static int process_builtin(sd_bus
*bus
, sd_bus_message
*m
) {
2590 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2596 if (bus
->is_monitor
)
2599 if (bus
->manual_peer_interface
)
2602 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2605 if (!streq_ptr(m
->interface
, "org.freedesktop.DBus.Peer"))
2608 if (m
->header
->flags
& BUS_MESSAGE_NO_REPLY_EXPECTED
)
2611 if (streq_ptr(m
->member
, "Ping"))
2612 r
= sd_bus_message_new_method_return(m
, &reply
);
2613 else if (streq_ptr(m
->member
, "GetMachineId")) {
2617 r
= sd_id128_get_machine(&id
);
2621 r
= sd_bus_message_new_method_return(m
, &reply
);
2625 r
= sd_bus_message_append(reply
, "s", sd_id128_to_string(id
, sid
));
2627 r
= sd_bus_message_new_method_errorf(
2629 SD_BUS_ERROR_UNKNOWN_METHOD
,
2630 "Unknown method '%s' on interface '%s'.", m
->member
, m
->interface
);
2636 r
= sd_bus_send(bus
, reply
, NULL
);
2643 static int process_fd_check(sd_bus
*bus
, sd_bus_message
*m
) {
2647 /* If we got a message with a file descriptor which we didn't
2648 * want to accept, then let's drop it. How can this even
2649 * happen? For example, when the kernel queues a message into
2650 * an activatable names's queue which allows fds, and then is
2651 * delivered to us later even though we ourselves did not
2654 if (bus
->is_monitor
)
2663 if (m
->header
->type
!= SD_BUS_MESSAGE_METHOD_CALL
)
2664 return 1; /* just eat it up */
2666 return sd_bus_reply_method_errorf(m
, SD_BUS_ERROR_INCONSISTENT_MESSAGE
, "Message contains file descriptors, which I cannot accept. Sorry.");
2669 static int process_message(sd_bus
*bus
, sd_bus_message
*m
) {
2675 bus
->current_message
= m
;
2676 bus
->iteration_counter
++;
2678 log_debug_bus_message(m
);
2680 r
= process_hello(bus
, m
);
2684 r
= process_reply(bus
, m
);
2688 r
= process_fd_check(bus
, m
);
2692 r
= process_filter(bus
, m
);
2696 r
= process_match(bus
, m
);
2700 r
= process_builtin(bus
, m
);
2704 r
= bus_process_object(bus
, m
);
2707 bus
->current_message
= NULL
;
2711 static int dispatch_track(sd_bus
*bus
) {
2714 if (!bus
->track_queue
)
2717 bus_track_dispatch(bus
->track_queue
);
2721 static int process_running(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2722 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2726 assert(IN_SET(bus
->state
, BUS_RUNNING
, BUS_HELLO
));
2728 r
= process_timeout(bus
);
2732 r
= dispatch_wqueue(bus
);
2736 r
= dispatch_track(bus
);
2740 r
= dispatch_rqueue(bus
, hint_priority
, priority
, &m
);
2746 r
= process_message(bus
, m
);
2751 r
= sd_bus_message_rewind(m
, true);
2760 if (m
->header
->type
== SD_BUS_MESSAGE_METHOD_CALL
) {
2762 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2763 strna(sd_bus_message_get_sender(m
)),
2764 strna(sd_bus_message_get_path(m
)),
2765 strna(sd_bus_message_get_interface(m
)),
2766 strna(sd_bus_message_get_member(m
)));
2768 r
= sd_bus_reply_method_errorf(
2770 SD_BUS_ERROR_UNKNOWN_OBJECT
,
2771 "Unknown object '%s'.", m
->path
);
2785 static int bus_exit_now(sd_bus
*bus
) {
2788 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2789 * sd_event_exit(), otherwise invokes libc exit(). */
2791 if (bus
->exited
) /* did we already exit? */
2793 if (!bus
->exit_triggered
) /* was the exit condition triggered? */
2795 if (!bus
->exit_on_disconnect
) /* Shall we actually exit on disconnection? */
2798 bus
->exited
= true; /* never exit more than once */
2800 log_debug("Bus connection disconnected, exiting.");
2803 return sd_event_exit(bus
->event
, EXIT_FAILURE
);
2807 assert_not_reached("exit() didn't exit?");
2810 static int process_closing_reply_callback(sd_bus
*bus
, struct reply_callback
*c
) {
2811 _cleanup_(sd_bus_error_free
) sd_bus_error error_buffer
= SD_BUS_ERROR_NULL
;
2812 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2819 r
= bus_message_new_synthetic_error(
2822 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY
, "Connection terminated"),
2827 r
= bus_seal_synthetic_message(bus
, m
);
2831 if (c
->timeout_usec
!= 0) {
2832 prioq_remove(bus
->reply_callbacks_prioq
, c
, &c
->prioq_idx
);
2833 c
->timeout_usec
= 0;
2836 ordered_hashmap_remove(bus
->reply_callbacks
, &c
->cookie
);
2839 slot
= container_of(c
, sd_bus_slot
, reply_callback
);
2841 bus
->iteration_counter
++;
2843 bus
->current_message
= m
;
2844 bus
->current_slot
= sd_bus_slot_ref(slot
);
2845 bus
->current_handler
= c
->callback
;
2846 bus
->current_userdata
= slot
->userdata
;
2847 r
= c
->callback(m
, slot
->userdata
, &error_buffer
);
2848 bus
->current_userdata
= NULL
;
2849 bus
->current_handler
= NULL
;
2850 bus
->current_slot
= NULL
;
2851 bus
->current_message
= NULL
;
2853 if (slot
->floating
) {
2854 bus_slot_disconnect(slot
);
2855 sd_bus_slot_unref(slot
);
2858 sd_bus_slot_unref(slot
);
2860 return bus_maybe_reply_error(m
, r
, &error_buffer
);
2863 static int process_closing(sd_bus
*bus
, sd_bus_message
**ret
) {
2864 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
;
2865 struct reply_callback
*c
;
2869 assert(bus
->state
== BUS_CLOSING
);
2871 /* First, fail all outstanding method calls */
2872 c
= ordered_hashmap_first(bus
->reply_callbacks
);
2874 return process_closing_reply_callback(bus
, c
);
2876 /* Then, fake-drop all remaining bus tracking references */
2878 bus_track_close(bus
->tracks
);
2882 /* Then, synthesize a Disconnected message */
2883 r
= sd_bus_message_new_signal(
2886 "/org/freedesktop/DBus/Local",
2887 "org.freedesktop.DBus.Local",
2892 bus_message_set_sender_local(bus
, m
);
2894 r
= bus_seal_synthetic_message(bus
, m
);
2900 bus
->current_message
= m
;
2901 bus
->iteration_counter
++;
2903 r
= process_filter(bus
, m
);
2907 r
= process_match(bus
, m
);
2911 /* Nothing else to do, exit now, if the condition holds */
2912 bus
->exit_triggered
= true;
2913 (void) bus_exit_now(bus
);
2923 bus
->current_message
= NULL
;
2928 static int bus_process_internal(sd_bus
*bus
, bool hint_priority
, int64_t priority
, sd_bus_message
**ret
) {
2929 BUS_DONT_DESTROY(bus
);
2932 /* Returns 0 when we didn't do anything. This should cause the
2933 * caller to invoke sd_bus_wait() before returning the next
2934 * time. Returns > 0 when we did something, which possibly
2935 * means *ret is filled in with an unprocessed message. */
2937 assert_return(bus
, -EINVAL
);
2938 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
2939 assert_return(!bus_pid_changed(bus
), -ECHILD
);
2941 /* We don't allow recursively invoking sd_bus_process(). */
2942 assert_return(!bus
->current_message
, -EBUSY
);
2943 assert(!bus
->current_slot
);
2945 switch (bus
->state
) {
2953 case BUS_WATCH_BIND
:
2954 r
= bus_socket_process_watch_bind(bus
);
2958 r
= bus_socket_process_opening(bus
);
2961 case BUS_AUTHENTICATING
:
2962 r
= bus_socket_process_authenticating(bus
);
2967 r
= process_running(bus
, hint_priority
, priority
, ret
);
2971 /* This branch initializes *ret, hence we don't use the generic error checking below */
2975 return process_closing(bus
, ret
);
2978 assert_not_reached("Unknown state");
2981 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
2982 bus_enter_closing(bus
);
2993 _public_
int sd_bus_process(sd_bus
*bus
, sd_bus_message
**ret
) {
2994 return bus_process_internal(bus
, false, 0, ret
);
2997 _public_
int sd_bus_process_priority(sd_bus
*bus
, int64_t priority
, sd_bus_message
**ret
) {
2998 return bus_process_internal(bus
, true, priority
, ret
);
3001 static int bus_poll(sd_bus
*bus
, bool need_more
, uint64_t timeout_usec
) {
3002 struct pollfd p
[2] = {};
3005 usec_t m
= USEC_INFINITY
;
3009 if (bus
->state
== BUS_CLOSING
)
3012 if (!BUS_IS_OPEN(bus
->state
))
3015 if (bus
->state
== BUS_WATCH_BIND
) {
3016 assert(bus
->inotify_fd
>= 0);
3018 p
[0].events
= POLLIN
;
3019 p
[0].fd
= bus
->inotify_fd
;
3024 e
= sd_bus_get_events(bus
);
3029 /* The caller really needs some more data, he doesn't
3030 * care about what's already read, or any timeouts
3031 * except its own. */
3035 /* The caller wants to process if there's something to
3036 * process, but doesn't care otherwise */
3038 r
= sd_bus_get_timeout(bus
, &until
);
3042 m
= usec_sub_unsigned(until
, now(CLOCK_MONOTONIC
));
3045 p
[0].fd
= bus
->input_fd
;
3046 if (bus
->output_fd
== bus
->input_fd
) {
3050 p
[0].events
= e
& POLLIN
;
3051 p
[1].fd
= bus
->output_fd
;
3052 p
[1].events
= e
& POLLOUT
;
3057 if (timeout_usec
!= (uint64_t) -1 && (m
== USEC_INFINITY
|| timeout_usec
< m
))
3060 r
= ppoll(p
, n
, m
== USEC_INFINITY
? NULL
: timespec_store(&ts
, m
), NULL
);
3064 return r
> 0 ? 1 : 0;
3067 _public_
int sd_bus_wait(sd_bus
*bus
, uint64_t timeout_usec
) {
3069 assert_return(bus
, -EINVAL
);
3070 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3071 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3073 if (bus
->state
== BUS_CLOSING
)
3076 if (!BUS_IS_OPEN(bus
->state
))
3079 if (bus
->rqueue_size
> 0)
3082 return bus_poll(bus
, false, timeout_usec
);
3085 _public_
int sd_bus_flush(sd_bus
*bus
) {
3088 assert_return(bus
, -EINVAL
);
3089 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3090 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3092 if (bus
->state
== BUS_CLOSING
)
3095 if (!BUS_IS_OPEN(bus
->state
))
3098 /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
3099 if (bus
->state
== BUS_WATCH_BIND
)
3102 r
= bus_ensure_running(bus
);
3106 if (bus
->wqueue_size
<= 0)
3110 r
= dispatch_wqueue(bus
);
3112 if (IN_SET(r
, -ENOTCONN
, -ECONNRESET
, -EPIPE
, -ESHUTDOWN
)) {
3113 bus_enter_closing(bus
);
3120 if (bus
->wqueue_size
<= 0)
3123 r
= bus_poll(bus
, false, (uint64_t) -1);
3129 _public_
int sd_bus_add_filter(
3132 sd_bus_message_handler_t callback
,
3137 assert_return(bus
, -EINVAL
);
3138 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3139 assert_return(callback
, -EINVAL
);
3140 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3142 s
= bus_slot_allocate(bus
, !slot
, BUS_FILTER_CALLBACK
, sizeof(struct filter_callback
), userdata
);
3146 s
->filter_callback
.callback
= callback
;
3148 bus
->filter_callbacks_modified
= true;
3149 LIST_PREPEND(callbacks
, bus
->filter_callbacks
, &s
->filter_callback
);
3157 static int add_match_callback(
3160 sd_bus_error
*ret_error
) {
3162 sd_bus_slot
*match_slot
= userdata
;
3163 bool failed
= false;
3169 sd_bus_slot_ref(match_slot
);
3171 if (sd_bus_message_is_method_error(m
, NULL
)) {
3172 log_debug_errno(sd_bus_message_get_errno(m
),
3173 "Unable to add match %s, failing connection: %s",
3174 match_slot
->match_callback
.match_string
,
3175 sd_bus_message_get_error(m
)->message
);
3179 log_debug("Match %s successfully installed.", match_slot
->match_callback
.match_string
);
3181 if (match_slot
->match_callback
.install_callback
) {
3184 bus
= sd_bus_message_get_bus(m
);
3186 /* This function has been called as slot handler, and we want to call another slot handler. Let's
3187 * update the slot callback metadata temporarily with our own data, and then revert back to the old
3190 assert(bus
->current_slot
== match_slot
->match_callback
.install_slot
);
3191 assert(bus
->current_handler
== add_match_callback
);
3192 assert(bus
->current_userdata
== userdata
);
3194 bus
->current_slot
= match_slot
;
3195 bus
->current_handler
= match_slot
->match_callback
.install_callback
;
3196 bus
->current_userdata
= match_slot
->userdata
;
3198 r
= match_slot
->match_callback
.install_callback(m
, match_slot
->userdata
, ret_error
);
3200 bus
->current_slot
= match_slot
->match_callback
.install_slot
;
3201 bus
->current_handler
= add_match_callback
;
3202 bus
->current_userdata
= userdata
;
3204 match_slot
->match_callback
.install_slot
= sd_bus_slot_unref(match_slot
->match_callback
.install_slot
);
3206 if (failed
) /* Generic failure handling: destroy the connection */
3207 bus_enter_closing(sd_bus_message_get_bus(m
));
3212 if (failed
&& match_slot
->floating
) {
3213 bus_slot_disconnect(match_slot
);
3214 sd_bus_slot_unref(match_slot
);
3217 sd_bus_slot_unref(match_slot
);
3222 static int bus_add_match_full(
3227 sd_bus_message_handler_t callback
,
3228 sd_bus_message_handler_t install_callback
,
3231 struct bus_match_component
*components
= NULL
;
3232 unsigned n_components
= 0;
3233 sd_bus_slot
*s
= NULL
;
3236 assert_return(bus
, -EINVAL
);
3237 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3238 assert_return(match
, -EINVAL
);
3239 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3241 r
= bus_match_parse(match
, &components
, &n_components
);
3245 s
= bus_slot_allocate(bus
, !slot
, BUS_MATCH_CALLBACK
, sizeof(struct match_callback
), userdata
);
3251 s
->match_callback
.callback
= callback
;
3252 s
->match_callback
.install_callback
= install_callback
;
3254 if (bus
->bus_client
) {
3255 enum bus_match_scope scope
;
3257 scope
= bus_match_get_scope(components
, n_components
);
3259 /* Do not install server-side matches for matches against the local service, interface or bus path. */
3260 if (scope
!= BUS_MATCH_LOCAL
) {
3262 /* We store the original match string, so that we can use it to remove the match again. */
3264 s
->match_callback
.match_string
= strdup(match
);
3265 if (!s
->match_callback
.match_string
) {
3271 r
= bus_add_match_internal_async(bus
,
3272 &s
->match_callback
.install_slot
,
3273 s
->match_callback
.match_string
,
3277 r
= bus_add_match_internal(bus
, s
->match_callback
.match_string
);
3281 s
->match_added
= true;
3285 bus
->match_callbacks_modified
= true;
3286 r
= bus_match_add(&bus
->match_callbacks
, components
, n_components
, &s
->match_callback
);
3295 bus_match_parse_free(components
, n_components
);
3296 sd_bus_slot_unref(s
);
3301 _public_
int sd_bus_add_match(
3305 sd_bus_message_handler_t callback
,
3308 return bus_add_match_full(bus
, slot
, false, match
, callback
, NULL
, userdata
);
3311 _public_
int sd_bus_add_match_async(
3315 sd_bus_message_handler_t callback
,
3316 sd_bus_message_handler_t install_callback
,
3319 return bus_add_match_full(bus
, slot
, true, match
, callback
, install_callback
, userdata
);
3322 bool bus_pid_changed(sd_bus
*bus
) {
3325 /* We don't support people creating a bus connection and
3326 * keeping it around over a fork(). Let's complain. */
3328 return bus
->original_pid
!= getpid_cached();
3331 static int io_callback(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
3332 sd_bus
*bus
= userdata
;
3337 /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3339 r
= sd_bus_process(bus
, NULL
);
3341 log_debug_errno(r
, "Processing of bus failed, closing down: %m");
3342 bus_enter_closing(bus
);
3348 static int time_callback(sd_event_source
*s
, uint64_t usec
, void *userdata
) {
3349 sd_bus
*bus
= userdata
;
3354 r
= sd_bus_process(bus
, NULL
);
3356 log_debug_errno(r
, "Processing of bus failed, closing down: %m");
3357 bus_enter_closing(bus
);
3363 static int prepare_callback(sd_event_source
*s
, void *userdata
) {
3364 sd_bus
*bus
= userdata
;
3371 e
= sd_bus_get_events(bus
);
3377 if (bus
->output_fd
!= bus
->input_fd
) {
3379 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
& POLLIN
);
3383 r
= sd_event_source_set_io_events(bus
->output_io_event_source
, e
& POLLOUT
);
3385 r
= sd_event_source_set_io_events(bus
->input_io_event_source
, e
);
3389 r
= sd_bus_get_timeout(bus
, &until
);
3395 j
= sd_event_source_set_time(bus
->time_event_source
, until
);
3402 r
= sd_event_source_set_enabled(bus
->time_event_source
, r
> 0);
3409 log_debug_errno(r
, "Preparing of bus events failed, closing down: %m");
3410 bus_enter_closing(bus
);
3415 static int quit_callback(sd_event_source
*event
, void *userdata
) {
3416 sd_bus
*bus
= userdata
;
3426 int bus_attach_io_events(sd_bus
*bus
) {
3431 if (bus
->input_fd
< 0)
3437 if (!bus
->input_io_event_source
) {
3438 r
= sd_event_add_io(bus
->event
, &bus
->input_io_event_source
, bus
->input_fd
, 0, io_callback
, bus
);
3442 r
= sd_event_source_set_prepare(bus
->input_io_event_source
, prepare_callback
);
3446 r
= sd_event_source_set_priority(bus
->input_io_event_source
, bus
->event_priority
);
3450 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-input");
3452 r
= sd_event_source_set_io_fd(bus
->input_io_event_source
, bus
->input_fd
);
3457 if (bus
->output_fd
!= bus
->input_fd
) {
3458 assert(bus
->output_fd
>= 0);
3460 if (!bus
->output_io_event_source
) {
3461 r
= sd_event_add_io(bus
->event
, &bus
->output_io_event_source
, bus
->output_fd
, 0, io_callback
, bus
);
3465 r
= sd_event_source_set_priority(bus
->output_io_event_source
, bus
->event_priority
);
3469 r
= sd_event_source_set_description(bus
->input_io_event_source
, "bus-output");
3471 r
= sd_event_source_set_io_fd(bus
->output_io_event_source
, bus
->output_fd
);
3480 static void bus_detach_io_events(sd_bus
*bus
) {
3483 if (bus
->input_io_event_source
) {
3484 sd_event_source_set_enabled(bus
->input_io_event_source
, SD_EVENT_OFF
);
3485 bus
->input_io_event_source
= sd_event_source_unref(bus
->input_io_event_source
);
3488 if (bus
->output_io_event_source
) {
3489 sd_event_source_set_enabled(bus
->output_io_event_source
, SD_EVENT_OFF
);
3490 bus
->output_io_event_source
= sd_event_source_unref(bus
->output_io_event_source
);
3494 int bus_attach_inotify_event(sd_bus
*bus
) {
3499 if (bus
->inotify_fd
< 0)
3505 if (!bus
->inotify_event_source
) {
3506 r
= sd_event_add_io(bus
->event
, &bus
->inotify_event_source
, bus
->inotify_fd
, EPOLLIN
, io_callback
, bus
);
3510 r
= sd_event_source_set_priority(bus
->inotify_event_source
, bus
->event_priority
);
3514 r
= sd_event_source_set_description(bus
->inotify_event_source
, "bus-inotify");
3516 r
= sd_event_source_set_io_fd(bus
->inotify_event_source
, bus
->inotify_fd
);
3523 static void bus_detach_inotify_event(sd_bus
*bus
) {
3526 if (bus
->inotify_event_source
) {
3527 sd_event_source_set_enabled(bus
->inotify_event_source
, SD_EVENT_OFF
);
3528 bus
->inotify_event_source
= sd_event_source_unref(bus
->inotify_event_source
);
3532 _public_
int sd_bus_attach_event(sd_bus
*bus
, sd_event
*event
, int priority
) {
3535 assert_return(bus
, -EINVAL
);
3536 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3537 assert_return(!bus
->event
, -EBUSY
);
3539 assert(!bus
->input_io_event_source
);
3540 assert(!bus
->output_io_event_source
);
3541 assert(!bus
->time_event_source
);
3544 bus
->event
= sd_event_ref(event
);
3546 r
= sd_event_default(&bus
->event
);
3551 bus
->event_priority
= priority
;
3553 r
= sd_event_add_time(bus
->event
, &bus
->time_event_source
, CLOCK_MONOTONIC
, 0, 0, time_callback
, bus
);
3557 r
= sd_event_source_set_priority(bus
->time_event_source
, priority
);
3561 r
= sd_event_source_set_description(bus
->time_event_source
, "bus-time");
3565 r
= sd_event_add_exit(bus
->event
, &bus
->quit_event_source
, quit_callback
, bus
);
3569 r
= sd_event_source_set_description(bus
->quit_event_source
, "bus-exit");
3573 r
= bus_attach_io_events(bus
);
3577 r
= bus_attach_inotify_event(bus
);
3584 sd_bus_detach_event(bus
);
3588 _public_
int sd_bus_detach_event(sd_bus
*bus
) {
3589 assert_return(bus
, -EINVAL
);
3590 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3595 bus_detach_io_events(bus
);
3596 bus_detach_inotify_event(bus
);
3598 if (bus
->time_event_source
) {
3599 sd_event_source_set_enabled(bus
->time_event_source
, SD_EVENT_OFF
);
3600 bus
->time_event_source
= sd_event_source_unref(bus
->time_event_source
);
3603 if (bus
->quit_event_source
) {
3604 sd_event_source_set_enabled(bus
->quit_event_source
, SD_EVENT_OFF
);
3605 bus
->quit_event_source
= sd_event_source_unref(bus
->quit_event_source
);
3608 bus
->event
= sd_event_unref(bus
->event
);
3612 _public_ sd_event
* sd_bus_get_event(sd_bus
*bus
) {
3613 assert_return(bus
, NULL
);
3618 _public_ sd_bus_message
* sd_bus_get_current_message(sd_bus
*bus
) {
3619 assert_return(bus
, NULL
);
3621 return bus
->current_message
;
3624 _public_ sd_bus_slot
* sd_bus_get_current_slot(sd_bus
*bus
) {
3625 assert_return(bus
, NULL
);
3627 return bus
->current_slot
;
3630 _public_ sd_bus_message_handler_t
sd_bus_get_current_handler(sd_bus
*bus
) {
3631 assert_return(bus
, NULL
);
3633 return bus
->current_handler
;
3636 _public_
void* sd_bus_get_current_userdata(sd_bus
*bus
) {
3637 assert_return(bus
, NULL
);
3639 return bus
->current_userdata
;
3642 static int bus_default(int (*bus_open
)(sd_bus
**), sd_bus
**default_bus
, sd_bus
**ret
) {
3647 assert(default_bus
);
3650 return !!*default_bus
;
3653 *ret
= sd_bus_ref(*default_bus
);
3661 b
->default_bus_ptr
= default_bus
;
3669 _public_
int sd_bus_default_system(sd_bus
**ret
) {
3670 return bus_default(sd_bus_open_system
, &default_system_bus
, ret
);
3674 _public_
int sd_bus_default_user(sd_bus
**ret
) {
3675 return bus_default(sd_bus_open_user
, &default_user_bus
, ret
);
3678 _public_
int sd_bus_default(sd_bus
**ret
) {
3679 int (*bus_open
)(sd_bus
**) = NULL
;
3682 busp
= bus_choose_default(&bus_open
);
3683 return bus_default(bus_open
, busp
, ret
);
3686 _public_
int sd_bus_get_tid(sd_bus
*b
, pid_t
*tid
) {
3687 assert_return(b
, -EINVAL
);
3688 assert_return(tid
, -EINVAL
);
3689 assert_return(!bus_pid_changed(b
), -ECHILD
);
3697 return sd_event_get_tid(b
->event
, tid
);
3702 _public_
int sd_bus_path_encode(const char *prefix
, const char *external_id
, char **ret_path
) {
3703 _cleanup_free_
char *e
= NULL
;
3706 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3707 assert_return(external_id
, -EINVAL
);
3708 assert_return(ret_path
, -EINVAL
);
3710 e
= bus_label_escape(external_id
);
3714 ret
= strjoin(prefix
, "/", e
);
3722 _public_
int sd_bus_path_decode(const char *path
, const char *prefix
, char **external_id
) {
3726 assert_return(object_path_is_valid(path
), -EINVAL
);
3727 assert_return(object_path_is_valid(prefix
), -EINVAL
);
3728 assert_return(external_id
, -EINVAL
);
3730 e
= object_path_startswith(path
, prefix
);
3732 *external_id
= NULL
;
3736 ret
= bus_label_unescape(e
);
3744 _public_
int sd_bus_path_encode_many(char **out
, const char *path_template
, ...) {
3745 _cleanup_strv_free_
char **labels
= NULL
;
3746 char *path
, *path_pos
, **label_pos
;
3747 const char *sep
, *template_pos
;
3752 assert_return(out
, -EINVAL
);
3753 assert_return(path_template
, -EINVAL
);
3755 path_length
= strlen(path_template
);
3757 va_start(list
, path_template
);
3758 for (sep
= strchr(path_template
, '%'); sep
; sep
= strchr(sep
+ 1, '%')) {
3762 arg
= va_arg(list
, const char *);
3768 label
= bus_label_escape(arg
);
3774 r
= strv_consume(&labels
, label
);
3780 /* add label length, but account for the format character */
3781 path_length
+= strlen(label
) - 1;
3785 path
= malloc(path_length
+ 1);
3792 for (template_pos
= path_template
; *template_pos
; ) {
3793 sep
= strchrnul(template_pos
, '%');
3794 path_pos
= mempcpy(path_pos
, template_pos
, sep
- template_pos
);
3798 path_pos
= stpcpy(path_pos
, *label_pos
++);
3799 template_pos
= sep
+ 1;
3807 _public_
int sd_bus_path_decode_many(const char *path
, const char *path_template
, ...) {
3808 _cleanup_strv_free_
char **labels
= NULL
;
3809 const char *template_pos
, *path_pos
;
3815 * This decodes an object-path based on a template argument. The
3816 * template consists of a verbatim path, optionally including special
3819 * - Each occurrence of '%' in the template matches an arbitrary
3820 * substring of a label in the given path. At most one such
3821 * directive is allowed per label. For each such directive, the
3822 * caller must provide an output parameter (char **) via va_arg. If
3823 * NULL is passed, the given label is verified, but not returned.
3824 * For each matched label, the *decoded* label is stored in the
3825 * passed output argument, and the caller is responsible to free
3826 * it. Note that the output arguments are only modified if the
3827 * actualy path matched the template. Otherwise, they're left
3830 * This function returns <0 on error, 0 if the path does not match the
3831 * template, 1 if it matched.
3834 assert_return(path
, -EINVAL
);
3835 assert_return(path_template
, -EINVAL
);
3839 for (template_pos
= path_template
; *template_pos
; ) {
3844 /* verify everything until the next '%' matches verbatim */
3845 sep
= strchrnul(template_pos
, '%');
3846 length
= sep
- template_pos
;
3847 if (strncmp(path_pos
, template_pos
, length
))
3851 template_pos
+= length
;
3856 /* We found the next '%' character. Everything up until here
3857 * matched. We now skip ahead to the end of this label and make
3858 * sure it matches the tail of the label in the path. Then we
3859 * decode the string in-between and save it for later use. */
3861 ++template_pos
; /* skip over '%' */
3863 sep
= strchrnul(template_pos
, '/');
3864 length
= sep
- template_pos
; /* length of suffix to match verbatim */
3866 /* verify the suffixes match */
3867 sep
= strchrnul(path_pos
, '/');
3868 if (sep
- path_pos
< (ssize_t
)length
||
3869 strncmp(sep
- length
, template_pos
, length
))
3872 template_pos
+= length
; /* skip over matched label */
3873 length
= sep
- path_pos
- length
; /* length of sub-label to decode */
3875 /* store unescaped label for later use */
3876 label
= bus_label_unescape_n(path_pos
, length
);
3880 r
= strv_consume(&labels
, label
);
3884 path_pos
= sep
; /* skip decoded label and suffix */
3887 /* end of template must match end of path */
3891 /* copy the labels over to the caller */
3892 va_start(list
, path_template
);
3893 for (label_pos
= labels
; label_pos
&& *label_pos
; ++label_pos
) {
3896 arg
= va_arg(list
, char **);
3904 labels
= mfree(labels
);
3908 _public_
int sd_bus_try_close(sd_bus
*bus
) {
3909 assert_return(bus
, -EINVAL
);
3910 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3911 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3916 _public_
int sd_bus_get_description(sd_bus
*bus
, const char **description
) {
3917 assert_return(bus
, -EINVAL
);
3918 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3919 assert_return(description
, -EINVAL
);
3920 assert_return(bus
->description
, -ENXIO
);
3921 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3923 if (bus
->description
)
3924 *description
= bus
->description
;
3925 else if (bus
->is_system
)
3926 *description
= "system";
3927 else if (bus
->is_user
)
3928 *description
= "user";
3930 *description
= NULL
;
3935 int bus_get_root_path(sd_bus
*bus
) {
3938 if (bus
->cgroup_root
)
3941 r
= cg_get_root_path(&bus
->cgroup_root
);
3943 bus
->cgroup_root
= strdup("/");
3944 if (!bus
->cgroup_root
)
3953 _public_
int sd_bus_get_scope(sd_bus
*bus
, const char **scope
) {
3954 assert_return(bus
, -EINVAL
);
3955 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3956 assert_return(scope
, -EINVAL
);
3957 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3964 if (bus
->is_system
) {
3972 _public_
int sd_bus_get_address(sd_bus
*bus
, const char **address
) {
3974 assert_return(bus
, -EINVAL
);
3975 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3976 assert_return(address
, -EINVAL
);
3977 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3980 *address
= bus
->address
;
3987 _public_
int sd_bus_get_creds_mask(sd_bus
*bus
, uint64_t *mask
) {
3988 assert_return(bus
, -EINVAL
);
3989 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
3990 assert_return(mask
, -EINVAL
);
3991 assert_return(!bus_pid_changed(bus
), -ECHILD
);
3993 *mask
= bus
->creds_mask
;
3997 _public_
int sd_bus_is_bus_client(sd_bus
*bus
) {
3998 assert_return(bus
, -EINVAL
);
3999 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4000 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4002 return bus
->bus_client
;
4005 _public_
int sd_bus_is_server(sd_bus
*bus
) {
4006 assert_return(bus
, -EINVAL
);
4007 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4008 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4010 return bus
->is_server
;
4013 _public_
int sd_bus_is_anonymous(sd_bus
*bus
) {
4014 assert_return(bus
, -EINVAL
);
4015 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4016 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4018 return bus
->anonymous_auth
;
4021 _public_
int sd_bus_is_trusted(sd_bus
*bus
) {
4022 assert_return(bus
, -EINVAL
);
4023 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4024 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4026 return bus
->trusted
;
4029 _public_
int sd_bus_is_monitor(sd_bus
*bus
) {
4030 assert_return(bus
, -EINVAL
);
4031 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4032 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4034 return bus
->is_monitor
;
4037 static void flush_close(sd_bus
*bus
) {
4041 /* Flushes and closes the specified bus. We take a ref before,
4042 * to ensure the flushing does not cause the bus to be
4045 sd_bus_flush_close_unref(sd_bus_ref(bus
));
4048 _public_
void sd_bus_default_flush_close(void) {
4049 flush_close(default_starter_bus
);
4050 flush_close(default_user_bus
);
4051 flush_close(default_system_bus
);
4054 _public_
int sd_bus_set_exit_on_disconnect(sd_bus
*bus
, int b
) {
4055 assert_return(bus
, -EINVAL
);
4056 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4058 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
4059 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
4060 * from the client side. */
4061 bus
->exit_on_disconnect
= b
;
4063 /* If the exit condition was triggered already, exit immediately. */
4064 return bus_exit_now(bus
);
4067 _public_
int sd_bus_get_exit_on_disconnect(sd_bus
*bus
) {
4068 assert_return(bus
, -EINVAL
);
4069 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4071 return bus
->exit_on_disconnect
;
4074 _public_
int sd_bus_set_sender(sd_bus
*bus
, const char *sender
) {
4075 assert_return(bus
, -EINVAL
);
4076 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4077 assert_return(!bus
->bus_client
, -EPERM
);
4078 assert_return(!sender
|| service_name_is_valid(sender
), -EINVAL
);
4080 return free_and_strdup(&bus
->patch_sender
, sender
);
4083 _public_
int sd_bus_get_sender(sd_bus
*bus
, const char **ret
) {
4084 assert_return(bus
, -EINVAL
);
4085 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4086 assert_return(ret
, -EINVAL
);
4088 if (!bus
->patch_sender
)
4091 *ret
= bus
->patch_sender
;
4095 _public_
int sd_bus_get_n_queued_read(sd_bus
*bus
, uint64_t *ret
) {
4096 assert_return(bus
, -EINVAL
);
4097 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4098 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4099 assert_return(ret
, -EINVAL
);
4101 *ret
= bus
->rqueue_size
;
4105 _public_
int sd_bus_get_n_queued_write(sd_bus
*bus
, uint64_t *ret
) {
4106 assert_return(bus
, -EINVAL
);
4107 assert_return(bus
= bus_resolve(bus
), -ENOPKG
);
4108 assert_return(!bus_pid_changed(bus
), -ECHILD
);
4109 assert_return(ret
, -EINVAL
);
4111 *ret
= bus
->wqueue_size
;