1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2013 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
38 #include "cgroup-util.h"
41 #include "bus-internal.h"
42 #include "bus-message.h"
44 #include "bus-socket.h"
45 #include "bus-kernel.h"
46 #include "bus-control.h"
47 #include "bus-introspect.h"
48 #include "bus-signature.h"
49 #include "bus-objects.h"
51 #include "bus-container.h"
52 #include "bus-protocol.h"
54 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
55 static int attach_io_events(sd_bus *b);
56 static void detach_io_events(sd_bus *b);
58 static void bus_close_fds(sd_bus *b) {
64 close_nointr_nofail(b->input_fd);
66 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
67 close_nointr_nofail(b->output_fd);
69 b->input_fd = b->output_fd = -1;
72 static void bus_node_destroy(sd_bus *b, struct node *n) {
73 struct node_callback *c;
74 struct node_vtable *v;
75 struct node_enumerator *e;
83 bus_node_destroy(b, n->child);
85 while ((c = n->callbacks)) {
86 LIST_REMOVE(callbacks, n->callbacks, c);
90 while ((v = n->vtables)) {
91 LIST_REMOVE(vtables, n->vtables, v);
96 while ((e = n->enumerators)) {
97 LIST_REMOVE(enumerators, n->enumerators, e);
102 LIST_REMOVE(siblings, n->parent->child, n);
104 assert_se(hashmap_remove(b->nodes, n->path) == n);
109 static void bus_reset_queues(sd_bus *b) {
112 while (b->rqueue_size > 0)
113 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
117 b->rqueue_allocated = 0;
119 while (b->wqueue_size > 0)
120 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
124 b->wqueue_allocated = 0;
127 static void bus_free(sd_bus *b) {
128 struct filter_callback *f;
133 sd_bus_detach_event(b);
135 if (b->default_bus_ptr)
136 *b->default_bus_ptr = NULL;
141 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
144 free(b->unique_name);
145 free(b->auth_buffer);
150 free(b->cgroup_root);
151 free(b->connection_name);
154 strv_free(b->exec_argv);
156 close_many(b->fds, b->n_fds);
161 hashmap_free_free(b->reply_callbacks);
162 prioq_free(b->reply_callbacks_prioq);
164 while ((f = b->filter_callbacks)) {
165 LIST_REMOVE(callbacks, b->filter_callbacks, f);
169 bus_match_free(&b->match_callbacks);
171 hashmap_free_free(b->vtable_methods);
172 hashmap_free_free(b->vtable_properties);
174 while ((n = hashmap_first(b->nodes)))
175 bus_node_destroy(b, n);
177 hashmap_free(b->nodes);
179 bus_kernel_flush_memfd(b);
181 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
186 _public_ int sd_bus_new(sd_bus **ret) {
189 assert_return(ret, -EINVAL);
195 r->n_ref = REFCNT_INIT;
196 r->input_fd = r->output_fd = -1;
197 r->message_version = 1;
198 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
199 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
200 r->attach_flags |= KDBUS_ATTACH_NAMES;
201 r->original_pid = getpid();
203 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
205 /* We guarantee that wqueue always has space for at least one
207 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
216 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
219 assert_return(bus, -EINVAL);
220 assert_return(bus->state == BUS_UNSET, -EPERM);
221 assert_return(address, -EINVAL);
222 assert_return(!bus_pid_changed(bus), -ECHILD);
234 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
235 assert_return(bus, -EINVAL);
236 assert_return(bus->state == BUS_UNSET, -EPERM);
237 assert_return(input_fd >= 0, -EINVAL);
238 assert_return(output_fd >= 0, -EINVAL);
239 assert_return(!bus_pid_changed(bus), -ECHILD);
241 bus->input_fd = input_fd;
242 bus->output_fd = output_fd;
246 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
249 assert_return(bus, -EINVAL);
250 assert_return(bus->state == BUS_UNSET, -EPERM);
251 assert_return(path, -EINVAL);
252 assert_return(!strv_isempty(argv), -EINVAL);
253 assert_return(!bus_pid_changed(bus), -ECHILD);
265 free(bus->exec_path);
266 strv_free(bus->exec_argv);
274 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
275 assert_return(bus, -EINVAL);
276 assert_return(bus->state == BUS_UNSET, -EPERM);
277 assert_return(!bus_pid_changed(bus), -ECHILD);
279 bus->bus_client = !!b;
283 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
284 assert_return(bus, -EINVAL);
285 assert_return(bus->state == BUS_UNSET, -EPERM);
286 assert_return(!bus_pid_changed(bus), -ECHILD);
288 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
292 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
293 assert_return(bus, -EINVAL);
294 assert_return(bus->state == BUS_UNSET, -EPERM);
295 assert_return(!bus_pid_changed(bus), -ECHILD);
297 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
301 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
302 assert_return(bus, -EINVAL);
303 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
304 assert_return(bus->state == BUS_UNSET, -EPERM);
305 assert_return(!bus_pid_changed(bus), -ECHILD);
307 /* The well knowns we need unconditionally, so that matches can work */
308 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
310 return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
313 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
314 assert_return(bus, -EINVAL);
315 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
316 assert_return(bus->state == BUS_UNSET, -EPERM);
317 assert_return(!bus_pid_changed(bus), -ECHILD);
319 bus->is_server = !!b;
320 bus->server_id = server_id;
324 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
325 assert_return(bus, -EINVAL);
326 assert_return(bus->state == BUS_UNSET, -EPERM);
327 assert_return(!bus_pid_changed(bus), -ECHILD);
329 bus->anonymous_auth = !!b;
333 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
334 assert_return(bus, -EINVAL);
335 assert_return(bus->state == BUS_UNSET, -EPERM);
336 assert_return(!bus_pid_changed(bus), -ECHILD);
342 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
345 assert_return(bus, -EINVAL);
346 assert_return(name, -EINVAL);
347 assert_return(bus->state == BUS_UNSET, -EPERM);
348 assert_return(!bus_pid_changed(bus), -ECHILD);
354 free(bus->connection_name);
355 bus->connection_name = n;
360 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
365 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
368 r = sd_bus_message_get_errno(reply);
374 r = sd_bus_message_read(reply, "s", &s);
378 if (!service_name_is_valid(s) || s[0] != ':')
381 bus->unique_name = strdup(s);
382 if (!bus->unique_name)
385 if (bus->state == BUS_HELLO)
386 bus->state = BUS_RUNNING;
391 static int bus_send_hello(sd_bus *bus) {
392 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
397 if (!bus->bus_client || bus->is_kernel)
400 r = sd_bus_message_new_method_call(
402 "org.freedesktop.DBus",
403 "/org/freedesktop/DBus",
404 "org.freedesktop.DBus",
410 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie);
413 int bus_start_running(sd_bus *bus) {
416 if (bus->bus_client && !bus->is_kernel) {
417 bus->state = BUS_HELLO;
421 bus->state = BUS_RUNNING;
425 static int parse_address_key(const char **p, const char *key, char **value) {
426 size_t l, n = 0, allocated = 0;
436 if (strncmp(*p, key, l) != 0)
449 while (*a != ';' && *a != ',' && *a != 0) {
467 c = (char) ((x << 4) | y);
474 if (!GREEDY_REALLOC(r, allocated, n + 2))
498 static void skip_address_key(const char **p) {
502 *p += strcspn(*p, ",");
508 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
509 _cleanup_free_ char *path = NULL, *abstract = NULL;
518 while (**p != 0 && **p != ';') {
519 r = parse_address_key(p, "guid", guid);
525 r = parse_address_key(p, "path", &path);
531 r = parse_address_key(p, "abstract", &abstract);
540 if (!path && !abstract)
543 if (path && abstract)
548 if (l > sizeof(b->sockaddr.un.sun_path))
551 b->sockaddr.un.sun_family = AF_UNIX;
552 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
553 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
554 } else if (abstract) {
555 l = strlen(abstract);
556 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
559 b->sockaddr.un.sun_family = AF_UNIX;
560 b->sockaddr.un.sun_path[0] = 0;
561 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
562 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
568 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
569 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
571 struct addrinfo *result, hints = {
572 .ai_socktype = SOCK_STREAM,
573 .ai_flags = AI_ADDRCONFIG,
581 while (**p != 0 && **p != ';') {
582 r = parse_address_key(p, "guid", guid);
588 r = parse_address_key(p, "host", &host);
594 r = parse_address_key(p, "port", &port);
600 r = parse_address_key(p, "family", &family);
613 if (streq(family, "ipv4"))
614 hints.ai_family = AF_INET;
615 else if (streq(family, "ipv6"))
616 hints.ai_family = AF_INET6;
621 r = getaddrinfo(host, port, &hints, &result);
625 return -EADDRNOTAVAIL;
627 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
628 b->sockaddr_size = result->ai_addrlen;
630 freeaddrinfo(result);
635 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
637 unsigned n_argv = 0, j;
639 size_t allocated = 0;
647 while (**p != 0 && **p != ';') {
648 r = parse_address_key(p, "guid", guid);
654 r = parse_address_key(p, "path", &path);
660 if (startswith(*p, "argv")) {
664 ul = strtoul(*p + 4, (char**) p, 10);
665 if (errno > 0 || **p != '=' || ul > 256) {
673 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
681 r = parse_address_key(p, NULL, argv + ul);
696 /* Make sure there are no holes in the array, with the
697 * exception of argv[0] */
698 for (j = 1; j < n_argv; j++)
704 if (argv && argv[0] == NULL) {
705 argv[0] = strdup(path);
717 for (j = 0; j < n_argv; j++)
725 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
726 _cleanup_free_ char *path = NULL;
734 while (**p != 0 && **p != ';') {
735 r = parse_address_key(p, "guid", guid);
741 r = parse_address_key(p, "path", &path);
760 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
761 _cleanup_free_ char *machine = NULL;
769 while (**p != 0 && **p != ';') {
770 r = parse_address_key(p, "guid", guid);
776 r = parse_address_key(p, "machine", &machine);
788 if (!filename_is_safe(machine))
792 b->machine = machine;
795 b->sockaddr.un.sun_family = AF_UNIX;
796 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
797 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
802 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
803 _cleanup_free_ char *machine = NULL;
811 while (**p != 0 && **p != ';') {
812 r = parse_address_key(p, "guid", guid);
818 r = parse_address_key(p, "machine", &machine);
830 if (!filename_is_safe(machine))
834 b->machine = machine;
838 b->kernel = strdup("/dev/kdbus/0-system/bus");
845 static void bus_reset_parsed_address(sd_bus *b) {
849 b->sockaddr_size = 0;
850 strv_free(b->exec_argv);
854 b->server_id = SD_ID128_NULL;
861 static int bus_parse_next_address(sd_bus *b) {
862 _cleanup_free_ char *guid = NULL;
870 if (b->address[b->address_index] == 0)
873 bus_reset_parsed_address(b);
875 a = b->address + b->address_index;
884 if (startswith(a, "unix:")) {
887 r = parse_unix_address(b, &a, &guid);
892 } else if (startswith(a, "tcp:")) {
895 r = parse_tcp_address(b, &a, &guid);
901 } else if (startswith(a, "unixexec:")) {
904 r = parse_exec_address(b, &a, &guid);
910 } else if (startswith(a, "kernel:")) {
913 r = parse_kernel_address(b, &a, &guid);
918 } else if (startswith(a, "x-container-unix:")) {
921 r = parse_container_unix_address(b, &a, &guid);
926 } else if (startswith(a, "x-container-kernel:")) {
929 r = parse_container_kernel_address(b, &a, &guid);
942 r = sd_id128_from_string(guid, &b->server_id);
947 b->address_index = a - b->address;
951 static int bus_start_address(sd_bus *b) {
957 bool skipped = false;
962 r = bus_socket_exec(b);
963 else if (b->machine && b->kernel)
964 r = bus_container_connect_kernel(b);
965 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
966 r = bus_container_connect_socket(b);
968 r = bus_kernel_connect(b);
969 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
970 r = bus_socket_connect(b);
976 r = attach_io_events(b);
981 b->last_connect_error = -r;
984 r = bus_parse_next_address(b);
988 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
992 int bus_next_address(sd_bus *b) {
995 bus_reset_parsed_address(b);
996 return bus_start_address(b);
999 static int bus_start_fd(sd_bus *b) {
1004 assert(b->input_fd >= 0);
1005 assert(b->output_fd >= 0);
1007 r = fd_nonblock(b->input_fd, true);
1011 r = fd_cloexec(b->input_fd, true);
1015 if (b->input_fd != b->output_fd) {
1016 r = fd_nonblock(b->output_fd, true);
1020 r = fd_cloexec(b->output_fd, true);
1025 if (fstat(b->input_fd, &st) < 0)
1028 if (S_ISCHR(b->input_fd))
1029 return bus_kernel_take_fd(b);
1031 return bus_socket_take_fd(b);
1034 _public_ int sd_bus_start(sd_bus *bus) {
1037 assert_return(bus, -EINVAL);
1038 assert_return(bus->state == BUS_UNSET, -EPERM);
1039 assert_return(!bus_pid_changed(bus), -ECHILD);
1041 bus->state = BUS_OPENING;
1043 if (bus->is_server && bus->bus_client)
1046 if (bus->input_fd >= 0)
1047 r = bus_start_fd(bus);
1048 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1049 r = bus_start_address(bus);
1056 return bus_send_hello(bus);
1059 _public_ int sd_bus_open(sd_bus **ret) {
1064 assert_return(ret, -EINVAL);
1066 /* Let's connect to the starter bus if it is set, and
1067 * otherwise to the bus that is appropropriate for the scope
1068 * we are running in */
1070 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1072 if (streq(e, "system"))
1073 return sd_bus_open_system(ret);
1074 else if (streq(e, "session") || streq(e, "user"))
1075 return sd_bus_open_user(ret);
1078 e = secure_getenv("DBUS_STARTER_ADDRESS");
1080 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1081 return sd_bus_open_user(ret);
1083 return sd_bus_open_system(ret);
1090 r = sd_bus_set_address(b, e);
1094 b->bus_client = true;
1096 /* We don't know whether the bus is trusted or not, so better
1097 * be safe, and authenticate everything */
1099 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1101 r = sd_bus_start(b);
1113 _public_ int sd_bus_open_system(sd_bus **ret) {
1118 assert_return(ret, -EINVAL);
1124 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1126 r = sd_bus_set_address(b, e);
1128 r = sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1132 b->bus_client = true;
1133 b->is_system = true;
1135 /* Let's do per-method access control on the system bus. We
1136 * need the caller's UID and capability set for that. */
1138 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1140 r = sd_bus_start(b);
1152 _public_ int sd_bus_open_user(sd_bus **ret) {
1157 assert_return(ret, -EINVAL);
1163 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1165 r = sd_bus_set_address(b, e);
1169 e = secure_getenv("XDG_RUNTIME_DIR");
1171 _cleanup_free_ char *ee = NULL;
1173 ee = bus_address_escape(e);
1180 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee);
1182 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1186 asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
1188 return -ECONNREFUSED;
1198 b->bus_client = true;
1201 /* We don't do any per-method access control on the user
1205 r = sd_bus_start(b);
1217 _public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) {
1218 _cleanup_free_ char *e = NULL;
1223 assert_return(host, -EINVAL);
1224 assert_return(ret, -EINVAL);
1226 e = bus_address_escape(host);
1230 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1234 r = sd_bus_new(&bus);
1241 bus->bus_client = true;
1243 r = sd_bus_start(bus);
1253 _public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) {
1254 _cleanup_free_ char *e = NULL;
1259 assert_return(machine, -EINVAL);
1260 assert_return(ret, -EINVAL);
1261 assert_return(filename_is_safe(machine), -EINVAL);
1263 e = bus_address_escape(machine);
1268 p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1270 p = strjoin("x-container-unix:machine=", e, NULL);
1275 r = sd_bus_new(&bus);
1282 bus->bus_client = true;
1284 r = sd_bus_start(bus);
1294 _public_ void sd_bus_close(sd_bus *bus) {
1298 if (bus->state == BUS_CLOSED)
1300 if (bus_pid_changed(bus))
1303 bus->state = BUS_CLOSED;
1305 sd_bus_detach_event(bus);
1307 /* Drop all queued messages so that they drop references to
1308 * the bus object and the bus may be freed */
1309 bus_reset_queues(bus);
1311 if (!bus->is_kernel)
1314 /* We'll leave the fd open in case this is a kernel bus, since
1315 * there might still be memblocks around that reference this
1316 * bus, and they might need to invoke the KDBUS_CMD_FREE
1317 * ioctl on the fd when they are freed. */
1320 static void bus_enter_closing(sd_bus *bus) {
1323 if (bus->state != BUS_OPENING &&
1324 bus->state != BUS_AUTHENTICATING &&
1325 bus->state != BUS_HELLO &&
1326 bus->state != BUS_RUNNING)
1329 bus->state = BUS_CLOSING;
1332 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1333 assert_return(bus, NULL);
1335 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1340 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1346 if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
1349 for (i = 0; i < bus->rqueue_size; i++)
1350 if (bus->rqueue[i]->n_ref > 1) {
1356 for (i = 0; i < bus->wqueue_size; i++)
1357 if (bus->wqueue[i]->n_ref > 1) {
1363 /* We are the only holders on the messages, and the
1364 * messages are the only holders on us, so let's drop
1365 * the messages and thus implicitly also kill our own
1366 * last references */
1369 bus_reset_queues(bus);
1372 i = REFCNT_DEC(bus->n_ref);
1380 _public_ int sd_bus_is_open(sd_bus *bus) {
1382 assert_return(bus, -EINVAL);
1383 assert_return(!bus_pid_changed(bus), -ECHILD);
1385 return BUS_IS_OPEN(bus->state);
1388 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1391 assert_return(bus, -EINVAL);
1392 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1393 assert_return(!bus_pid_changed(bus), -ECHILD);
1395 if (type == SD_BUS_TYPE_UNIX_FD) {
1396 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1399 r = bus_ensure_running(bus);
1403 return bus->can_fds;
1406 return bus_type_is_valid(type);
1409 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1412 assert_return(bus, -EINVAL);
1413 assert_return(server_id, -EINVAL);
1414 assert_return(!bus_pid_changed(bus), -ECHILD);
1416 r = bus_ensure_running(bus);
1420 *server_id = bus->server_id;
1424 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1429 /* If we copy the same message to multiple
1430 * destinations, avoid using the same cookie
1432 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1437 timeout = BUS_DEFAULT_TIMEOUT;
1439 return bus_message_seal(m, ++b->cookie, timeout);
1442 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1445 /* Do packet version and endianess already match? */
1446 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1447 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1450 /* No? Then remarshal! */
1451 return bus_message_remarshal(b, m);
1454 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1458 /* The bus specification says the serial number cannot be 0,
1459 * hence let's fill something in for synthetic messages. Since
1460 * synthetic messages might have a fake sender and we don't
1461 * want to interfere with the real sender's serial numbers we
1462 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1463 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1464 * even though kdbus can do 64bit. */
1466 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1469 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1476 r = bus_kernel_write_message(bus, m, hint_sync_call);
1478 r = bus_socket_write_message(bus, m, idx);
1483 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1484 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
1485 bus_message_type_to_string(m->header->type),
1486 strna(sd_bus_message_get_sender(m)),
1487 strna(sd_bus_message_get_destination(m)),
1488 strna(sd_bus_message_get_path(m)),
1489 strna(sd_bus_message_get_interface(m)),
1490 strna(sd_bus_message_get_member(m)),
1491 (unsigned long) BUS_MESSAGE_COOKIE(m),
1492 (unsigned long) m->reply_cookie,
1493 strna(m->error.message));
1498 static int dispatch_wqueue(sd_bus *bus) {
1502 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1504 while (bus->wqueue_size > 0) {
1506 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1510 /* Didn't do anything this time */
1512 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1513 /* Fully written. Let's drop the entry from
1516 * This isn't particularly optimized, but
1517 * well, this is supposed to be our worst-case
1518 * buffer only, and the socket buffer is
1519 * supposed to be our primary buffer, and if
1520 * it got full, then all bets are off
1523 bus->wqueue_size --;
1524 sd_bus_message_unref(bus->wqueue[0]);
1525 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1535 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1539 return bus_kernel_read_message(bus, hint_priority, priority);
1541 return bus_socket_read_message(bus);
1544 int bus_rqueue_make_room(sd_bus *bus) {
1547 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1550 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1556 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1561 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1563 /* Note that the priority logic is only available on kdbus,
1564 * where the rqueue is unused. We check the rqueue here
1565 * anyway, because it's simple... */
1568 if (bus->rqueue_size > 0) {
1569 /* Dispatch a queued message */
1571 *m = bus->rqueue[0];
1572 bus->rqueue_size --;
1573 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1577 /* Try to read a new message */
1578 r = bus_read_message(bus, hint_priority, priority);
1588 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1589 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1592 assert_return(bus, -EINVAL);
1593 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1594 assert_return(m, -EINVAL);
1595 assert_return(!bus_pid_changed(bus), -ECHILD);
1598 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1605 /* If the cookie number isn't kept, then we know that no reply
1607 if (!cookie && !m->sealed)
1608 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1610 r = bus_seal_message(bus, m, 0);
1614 /* Remarshall if we have to. This will possibly unref the
1615 * message and place a replacement in m */
1616 r = bus_remarshal_message(bus, &m);
1620 /* If this is a reply and no reply was requested, then let's
1621 * suppress this, if we can */
1622 if (m->dont_send && !cookie)
1625 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1628 r = bus_write_message(bus, m, hint_sync_call, &idx);
1630 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1631 bus_enter_closing(bus);
1636 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1637 /* Wasn't fully written. So let's remember how
1638 * much was written. Note that the first entry
1639 * of the wqueue array is always allocated so
1640 * that we always can remember how much was
1642 bus->wqueue[0] = sd_bus_message_ref(m);
1643 bus->wqueue_size = 1;
1647 /* Just append it to the queue. */
1649 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1652 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1655 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1659 *cookie = BUS_MESSAGE_COOKIE(m);
1664 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1665 return bus_send_internal(bus, m, cookie, false);
1668 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1671 assert_return(bus, -EINVAL);
1672 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1673 assert_return(m, -EINVAL);
1674 assert_return(!bus_pid_changed(bus), -ECHILD);
1676 if (!streq_ptr(m->destination, destination)) {
1681 r = sd_bus_message_set_destination(m, destination);
1686 return sd_bus_send(bus, m, cookie);
1689 static usec_t calc_elapse(uint64_t usec) {
1690 if (usec == (uint64_t) -1)
1693 return now(CLOCK_MONOTONIC) + usec;
1696 static int timeout_compare(const void *a, const void *b) {
1697 const struct reply_callback *x = a, *y = b;
1699 if (x->timeout != 0 && y->timeout == 0)
1702 if (x->timeout == 0 && y->timeout != 0)
1705 if (x->timeout < y->timeout)
1708 if (x->timeout > y->timeout)
1714 _public_ int sd_bus_call_async(
1717 sd_bus_message_handler_t callback,
1722 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1723 struct reply_callback *c;
1726 assert_return(bus, -EINVAL);
1727 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1728 assert_return(m, -EINVAL);
1729 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1730 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1731 assert_return(callback, -EINVAL);
1732 assert_return(!bus_pid_changed(bus), -ECHILD);
1734 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1738 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1742 r = bus_seal_message(bus, m, usec);
1746 r = bus_remarshal_message(bus, &m);
1750 c = new0(struct reply_callback, 1);
1754 c->callback = callback;
1755 c->userdata = userdata;
1756 c->cookie = BUS_MESSAGE_COOKIE(m);
1757 c->timeout = calc_elapse(m->timeout);
1759 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1765 if (c->timeout != 0) {
1766 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1769 sd_bus_call_async_cancel(bus, c->cookie);
1774 r = sd_bus_send(bus, m, cookie);
1776 sd_bus_call_async_cancel(bus, c->cookie);
1783 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1784 struct reply_callback *c;
1786 assert_return(bus, -EINVAL);
1787 assert_return(cookie != 0, -EINVAL);
1788 assert_return(!bus_pid_changed(bus), -ECHILD);
1790 c = hashmap_remove(bus->reply_callbacks, &cookie);
1794 if (c->timeout != 0)
1795 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1801 int bus_ensure_running(sd_bus *bus) {
1806 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1808 if (bus->state == BUS_RUNNING)
1812 r = sd_bus_process(bus, NULL);
1815 if (bus->state == BUS_RUNNING)
1820 r = sd_bus_wait(bus, (uint64_t) -1);
1826 _public_ int sd_bus_call(
1830 sd_bus_error *error,
1831 sd_bus_message **reply) {
1833 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1839 assert_return(bus, -EINVAL);
1840 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1841 assert_return(m, -EINVAL);
1842 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1843 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1844 assert_return(!bus_error_is_dirty(error), -EINVAL);
1845 assert_return(!bus_pid_changed(bus), -ECHILD);
1847 r = bus_ensure_running(bus);
1851 i = bus->rqueue_size;
1853 r = bus_seal_message(bus, m, usec);
1857 r = bus_remarshal_message(bus, &m);
1861 r = bus_send_internal(bus, m, &cookie, true);
1865 timeout = calc_elapse(m->timeout);
1870 while (i < bus->rqueue_size) {
1871 sd_bus_message *incoming = NULL;
1873 incoming = bus->rqueue[i];
1875 if (incoming->reply_cookie == cookie) {
1876 /* Found a match! */
1878 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1881 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1886 sd_bus_message_unref(incoming);
1889 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1890 r = sd_bus_error_copy(error, &incoming->error);
1894 sd_bus_message_unref(incoming);
1897 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1900 streq(bus->unique_name, incoming->sender)) {
1902 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1905 /* Our own message? Somebody is trying
1906 * to send its own client a message,
1907 * let's not dead-lock, let's fail
1910 sd_bus_message_unref(incoming);
1914 /* Try to read more, right-away */
1918 r = bus_read_message(bus, false, 0);
1920 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1921 bus_enter_closing(bus);
1933 n = now(CLOCK_MONOTONIC);
1939 left = (uint64_t) -1;
1941 r = bus_poll(bus, true, left);
1947 r = dispatch_wqueue(bus);
1949 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1950 bus_enter_closing(bus);
1959 _public_ int sd_bus_get_fd(sd_bus *bus) {
1961 assert_return(bus, -EINVAL);
1962 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1963 assert_return(!bus_pid_changed(bus), -ECHILD);
1965 return bus->input_fd;
1968 _public_ int sd_bus_get_events(sd_bus *bus) {
1971 assert_return(bus, -EINVAL);
1972 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1973 assert_return(!bus_pid_changed(bus), -ECHILD);
1975 if (bus->state == BUS_OPENING)
1977 else if (bus->state == BUS_AUTHENTICATING) {
1979 if (bus_socket_auth_needs_write(bus))
1984 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1985 if (bus->rqueue_size <= 0)
1987 if (bus->wqueue_size > 0)
1994 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1995 struct reply_callback *c;
1997 assert_return(bus, -EINVAL);
1998 assert_return(timeout_usec, -EINVAL);
1999 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
2000 assert_return(!bus_pid_changed(bus), -ECHILD);
2002 if (bus->state == BUS_CLOSING) {
2007 if (bus->state == BUS_AUTHENTICATING) {
2008 *timeout_usec = bus->auth_timeout;
2012 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2013 *timeout_usec = (uint64_t) -1;
2017 if (bus->rqueue_size > 0) {
2022 c = prioq_peek(bus->reply_callbacks_prioq);
2024 *timeout_usec = (uint64_t) -1;
2028 *timeout_usec = c->timeout;
2032 static int process_timeout(sd_bus *bus) {
2033 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2034 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2035 struct reply_callback *c;
2041 c = prioq_peek(bus->reply_callbacks_prioq);
2045 n = now(CLOCK_MONOTONIC);
2049 r = bus_message_new_synthetic_error(
2052 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2057 m->sender = "org.freedesktop.DBus";
2059 r = bus_seal_synthetic_message(bus, m);
2063 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2064 hashmap_remove(bus->reply_callbacks, &c->cookie);
2067 bus->iteration_counter ++;
2069 r = c->callback(bus, m, c->userdata, &error_buffer);
2070 r = bus_maybe_reply_error(m, r, &error_buffer);
2073 bus->current = NULL;
2078 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2082 if (bus->state != BUS_HELLO)
2085 /* Let's make sure the first message on the bus is the HELLO
2086 * reply. But note that we don't actually parse the message
2087 * here (we leave that to the usual handling), we just verify
2088 * we don't let any earlier msg through. */
2090 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2091 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2094 if (m->reply_cookie != bus->hello_cookie)
2100 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2101 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2102 struct reply_callback *c;
2108 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2109 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2112 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2116 if (c->timeout != 0)
2117 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2119 r = sd_bus_message_rewind(m, true);
2123 r = c->callback(bus, m, c->userdata, &error_buffer);
2124 r = bus_maybe_reply_error(m, r, &error_buffer);
2130 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2131 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2132 struct filter_callback *l;
2139 bus->filter_callbacks_modified = false;
2141 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2143 if (bus->filter_callbacks_modified)
2146 /* Don't run this more than once per iteration */
2147 if (l->last_iteration == bus->iteration_counter)
2150 l->last_iteration = bus->iteration_counter;
2152 r = sd_bus_message_rewind(m, true);
2156 r = l->callback(bus, m, l->userdata, &error_buffer);
2157 r = bus_maybe_reply_error(m, r, &error_buffer);
2163 } while (bus->filter_callbacks_modified);
2168 static int process_match(sd_bus *bus, sd_bus_message *m) {
2175 bus->match_callbacks_modified = false;
2177 r = bus_match_run(bus, &bus->match_callbacks, m);
2181 } while (bus->match_callbacks_modified);
2186 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2187 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2193 if (bus->manual_peer_interface)
2196 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2199 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2202 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2205 if (streq_ptr(m->member, "Ping"))
2206 r = sd_bus_message_new_method_return(m, &reply);
2207 else if (streq_ptr(m->member, "GetMachineId")) {
2211 r = sd_id128_get_machine(&id);
2215 r = sd_bus_message_new_method_return(m, &reply);
2219 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2221 r = sd_bus_message_new_method_errorf(
2223 SD_BUS_ERROR_UNKNOWN_METHOD,
2224 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2230 r = sd_bus_send(bus, reply, NULL);
2237 static int process_message(sd_bus *bus, sd_bus_message *m) {
2244 bus->iteration_counter++;
2246 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2247 bus_message_type_to_string(m->header->type),
2248 strna(sd_bus_message_get_sender(m)),
2249 strna(sd_bus_message_get_destination(m)),
2250 strna(sd_bus_message_get_path(m)),
2251 strna(sd_bus_message_get_interface(m)),
2252 strna(sd_bus_message_get_member(m)),
2253 (unsigned long) BUS_MESSAGE_COOKIE(m),
2254 (unsigned long) m->reply_cookie,
2255 strna(m->error.message));
2257 r = process_hello(bus, m);
2261 r = process_reply(bus, m);
2265 r = process_filter(bus, m);
2269 r = process_match(bus, m);
2273 r = process_builtin(bus, m);
2277 r = bus_process_object(bus, m);
2280 bus->current = NULL;
2284 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2285 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2289 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2291 r = process_timeout(bus);
2295 r = dispatch_wqueue(bus);
2299 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2305 r = process_message(bus, m);
2310 r = sd_bus_message_rewind(m, true);
2319 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2321 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2322 strna(sd_bus_message_get_sender(m)),
2323 strna(sd_bus_message_get_path(m)),
2324 strna(sd_bus_message_get_interface(m)),
2325 strna(sd_bus_message_get_member(m)));
2327 r = sd_bus_reply_method_errorf(
2329 SD_BUS_ERROR_UNKNOWN_OBJECT,
2330 "Unknown object '%s'.", m->path);
2344 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2345 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2346 struct reply_callback *c;
2350 assert(bus->state == BUS_CLOSING);
2352 c = hashmap_first(bus->reply_callbacks);
2354 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2356 /* First, fail all outstanding method calls */
2357 r = bus_message_new_synthetic_error(
2360 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2365 r = bus_seal_synthetic_message(bus, m);
2369 if (c->timeout != 0)
2370 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2372 hashmap_remove(bus->reply_callbacks, &c->cookie);
2375 bus->iteration_counter++;
2377 r = c->callback(bus, m, c->userdata, &error_buffer);
2378 r = bus_maybe_reply_error(m, r, &error_buffer);
2384 /* Then, synthesize a Disconnected message */
2385 r = sd_bus_message_new_signal(
2387 "/org/freedesktop/DBus/Local",
2388 "org.freedesktop.DBus.Local",
2394 m->sender = "org.freedesktop.DBus.Local";
2396 r = bus_seal_synthetic_message(bus, m);
2403 bus->iteration_counter++;
2405 r = process_filter(bus, m);
2409 r = process_match(bus, m);
2421 bus->current = NULL;
2425 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2426 BUS_DONT_DESTROY(bus);
2429 /* Returns 0 when we didn't do anything. This should cause the
2430 * caller to invoke sd_bus_wait() before returning the next
2431 * time. Returns > 0 when we did something, which possibly
2432 * means *ret is filled in with an unprocessed message. */
2434 assert_return(bus, -EINVAL);
2435 assert_return(!bus_pid_changed(bus), -ECHILD);
2437 /* We don't allow recursively invoking sd_bus_process(). */
2438 assert_return(!bus->current, -EBUSY);
2440 switch (bus->state) {
2449 r = bus_socket_process_opening(bus);
2450 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2451 bus_enter_closing(bus);
2459 case BUS_AUTHENTICATING:
2460 r = bus_socket_process_authenticating(bus);
2461 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2462 bus_enter_closing(bus);
2474 r = process_running(bus, hint_priority, priority, ret);
2475 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2476 bus_enter_closing(bus);
2486 return process_closing(bus, ret);
2489 assert_not_reached("Unknown state");
2492 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2493 return bus_process_internal(bus, false, 0, ret);
2496 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2497 return bus_process_internal(bus, true, priority, ret);
2500 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2501 struct pollfd p[2] = {};
2504 usec_t m = (usec_t) -1;
2508 if (bus->state == BUS_CLOSING)
2511 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2513 e = sd_bus_get_events(bus);
2518 /* The caller really needs some more data, he doesn't
2519 * care about what's already read, or any timeouts
2524 /* The caller wants to process if there's something to
2525 * process, but doesn't care otherwise */
2527 r = sd_bus_get_timeout(bus, &until);
2532 nw = now(CLOCK_MONOTONIC);
2533 m = until > nw ? until - nw : 0;
2537 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2540 p[0].fd = bus->input_fd;
2541 if (bus->output_fd == bus->input_fd) {
2545 p[0].events = e & POLLIN;
2546 p[1].fd = bus->output_fd;
2547 p[1].events = e & POLLOUT;
2551 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2555 return r > 0 ? 1 : 0;
2558 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2560 assert_return(bus, -EINVAL);
2561 assert_return(!bus_pid_changed(bus), -ECHILD);
2563 if (bus->state == BUS_CLOSING)
2566 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2568 if (bus->rqueue_size > 0)
2571 return bus_poll(bus, false, timeout_usec);
2574 _public_ int sd_bus_flush(sd_bus *bus) {
2577 assert_return(bus, -EINVAL);
2578 assert_return(!bus_pid_changed(bus), -ECHILD);
2580 if (bus->state == BUS_CLOSING)
2583 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2585 r = bus_ensure_running(bus);
2589 if (bus->wqueue_size <= 0)
2593 r = dispatch_wqueue(bus);
2595 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2596 bus_enter_closing(bus);
2603 if (bus->wqueue_size <= 0)
2606 r = bus_poll(bus, false, (uint64_t) -1);
2612 _public_ int sd_bus_add_filter(sd_bus *bus,
2613 sd_bus_message_handler_t callback,
2616 struct filter_callback *f;
2618 assert_return(bus, -EINVAL);
2619 assert_return(callback, -EINVAL);
2620 assert_return(!bus_pid_changed(bus), -ECHILD);
2622 f = new0(struct filter_callback, 1);
2625 f->callback = callback;
2626 f->userdata = userdata;
2628 bus->filter_callbacks_modified = true;
2629 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2633 _public_ int sd_bus_remove_filter(sd_bus *bus,
2634 sd_bus_message_handler_t callback,
2637 struct filter_callback *f;
2639 assert_return(bus, -EINVAL);
2640 assert_return(callback, -EINVAL);
2641 assert_return(!bus_pid_changed(bus), -ECHILD);
2643 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2644 if (f->callback == callback && f->userdata == userdata) {
2645 bus->filter_callbacks_modified = true;
2646 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2655 _public_ int sd_bus_add_match(sd_bus *bus,
2657 sd_bus_message_handler_t callback,
2660 struct bus_match_component *components = NULL;
2661 unsigned n_components = 0;
2662 uint64_t cookie = 0;
2665 assert_return(bus, -EINVAL);
2666 assert_return(match, -EINVAL);
2667 assert_return(!bus_pid_changed(bus), -ECHILD);
2669 r = bus_match_parse(match, &components, &n_components);
2673 if (bus->bus_client) {
2674 cookie = ++bus->match_cookie;
2676 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2681 bus->match_callbacks_modified = true;
2682 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2684 if (bus->bus_client)
2685 bus_remove_match_internal(bus, match, cookie);
2689 bus_match_parse_free(components, n_components);
2693 _public_ int sd_bus_remove_match(sd_bus *bus,
2695 sd_bus_message_handler_t callback,
2698 struct bus_match_component *components = NULL;
2699 unsigned n_components = 0;
2701 uint64_t cookie = 0;
2703 assert_return(bus, -EINVAL);
2704 assert_return(match, -EINVAL);
2705 assert_return(!bus_pid_changed(bus), -ECHILD);
2707 r = bus_match_parse(match, &components, &n_components);
2711 bus->match_callbacks_modified = true;
2712 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2714 if (bus->bus_client)
2715 q = bus_remove_match_internal(bus, match, cookie);
2717 bus_match_parse_free(components, n_components);
2719 return r < 0 ? r : q;
2722 bool bus_pid_changed(sd_bus *bus) {
2725 /* We don't support people creating a bus connection and
2726 * keeping it around over a fork(). Let's complain. */
2728 return bus->original_pid != getpid();
2731 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2732 sd_bus *bus = userdata;
2737 r = sd_bus_process(bus, NULL);
2744 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2745 sd_bus *bus = userdata;
2750 r = sd_bus_process(bus, NULL);
2757 static int prepare_callback(sd_event_source *s, void *userdata) {
2758 sd_bus *bus = userdata;
2765 e = sd_bus_get_events(bus);
2769 if (bus->output_fd != bus->input_fd) {
2771 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2775 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2779 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2784 r = sd_bus_get_timeout(bus, &until);
2790 j = sd_event_source_set_time(bus->time_event_source, until);
2795 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2802 static int quit_callback(sd_event_source *event, void *userdata) {
2803 sd_bus *bus = userdata;
2812 static int attach_io_events(sd_bus *bus) {
2817 if (bus->input_fd < 0)
2823 if (!bus->input_io_event_source) {
2824 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2828 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2832 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2834 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2839 if (bus->output_fd != bus->input_fd) {
2840 assert(bus->output_fd >= 0);
2842 if (!bus->output_io_event_source) {
2843 r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2847 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2849 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2858 static void detach_io_events(sd_bus *bus) {
2861 if (bus->input_io_event_source) {
2862 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2863 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2866 if (bus->output_io_event_source) {
2867 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2868 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2872 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2875 assert_return(bus, -EINVAL);
2876 assert_return(!bus->event, -EBUSY);
2878 assert(!bus->input_io_event_source);
2879 assert(!bus->output_io_event_source);
2880 assert(!bus->time_event_source);
2883 bus->event = sd_event_ref(event);
2885 r = sd_event_default(&bus->event);
2890 bus->event_priority = priority;
2892 r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2896 r = sd_event_source_set_priority(bus->time_event_source, priority);
2900 r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
2904 r = attach_io_events(bus);
2911 sd_bus_detach_event(bus);
2915 _public_ int sd_bus_detach_event(sd_bus *bus) {
2916 assert_return(bus, -EINVAL);
2921 detach_io_events(bus);
2923 if (bus->time_event_source) {
2924 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2925 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2928 if (bus->quit_event_source) {
2929 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2930 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2934 bus->event = sd_event_unref(bus->event);
2939 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2940 assert_return(bus, NULL);
2945 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2946 assert_return(bus, NULL);
2948 return bus->current;
2951 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2956 assert(default_bus);
2959 return !!*default_bus;
2962 *ret = sd_bus_ref(*default_bus);
2970 b->default_bus_ptr = default_bus;
2978 _public_ int sd_bus_default_system(sd_bus **ret) {
2979 static thread_local sd_bus *default_system_bus = NULL;
2981 return bus_default(sd_bus_open_system, &default_system_bus, ret);
2984 _public_ int sd_bus_default_user(sd_bus **ret) {
2985 static thread_local sd_bus *default_user_bus = NULL;
2987 return bus_default(sd_bus_open_user, &default_user_bus, ret);
2990 _public_ int sd_bus_default(sd_bus **ret) {
2994 /* Let's try our best to reuse another cached connection. If
2995 * the starter bus type is set, connect via our normal
2996 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
2997 * we can share the connection with the user/system default
3000 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3002 if (streq(e, "system"))
3003 return sd_bus_default_system(ret);
3004 else if (streq(e, "user") || streq(e, "session"))
3005 return sd_bus_default_user(ret);
3008 /* No type is specified, so we have not other option than to
3009 * use the starter address if it is set. */
3011 e = secure_getenv("DBUS_STARTER_ADDRESS");
3013 static thread_local sd_bus *default_starter_bus = NULL;
3015 return bus_default(sd_bus_open, &default_starter_bus, ret);
3018 /* Finally, if nothing is set use the cached connection for
3019 * the right scope */
3021 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3022 return sd_bus_default_user(ret);
3024 return sd_bus_default_system(ret);
3027 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3028 assert_return(b, -EINVAL);
3029 assert_return(tid, -EINVAL);
3030 assert_return(!bus_pid_changed(b), -ECHILD);
3038 return sd_event_get_tid(b->event, tid);
3043 _public_ char *sd_bus_label_escape(const char *s) {
3047 assert_return(s, NULL);
3049 /* Escapes all chars that D-Bus' object path cannot deal
3050 * with. Can be reversed with bus_path_unescape(). We special
3051 * case the empty string. */
3056 r = new(char, strlen(s)*3 + 1);
3060 for (f = s, t = r; *f; f++) {
3062 /* Escape everything that is not a-zA-Z0-9. We also
3063 * escape 0-9 if it's the first character */
3065 if (!(*f >= 'A' && *f <= 'Z') &&
3066 !(*f >= 'a' && *f <= 'z') &&
3067 !(f > s && *f >= '0' && *f <= '9')) {
3069 *(t++) = hexchar(*f >> 4);
3070 *(t++) = hexchar(*f);
3080 _public_ char *sd_bus_label_unescape(const char *f) {
3083 assert_return(f, NULL);
3085 /* Special case for the empty string */
3089 r = new(char, strlen(f) + 1);
3093 for (t = r; *f; f++) {
3098 if ((a = unhexchar(f[1])) < 0 ||
3099 (b = unhexchar(f[2])) < 0) {
3100 /* Invalid escape code, let's take it literal then */
3103 *(t++) = (char) ((a << 4) | b);
3115 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3120 assert_return(bus, -EINVAL);
3121 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3122 assert_return(ret, -EINVAL);
3123 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3124 assert_return(!bus_pid_changed(bus), -ECHILD);
3125 assert_return(!bus->is_kernel, -ENOTSUP);
3127 if (!bus->ucred_valid && !isempty(bus->label))
3130 c = bus_creds_new();
3134 if (bus->ucred_valid) {
3135 pid = c->pid = bus->ucred.pid;
3136 c->uid = bus->ucred.uid;
3137 c->gid = bus->ucred.gid;
3139 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3142 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3143 c->label = strdup(bus->label);
3145 sd_bus_creds_unref(c);
3149 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3152 r = bus_creds_add_more(c, mask, pid, 0);
3160 _public_ int sd_bus_try_close(sd_bus *bus) {
3163 assert_return(bus, -EINVAL);
3164 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3165 assert_return(!bus_pid_changed(bus), -ECHILD);
3166 assert_return(bus->is_kernel, -ENOTSUP);
3168 if (bus->rqueue_size > 0)
3171 if (bus->wqueue_size > 0)
3174 r = bus_kernel_try_close(bus);
3182 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3183 assert_return(bus, -EINVAL);
3184 assert_return(name, -EINVAL);
3185 assert_return(!bus_pid_changed(bus), -ECHILD);
3187 *name = bus->connection_name;