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/>.
40 #include "bus-internal.h"
41 #include "bus-message.h"
43 #include "bus-socket.h"
44 #include "bus-kernel.h"
45 #include "bus-control.h"
46 #include "bus-introspect.h"
47 #include "bus-signature.h"
48 #include "bus-objects.h"
50 #include "bus-container.h"
51 #include "bus-protocol.h"
53 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
54 static int attach_io_events(sd_bus *b);
55 static void detach_io_events(sd_bus *b);
57 static void bus_close_fds(sd_bus *b) {
63 close_nointr_nofail(b->input_fd);
65 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
66 close_nointr_nofail(b->output_fd);
68 b->input_fd = b->output_fd = -1;
71 static void bus_node_destroy(sd_bus *b, struct node *n) {
72 struct node_callback *c;
73 struct node_vtable *v;
74 struct node_enumerator *e;
82 bus_node_destroy(b, n->child);
84 while ((c = n->callbacks)) {
85 LIST_REMOVE(callbacks, n->callbacks, c);
89 while ((v = n->vtables)) {
90 LIST_REMOVE(vtables, n->vtables, v);
95 while ((e = n->enumerators)) {
96 LIST_REMOVE(enumerators, n->enumerators, e);
101 LIST_REMOVE(siblings, n->parent->child, n);
103 assert_se(hashmap_remove(b->nodes, n->path) == n);
108 static void bus_reset_queues(sd_bus *b) {
113 for (i = 0; i < b->rqueue_size; i++)
114 sd_bus_message_unref(b->rqueue[i]);
117 for (i = 0; i < b->wqueue_size; i++)
118 sd_bus_message_unref(b->wqueue[i]);
121 b->rqueue = b->wqueue = NULL;
122 b->rqueue_allocated = b->wqueue_allocated = 0;
123 b->rqueue_size = b->wqueue_size = 0;
126 static void bus_free(sd_bus *b) {
127 struct filter_callback *f;
132 sd_bus_detach_event(b);
137 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
140 free(b->unique_name);
141 free(b->auth_buffer);
146 free(b->cgroup_root);
147 free(b->connection_name);
150 strv_free(b->exec_argv);
152 close_many(b->fds, b->n_fds);
157 hashmap_free_free(b->reply_callbacks);
158 prioq_free(b->reply_callbacks_prioq);
160 while ((f = b->filter_callbacks)) {
161 LIST_REMOVE(callbacks, b->filter_callbacks, f);
165 bus_match_free(&b->match_callbacks);
167 hashmap_free_free(b->vtable_methods);
168 hashmap_free_free(b->vtable_properties);
170 while ((n = hashmap_first(b->nodes)))
171 bus_node_destroy(b, n);
173 hashmap_free(b->nodes);
175 bus_kernel_flush_memfd(b);
177 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
182 _public_ int sd_bus_new(sd_bus **ret) {
185 assert_return(ret, -EINVAL);
191 r->n_ref = REFCNT_INIT;
192 r->input_fd = r->output_fd = -1;
193 r->message_version = 1;
194 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
195 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
196 r->attach_flags |= KDBUS_ATTACH_NAMES;
197 r->original_pid = getpid();
199 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
201 /* We guarantee that wqueue always has space for at least one
203 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
212 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
215 assert_return(bus, -EINVAL);
216 assert_return(bus->state == BUS_UNSET, -EPERM);
217 assert_return(address, -EINVAL);
218 assert_return(!bus_pid_changed(bus), -ECHILD);
230 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
231 assert_return(bus, -EINVAL);
232 assert_return(bus->state == BUS_UNSET, -EPERM);
233 assert_return(input_fd >= 0, -EINVAL);
234 assert_return(output_fd >= 0, -EINVAL);
235 assert_return(!bus_pid_changed(bus), -ECHILD);
237 bus->input_fd = input_fd;
238 bus->output_fd = output_fd;
242 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
245 assert_return(bus, -EINVAL);
246 assert_return(bus->state == BUS_UNSET, -EPERM);
247 assert_return(path, -EINVAL);
248 assert_return(!strv_isempty(argv), -EINVAL);
249 assert_return(!bus_pid_changed(bus), -ECHILD);
261 free(bus->exec_path);
262 strv_free(bus->exec_argv);
270 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
271 assert_return(bus, -EINVAL);
272 assert_return(bus->state == BUS_UNSET, -EPERM);
273 assert_return(!bus_pid_changed(bus), -ECHILD);
275 bus->bus_client = !!b;
279 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
280 assert_return(bus, -EINVAL);
281 assert_return(bus->state == BUS_UNSET, -EPERM);
282 assert_return(!bus_pid_changed(bus), -ECHILD);
284 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
288 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
289 assert_return(bus, -EINVAL);
290 assert_return(bus->state == BUS_UNSET, -EPERM);
291 assert_return(!bus_pid_changed(bus), -ECHILD);
293 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
297 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
298 assert_return(bus, -EINVAL);
299 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
300 assert_return(bus->state == BUS_UNSET, -EPERM);
301 assert_return(!bus_pid_changed(bus), -ECHILD);
303 /* The well knowns we need unconditionally, so that matches can work */
304 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
306 return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
309 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
310 assert_return(bus, -EINVAL);
311 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
312 assert_return(bus->state == BUS_UNSET, -EPERM);
313 assert_return(!bus_pid_changed(bus), -ECHILD);
315 bus->is_server = !!b;
316 bus->server_id = server_id;
320 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
321 assert_return(bus, -EINVAL);
322 assert_return(bus->state == BUS_UNSET, -EPERM);
323 assert_return(!bus_pid_changed(bus), -ECHILD);
325 bus->anonymous_auth = !!b;
329 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
330 assert_return(bus, -EINVAL);
331 assert_return(bus->state == BUS_UNSET, -EPERM);
332 assert_return(!bus_pid_changed(bus), -ECHILD);
338 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
341 assert_return(bus, -EINVAL);
342 assert_return(name, -EINVAL);
343 assert_return(bus->state == BUS_UNSET, -EPERM);
344 assert_return(!bus_pid_changed(bus), -ECHILD);
350 free(bus->connection_name);
351 bus->connection_name = n;
356 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
361 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
364 r = sd_bus_message_get_errno(reply);
370 r = sd_bus_message_read(reply, "s", &s);
374 if (!service_name_is_valid(s) || s[0] != ':')
377 bus->unique_name = strdup(s);
378 if (!bus->unique_name)
381 if (bus->state == BUS_HELLO)
382 bus->state = BUS_RUNNING;
387 static int bus_send_hello(sd_bus *bus) {
388 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
393 if (!bus->bus_client || bus->is_kernel)
396 r = sd_bus_message_new_method_call(
398 "org.freedesktop.DBus",
399 "/org/freedesktop/DBus",
400 "org.freedesktop.DBus",
406 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie);
409 int bus_start_running(sd_bus *bus) {
412 if (bus->bus_client && !bus->is_kernel) {
413 bus->state = BUS_HELLO;
417 bus->state = BUS_RUNNING;
421 static int parse_address_key(const char **p, const char *key, char **value) {
422 size_t l, n = 0, allocated = 0;
432 if (strncmp(*p, key, l) != 0)
445 while (*a != ';' && *a != ',' && *a != 0) {
463 c = (char) ((x << 4) | y);
470 if (!GREEDY_REALLOC(r, allocated, n + 2))
494 static void skip_address_key(const char **p) {
498 *p += strcspn(*p, ",");
504 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
505 _cleanup_free_ char *path = NULL, *abstract = NULL;
514 while (**p != 0 && **p != ';') {
515 r = parse_address_key(p, "guid", guid);
521 r = parse_address_key(p, "path", &path);
527 r = parse_address_key(p, "abstract", &abstract);
536 if (!path && !abstract)
539 if (path && abstract)
544 if (l > sizeof(b->sockaddr.un.sun_path))
547 b->sockaddr.un.sun_family = AF_UNIX;
548 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
549 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
550 } else if (abstract) {
551 l = strlen(abstract);
552 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
555 b->sockaddr.un.sun_family = AF_UNIX;
556 b->sockaddr.un.sun_path[0] = 0;
557 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
558 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
564 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
565 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
567 struct addrinfo *result, hints = {
568 .ai_socktype = SOCK_STREAM,
569 .ai_flags = AI_ADDRCONFIG,
577 while (**p != 0 && **p != ';') {
578 r = parse_address_key(p, "guid", guid);
584 r = parse_address_key(p, "host", &host);
590 r = parse_address_key(p, "port", &port);
596 r = parse_address_key(p, "family", &family);
609 if (streq(family, "ipv4"))
610 hints.ai_family = AF_INET;
611 else if (streq(family, "ipv6"))
612 hints.ai_family = AF_INET6;
617 r = getaddrinfo(host, port, &hints, &result);
621 return -EADDRNOTAVAIL;
623 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
624 b->sockaddr_size = result->ai_addrlen;
626 freeaddrinfo(result);
631 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
633 unsigned n_argv = 0, j;
635 size_t allocated = 0;
643 while (**p != 0 && **p != ';') {
644 r = parse_address_key(p, "guid", guid);
650 r = parse_address_key(p, "path", &path);
656 if (startswith(*p, "argv")) {
660 ul = strtoul(*p + 4, (char**) p, 10);
661 if (errno > 0 || **p != '=' || ul > 256) {
669 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
677 r = parse_address_key(p, NULL, argv + ul);
692 /* Make sure there are no holes in the array, with the
693 * exception of argv[0] */
694 for (j = 1; j < n_argv; j++)
700 if (argv && argv[0] == NULL) {
701 argv[0] = strdup(path);
713 for (j = 0; j < n_argv; j++)
721 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
722 _cleanup_free_ char *path = NULL;
730 while (**p != 0 && **p != ';') {
731 r = parse_address_key(p, "guid", guid);
737 r = parse_address_key(p, "path", &path);
756 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
757 _cleanup_free_ char *machine = NULL;
765 while (**p != 0 && **p != ';') {
766 r = parse_address_key(p, "guid", guid);
772 r = parse_address_key(p, "machine", &machine);
784 if (!filename_is_safe(machine))
788 b->machine = machine;
791 b->sockaddr.un.sun_family = AF_UNIX;
792 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
793 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
798 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
799 _cleanup_free_ char *machine = NULL;
807 while (**p != 0 && **p != ';') {
808 r = parse_address_key(p, "guid", guid);
814 r = parse_address_key(p, "machine", &machine);
826 if (!filename_is_safe(machine))
830 b->machine = machine;
834 b->kernel = strdup("/dev/kdbus/0-system/bus");
841 static void bus_reset_parsed_address(sd_bus *b) {
845 b->sockaddr_size = 0;
846 strv_free(b->exec_argv);
850 b->server_id = SD_ID128_NULL;
857 static int bus_parse_next_address(sd_bus *b) {
858 _cleanup_free_ char *guid = NULL;
866 if (b->address[b->address_index] == 0)
869 bus_reset_parsed_address(b);
871 a = b->address + b->address_index;
880 if (startswith(a, "unix:")) {
883 r = parse_unix_address(b, &a, &guid);
888 } else if (startswith(a, "tcp:")) {
891 r = parse_tcp_address(b, &a, &guid);
897 } else if (startswith(a, "unixexec:")) {
900 r = parse_exec_address(b, &a, &guid);
906 } else if (startswith(a, "kernel:")) {
909 r = parse_kernel_address(b, &a, &guid);
914 } else if (startswith(a, "x-container-unix:")) {
917 r = parse_container_unix_address(b, &a, &guid);
922 } else if (startswith(a, "x-container-kernel:")) {
925 r = parse_container_kernel_address(b, &a, &guid);
938 r = sd_id128_from_string(guid, &b->server_id);
943 b->address_index = a - b->address;
947 static int bus_start_address(sd_bus *b) {
953 bool skipped = false;
958 r = bus_socket_exec(b);
959 else if (b->machine && b->kernel)
960 r = bus_container_connect_kernel(b);
961 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
962 r = bus_container_connect_socket(b);
964 r = bus_kernel_connect(b);
965 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
966 r = bus_socket_connect(b);
972 r = attach_io_events(b);
977 b->last_connect_error = -r;
980 r = bus_parse_next_address(b);
984 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
988 int bus_next_address(sd_bus *b) {
991 bus_reset_parsed_address(b);
992 return bus_start_address(b);
995 static int bus_start_fd(sd_bus *b) {
1000 assert(b->input_fd >= 0);
1001 assert(b->output_fd >= 0);
1003 r = fd_nonblock(b->input_fd, true);
1007 r = fd_cloexec(b->input_fd, true);
1011 if (b->input_fd != b->output_fd) {
1012 r = fd_nonblock(b->output_fd, true);
1016 r = fd_cloexec(b->output_fd, true);
1021 if (fstat(b->input_fd, &st) < 0)
1024 if (S_ISCHR(b->input_fd))
1025 return bus_kernel_take_fd(b);
1027 return bus_socket_take_fd(b);
1030 _public_ int sd_bus_start(sd_bus *bus) {
1033 assert_return(bus, -EINVAL);
1034 assert_return(bus->state == BUS_UNSET, -EPERM);
1035 assert_return(!bus_pid_changed(bus), -ECHILD);
1037 bus->state = BUS_OPENING;
1039 if (bus->is_server && bus->bus_client)
1042 if (bus->input_fd >= 0)
1043 r = bus_start_fd(bus);
1044 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1045 r = bus_start_address(bus);
1052 return bus_send_hello(bus);
1055 _public_ int sd_bus_open_system(sd_bus **ret) {
1060 assert_return(ret, -EINVAL);
1066 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1068 r = sd_bus_set_address(b, e);
1070 r = sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1074 b->bus_client = true;
1075 b->is_system = true;
1077 /* Let's do per-method access control on the system bus. We
1078 * need the caller's UID and capability set for that. */
1080 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1082 r = sd_bus_start(b);
1094 _public_ int sd_bus_open_user(sd_bus **ret) {
1099 assert_return(ret, -EINVAL);
1105 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1107 r = sd_bus_set_address(b, e);
1111 e = secure_getenv("XDG_RUNTIME_DIR");
1113 _cleanup_free_ char *ee = NULL;
1115 ee = bus_address_escape(e);
1122 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee);
1124 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1128 asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
1130 return -ECONNREFUSED;
1140 b->bus_client = true;
1143 /* We don't do any per-method access control on the user
1147 r = sd_bus_start(b);
1159 _public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) {
1160 _cleanup_free_ char *e = NULL;
1165 assert_return(host, -EINVAL);
1166 assert_return(ret, -EINVAL);
1168 e = bus_address_escape(host);
1172 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1176 r = sd_bus_new(&bus);
1183 bus->bus_client = true;
1185 r = sd_bus_start(bus);
1195 _public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) {
1196 _cleanup_free_ char *e = NULL;
1201 assert_return(machine, -EINVAL);
1202 assert_return(ret, -EINVAL);
1203 assert_return(filename_is_safe(machine), -EINVAL);
1205 e = bus_address_escape(machine);
1210 p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1212 p = strjoin("x-container-unix:machine=", e, NULL);
1217 r = sd_bus_new(&bus);
1224 bus->bus_client = true;
1226 r = sd_bus_start(bus);
1236 _public_ void sd_bus_close(sd_bus *bus) {
1240 if (bus->state == BUS_CLOSED)
1242 if (bus_pid_changed(bus))
1245 bus->state = BUS_CLOSED;
1247 sd_bus_detach_event(bus);
1249 /* Drop all queued messages so that they drop references to
1250 * the bus object and the bus may be freed */
1251 bus_reset_queues(bus);
1253 if (!bus->is_kernel)
1256 /* We'll leave the fd open in case this is a kernel bus, since
1257 * there might still be memblocks around that reference this
1258 * bus, and they might need to invoke the KDBUS_CMD_FREE
1259 * ioctl on the fd when they are freed. */
1262 static void bus_enter_closing(sd_bus *bus) {
1265 if (bus->state != BUS_OPENING &&
1266 bus->state != BUS_AUTHENTICATING &&
1267 bus->state != BUS_HELLO &&
1268 bus->state != BUS_RUNNING)
1271 bus->state = BUS_CLOSING;
1274 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1275 assert_return(bus, NULL);
1277 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1282 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1288 i = REFCNT_DEC(bus->n_ref);
1289 if (i != bus->rqueue_size + bus->wqueue_size)
1292 for (i = 0; i < bus->rqueue_size; i++)
1293 if (bus->rqueue[i]->n_ref > 1)
1296 for (i = 0; i < bus->wqueue_size; i++)
1297 if (bus->wqueue[i]->n_ref > 1)
1300 /* we are the only holders on the messages */
1306 _public_ int sd_bus_is_open(sd_bus *bus) {
1308 assert_return(bus, -EINVAL);
1309 assert_return(!bus_pid_changed(bus), -ECHILD);
1311 return BUS_IS_OPEN(bus->state);
1314 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1317 assert_return(bus, -EINVAL);
1318 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1319 assert_return(!bus_pid_changed(bus), -ECHILD);
1321 if (type == SD_BUS_TYPE_UNIX_FD) {
1322 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1325 r = bus_ensure_running(bus);
1329 return bus->can_fds;
1332 return bus_type_is_valid(type);
1335 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1338 assert_return(bus, -EINVAL);
1339 assert_return(server_id, -EINVAL);
1340 assert_return(!bus_pid_changed(bus), -ECHILD);
1342 r = bus_ensure_running(bus);
1346 *server_id = bus->server_id;
1350 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1355 /* If we copy the same message to multiple
1356 * destinations, avoid using the same cookie
1358 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1363 timeout = BUS_DEFAULT_TIMEOUT;
1365 return bus_message_seal(m, ++b->cookie, timeout);
1368 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1371 /* Do packet version and endianess already match? */
1372 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1373 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1376 /* No? Then remarshal! */
1377 return bus_message_remarshal(b, m);
1380 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1384 /* The bus specification says the serial number cannot be 0,
1385 * hence let's fill something in for synthetic messages. Since
1386 * synthetic messages might have a fake sender and we don't
1387 * want to interfere with the real sender's serial numbers we
1388 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1389 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1390 * even though kdbus can do 64bit. */
1392 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1395 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1402 r = bus_kernel_write_message(bus, m, hint_sync_call);
1404 r = bus_socket_write_message(bus, m, idx);
1409 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1410 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
1411 bus_message_type_to_string(m->header->type),
1412 strna(sd_bus_message_get_sender(m)),
1413 strna(sd_bus_message_get_destination(m)),
1414 strna(sd_bus_message_get_path(m)),
1415 strna(sd_bus_message_get_interface(m)),
1416 strna(sd_bus_message_get_member(m)),
1417 (unsigned long) BUS_MESSAGE_COOKIE(m),
1418 (unsigned long) m->reply_cookie,
1419 strna(m->error.message));
1424 static int dispatch_wqueue(sd_bus *bus) {
1428 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1430 while (bus->wqueue_size > 0) {
1432 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1436 /* Didn't do anything this time */
1438 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1439 /* Fully written. Let's drop the entry from
1442 * This isn't particularly optimized, but
1443 * well, this is supposed to be our worst-case
1444 * buffer only, and the socket buffer is
1445 * supposed to be our primary buffer, and if
1446 * it got full, then all bets are off
1449 bus->wqueue_size --;
1450 sd_bus_message_unref(bus->wqueue[0]);
1451 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1461 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1465 return bus_kernel_read_message(bus, hint_priority, priority);
1467 return bus_socket_read_message(bus);
1470 int bus_rqueue_make_room(sd_bus *bus) {
1473 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1476 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1482 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1487 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1489 /* Note that the priority logic is only available on kdbus,
1490 * where the rqueue is unused. We check the rqueue here
1491 * anyway, because it's simple... */
1494 if (bus->rqueue_size > 0) {
1495 /* Dispatch a queued message */
1497 *m = bus->rqueue[0];
1498 bus->rqueue_size --;
1499 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1503 /* Try to read a new message */
1504 r = bus_read_message(bus, hint_priority, priority);
1514 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1515 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1518 assert_return(bus, -EINVAL);
1519 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1520 assert_return(m, -EINVAL);
1521 assert_return(!bus_pid_changed(bus), -ECHILD);
1524 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1531 /* If the cookie number isn't kept, then we know that no reply
1533 if (!cookie && !m->sealed)
1534 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1536 r = bus_seal_message(bus, m, 0);
1540 /* Remarshall if we have to. This will possibly unref the
1541 * message and place a replacement in m */
1542 r = bus_remarshal_message(bus, &m);
1546 /* If this is a reply and no reply was requested, then let's
1547 * suppress this, if we can */
1548 if (m->dont_send && !cookie)
1551 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1554 r = bus_write_message(bus, m, hint_sync_call, &idx);
1556 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1557 bus_enter_closing(bus);
1562 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1563 /* Wasn't fully written. So let's remember how
1564 * much was written. Note that the first entry
1565 * of the wqueue array is always allocated so
1566 * that we always can remember how much was
1568 bus->wqueue[0] = sd_bus_message_ref(m);
1569 bus->wqueue_size = 1;
1573 /* Just append it to the queue. */
1575 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1578 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1581 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1585 *cookie = BUS_MESSAGE_COOKIE(m);
1590 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1591 return bus_send_internal(bus, m, cookie, false);
1594 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1597 assert_return(bus, -EINVAL);
1598 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1599 assert_return(m, -EINVAL);
1600 assert_return(!bus_pid_changed(bus), -ECHILD);
1602 if (!streq_ptr(m->destination, destination)) {
1607 r = sd_bus_message_set_destination(m, destination);
1612 return sd_bus_send(bus, m, cookie);
1615 static usec_t calc_elapse(uint64_t usec) {
1616 if (usec == (uint64_t) -1)
1619 return now(CLOCK_MONOTONIC) + usec;
1622 static int timeout_compare(const void *a, const void *b) {
1623 const struct reply_callback *x = a, *y = b;
1625 if (x->timeout != 0 && y->timeout == 0)
1628 if (x->timeout == 0 && y->timeout != 0)
1631 if (x->timeout < y->timeout)
1634 if (x->timeout > y->timeout)
1640 _public_ int sd_bus_call_async(
1643 sd_bus_message_handler_t callback,
1648 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1649 struct reply_callback *c;
1652 assert_return(bus, -EINVAL);
1653 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1654 assert_return(m, -EINVAL);
1655 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1656 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1657 assert_return(callback, -EINVAL);
1658 assert_return(!bus_pid_changed(bus), -ECHILD);
1660 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1664 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1668 r = bus_seal_message(bus, m, usec);
1672 r = bus_remarshal_message(bus, &m);
1676 c = new0(struct reply_callback, 1);
1680 c->callback = callback;
1681 c->userdata = userdata;
1682 c->cookie = BUS_MESSAGE_COOKIE(m);
1683 c->timeout = calc_elapse(m->timeout);
1685 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1691 if (c->timeout != 0) {
1692 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1695 sd_bus_call_async_cancel(bus, c->cookie);
1700 r = sd_bus_send(bus, m, cookie);
1702 sd_bus_call_async_cancel(bus, c->cookie);
1709 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1710 struct reply_callback *c;
1712 assert_return(bus, -EINVAL);
1713 assert_return(cookie != 0, -EINVAL);
1714 assert_return(!bus_pid_changed(bus), -ECHILD);
1716 c = hashmap_remove(bus->reply_callbacks, &cookie);
1720 if (c->timeout != 0)
1721 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1727 int bus_ensure_running(sd_bus *bus) {
1732 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1734 if (bus->state == BUS_RUNNING)
1738 r = sd_bus_process(bus, NULL);
1741 if (bus->state == BUS_RUNNING)
1746 r = sd_bus_wait(bus, (uint64_t) -1);
1752 _public_ int sd_bus_call(
1756 sd_bus_error *error,
1757 sd_bus_message **reply) {
1759 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1765 assert_return(bus, -EINVAL);
1766 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1767 assert_return(m, -EINVAL);
1768 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1769 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1770 assert_return(!bus_error_is_dirty(error), -EINVAL);
1771 assert_return(!bus_pid_changed(bus), -ECHILD);
1773 r = bus_ensure_running(bus);
1777 i = bus->rqueue_size;
1779 r = bus_seal_message(bus, m, usec);
1783 r = bus_remarshal_message(bus, &m);
1787 r = bus_send_internal(bus, m, &cookie, true);
1791 timeout = calc_elapse(m->timeout);
1796 while (i < bus->rqueue_size) {
1797 sd_bus_message *incoming = NULL;
1799 incoming = bus->rqueue[i];
1801 if (incoming->reply_cookie == cookie) {
1802 /* Found a match! */
1804 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1807 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1812 sd_bus_message_unref(incoming);
1815 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1816 r = sd_bus_error_copy(error, &incoming->error);
1820 sd_bus_message_unref(incoming);
1823 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1826 streq(bus->unique_name, incoming->sender)) {
1828 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1831 /* Our own message? Somebody is trying
1832 * to send its own client a message,
1833 * let's not dead-lock, let's fail
1836 sd_bus_message_unref(incoming);
1840 /* Try to read more, right-away */
1844 r = bus_read_message(bus, false, 0);
1846 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1847 bus_enter_closing(bus);
1859 n = now(CLOCK_MONOTONIC);
1865 left = (uint64_t) -1;
1867 r = bus_poll(bus, true, left);
1873 r = dispatch_wqueue(bus);
1875 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1876 bus_enter_closing(bus);
1885 _public_ int sd_bus_get_fd(sd_bus *bus) {
1887 assert_return(bus, -EINVAL);
1888 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1889 assert_return(!bus_pid_changed(bus), -ECHILD);
1891 return bus->input_fd;
1894 _public_ int sd_bus_get_events(sd_bus *bus) {
1897 assert_return(bus, -EINVAL);
1898 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1899 assert_return(!bus_pid_changed(bus), -ECHILD);
1901 if (bus->state == BUS_OPENING)
1903 else if (bus->state == BUS_AUTHENTICATING) {
1905 if (bus_socket_auth_needs_write(bus))
1910 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1911 if (bus->rqueue_size <= 0)
1913 if (bus->wqueue_size > 0)
1920 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1921 struct reply_callback *c;
1923 assert_return(bus, -EINVAL);
1924 assert_return(timeout_usec, -EINVAL);
1925 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1926 assert_return(!bus_pid_changed(bus), -ECHILD);
1928 if (bus->state == BUS_CLOSING) {
1933 if (bus->state == BUS_AUTHENTICATING) {
1934 *timeout_usec = bus->auth_timeout;
1938 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1939 *timeout_usec = (uint64_t) -1;
1943 if (bus->rqueue_size > 0) {
1948 c = prioq_peek(bus->reply_callbacks_prioq);
1950 *timeout_usec = (uint64_t) -1;
1954 *timeout_usec = c->timeout;
1958 static int process_timeout(sd_bus *bus) {
1959 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1960 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1961 struct reply_callback *c;
1967 c = prioq_peek(bus->reply_callbacks_prioq);
1971 n = now(CLOCK_MONOTONIC);
1975 r = bus_message_new_synthetic_error(
1978 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
1983 m->sender = "org.freedesktop.DBus";
1985 r = bus_seal_synthetic_message(bus, m);
1989 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1990 hashmap_remove(bus->reply_callbacks, &c->cookie);
1993 bus->iteration_counter ++;
1995 r = c->callback(bus, m, c->userdata, &error_buffer);
1996 r = bus_maybe_reply_error(m, r, &error_buffer);
1999 bus->current = NULL;
2004 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2008 if (bus->state != BUS_HELLO)
2011 /* Let's make sure the first message on the bus is the HELLO
2012 * reply. But note that we don't actually parse the message
2013 * here (we leave that to the usual handling), we just verify
2014 * we don't let any earlier msg through. */
2016 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2017 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2020 if (m->reply_cookie != bus->hello_cookie)
2026 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2027 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2028 struct reply_callback *c;
2034 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2035 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2038 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2042 if (c->timeout != 0)
2043 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2045 r = sd_bus_message_rewind(m, true);
2049 r = c->callback(bus, m, c->userdata, &error_buffer);
2050 r = bus_maybe_reply_error(m, r, &error_buffer);
2056 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2057 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2058 struct filter_callback *l;
2065 bus->filter_callbacks_modified = false;
2067 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2069 if (bus->filter_callbacks_modified)
2072 /* Don't run this more than once per iteration */
2073 if (l->last_iteration == bus->iteration_counter)
2076 l->last_iteration = bus->iteration_counter;
2078 r = sd_bus_message_rewind(m, true);
2082 r = l->callback(bus, m, l->userdata, &error_buffer);
2083 r = bus_maybe_reply_error(m, r, &error_buffer);
2089 } while (bus->filter_callbacks_modified);
2094 static int process_match(sd_bus *bus, sd_bus_message *m) {
2101 bus->match_callbacks_modified = false;
2103 r = bus_match_run(bus, &bus->match_callbacks, m);
2107 } while (bus->match_callbacks_modified);
2112 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2113 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2119 if (bus->manual_peer_interface)
2122 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2125 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2128 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2131 if (streq_ptr(m->member, "Ping"))
2132 r = sd_bus_message_new_method_return(m, &reply);
2133 else if (streq_ptr(m->member, "GetMachineId")) {
2137 r = sd_id128_get_machine(&id);
2141 r = sd_bus_message_new_method_return(m, &reply);
2145 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2147 r = sd_bus_message_new_method_errorf(
2149 SD_BUS_ERROR_UNKNOWN_METHOD,
2150 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2156 r = sd_bus_send(bus, reply, NULL);
2163 static int process_message(sd_bus *bus, sd_bus_message *m) {
2170 bus->iteration_counter++;
2172 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2173 bus_message_type_to_string(m->header->type),
2174 strna(sd_bus_message_get_sender(m)),
2175 strna(sd_bus_message_get_destination(m)),
2176 strna(sd_bus_message_get_path(m)),
2177 strna(sd_bus_message_get_interface(m)),
2178 strna(sd_bus_message_get_member(m)),
2179 (unsigned long) BUS_MESSAGE_COOKIE(m),
2180 (unsigned long) m->reply_cookie,
2181 strna(m->error.message));
2183 r = process_hello(bus, m);
2187 r = process_reply(bus, m);
2191 r = process_filter(bus, m);
2195 r = process_match(bus, m);
2199 r = process_builtin(bus, m);
2203 r = bus_process_object(bus, m);
2206 bus->current = NULL;
2210 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2211 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2215 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2217 r = process_timeout(bus);
2221 r = dispatch_wqueue(bus);
2225 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2231 r = process_message(bus, m);
2236 r = sd_bus_message_rewind(m, true);
2245 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2247 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2248 strna(sd_bus_message_get_sender(m)),
2249 strna(sd_bus_message_get_path(m)),
2250 strna(sd_bus_message_get_interface(m)),
2251 strna(sd_bus_message_get_member(m)));
2253 r = sd_bus_reply_method_errorf(
2255 SD_BUS_ERROR_UNKNOWN_OBJECT,
2256 "Unknown object '%s'.", m->path);
2270 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2271 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2272 struct reply_callback *c;
2276 assert(bus->state == BUS_CLOSING);
2278 c = hashmap_first(bus->reply_callbacks);
2280 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2282 /* First, fail all outstanding method calls */
2283 r = bus_message_new_synthetic_error(
2286 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2291 r = bus_seal_synthetic_message(bus, m);
2295 if (c->timeout != 0)
2296 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2298 hashmap_remove(bus->reply_callbacks, &c->cookie);
2301 bus->iteration_counter++;
2303 r = c->callback(bus, m, c->userdata, &error_buffer);
2304 r = bus_maybe_reply_error(m, r, &error_buffer);
2310 /* Then, synthesize a Disconnected message */
2311 r = sd_bus_message_new_signal(
2313 "/org/freedesktop/DBus/Local",
2314 "org.freedesktop.DBus.Local",
2320 m->sender = "org.freedesktop.DBus.Local";
2322 r = bus_seal_synthetic_message(bus, m);
2329 bus->iteration_counter++;
2331 r = process_filter(bus, m);
2335 r = process_match(bus, m);
2347 bus->current = NULL;
2351 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2352 BUS_DONT_DESTROY(bus);
2355 /* Returns 0 when we didn't do anything. This should cause the
2356 * caller to invoke sd_bus_wait() before returning the next
2357 * time. Returns > 0 when we did something, which possibly
2358 * means *ret is filled in with an unprocessed message. */
2360 assert_return(bus, -EINVAL);
2361 assert_return(!bus_pid_changed(bus), -ECHILD);
2363 /* We don't allow recursively invoking sd_bus_process(). */
2364 assert_return(!bus->current, -EBUSY);
2366 switch (bus->state) {
2375 r = bus_socket_process_opening(bus);
2376 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2377 bus_enter_closing(bus);
2385 case BUS_AUTHENTICATING:
2386 r = bus_socket_process_authenticating(bus);
2387 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2388 bus_enter_closing(bus);
2400 r = process_running(bus, hint_priority, priority, ret);
2401 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2402 bus_enter_closing(bus);
2412 return process_closing(bus, ret);
2415 assert_not_reached("Unknown state");
2418 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2419 return bus_process_internal(bus, false, 0, ret);
2422 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2423 return bus_process_internal(bus, true, priority, ret);
2426 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2427 struct pollfd p[2] = {};
2430 usec_t m = (usec_t) -1;
2434 if (bus->state == BUS_CLOSING)
2437 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2439 e = sd_bus_get_events(bus);
2444 /* The caller really needs some more data, he doesn't
2445 * care about what's already read, or any timeouts
2450 /* The caller wants to process if there's something to
2451 * process, but doesn't care otherwise */
2453 r = sd_bus_get_timeout(bus, &until);
2458 nw = now(CLOCK_MONOTONIC);
2459 m = until > nw ? until - nw : 0;
2463 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2466 p[0].fd = bus->input_fd;
2467 if (bus->output_fd == bus->input_fd) {
2471 p[0].events = e & POLLIN;
2472 p[1].fd = bus->output_fd;
2473 p[1].events = e & POLLOUT;
2477 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2481 return r > 0 ? 1 : 0;
2484 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2486 assert_return(bus, -EINVAL);
2487 assert_return(!bus_pid_changed(bus), -ECHILD);
2489 if (bus->state == BUS_CLOSING)
2492 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2494 if (bus->rqueue_size > 0)
2497 return bus_poll(bus, false, timeout_usec);
2500 _public_ int sd_bus_flush(sd_bus *bus) {
2503 assert_return(bus, -EINVAL);
2504 assert_return(!bus_pid_changed(bus), -ECHILD);
2506 if (bus->state == BUS_CLOSING)
2509 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2511 r = bus_ensure_running(bus);
2515 if (bus->wqueue_size <= 0)
2519 r = dispatch_wqueue(bus);
2521 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2522 bus_enter_closing(bus);
2529 if (bus->wqueue_size <= 0)
2532 r = bus_poll(bus, false, (uint64_t) -1);
2538 _public_ int sd_bus_add_filter(sd_bus *bus,
2539 sd_bus_message_handler_t callback,
2542 struct filter_callback *f;
2544 assert_return(bus, -EINVAL);
2545 assert_return(callback, -EINVAL);
2546 assert_return(!bus_pid_changed(bus), -ECHILD);
2548 f = new0(struct filter_callback, 1);
2551 f->callback = callback;
2552 f->userdata = userdata;
2554 bus->filter_callbacks_modified = true;
2555 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2559 _public_ int sd_bus_remove_filter(sd_bus *bus,
2560 sd_bus_message_handler_t callback,
2563 struct filter_callback *f;
2565 assert_return(bus, -EINVAL);
2566 assert_return(callback, -EINVAL);
2567 assert_return(!bus_pid_changed(bus), -ECHILD);
2569 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2570 if (f->callback == callback && f->userdata == userdata) {
2571 bus->filter_callbacks_modified = true;
2572 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2581 _public_ int sd_bus_add_match(sd_bus *bus,
2583 sd_bus_message_handler_t callback,
2586 struct bus_match_component *components = NULL;
2587 unsigned n_components = 0;
2588 uint64_t cookie = 0;
2591 assert_return(bus, -EINVAL);
2592 assert_return(match, -EINVAL);
2593 assert_return(!bus_pid_changed(bus), -ECHILD);
2595 r = bus_match_parse(match, &components, &n_components);
2599 if (bus->bus_client) {
2600 cookie = ++bus->match_cookie;
2602 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2607 bus->match_callbacks_modified = true;
2608 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2610 if (bus->bus_client)
2611 bus_remove_match_internal(bus, match, cookie);
2615 bus_match_parse_free(components, n_components);
2619 _public_ int sd_bus_remove_match(sd_bus *bus,
2621 sd_bus_message_handler_t callback,
2624 struct bus_match_component *components = NULL;
2625 unsigned n_components = 0;
2627 uint64_t cookie = 0;
2629 assert_return(bus, -EINVAL);
2630 assert_return(match, -EINVAL);
2631 assert_return(!bus_pid_changed(bus), -ECHILD);
2633 r = bus_match_parse(match, &components, &n_components);
2637 bus->match_callbacks_modified = true;
2638 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2640 if (bus->bus_client)
2641 q = bus_remove_match_internal(bus, match, cookie);
2643 bus_match_parse_free(components, n_components);
2645 return r < 0 ? r : q;
2648 bool bus_pid_changed(sd_bus *bus) {
2651 /* We don't support people creating a bus connection and
2652 * keeping it around over a fork(). Let's complain. */
2654 return bus->original_pid != getpid();
2657 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2658 sd_bus *bus = userdata;
2663 r = sd_bus_process(bus, NULL);
2670 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2671 sd_bus *bus = userdata;
2676 r = sd_bus_process(bus, NULL);
2683 static int prepare_callback(sd_event_source *s, void *userdata) {
2684 sd_bus *bus = userdata;
2691 e = sd_bus_get_events(bus);
2695 if (bus->output_fd != bus->input_fd) {
2697 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2701 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2705 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2710 r = sd_bus_get_timeout(bus, &until);
2716 j = sd_event_source_set_time(bus->time_event_source, until);
2721 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2728 static int quit_callback(sd_event_source *event, void *userdata) {
2729 sd_bus *bus = userdata;
2738 static int attach_io_events(sd_bus *bus) {
2743 if (bus->input_fd < 0)
2749 if (!bus->input_io_event_source) {
2750 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2754 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2758 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2760 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2765 if (bus->output_fd != bus->input_fd) {
2766 assert(bus->output_fd >= 0);
2768 if (!bus->output_io_event_source) {
2769 r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2773 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2775 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2784 static void detach_io_events(sd_bus *bus) {
2787 if (bus->input_io_event_source) {
2788 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2789 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2792 if (bus->output_io_event_source) {
2793 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2794 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2798 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2801 assert_return(bus, -EINVAL);
2802 assert_return(!bus->event, -EBUSY);
2804 assert(!bus->input_io_event_source);
2805 assert(!bus->output_io_event_source);
2806 assert(!bus->time_event_source);
2809 bus->event = sd_event_ref(event);
2811 r = sd_event_default(&bus->event);
2816 bus->event_priority = priority;
2818 r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2822 r = sd_event_source_set_priority(bus->time_event_source, priority);
2826 r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
2830 r = attach_io_events(bus);
2837 sd_bus_detach_event(bus);
2841 _public_ int sd_bus_detach_event(sd_bus *bus) {
2842 assert_return(bus, -EINVAL);
2847 detach_io_events(bus);
2849 if (bus->time_event_source) {
2850 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2851 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2854 if (bus->quit_event_source) {
2855 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2856 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2860 bus->event = sd_event_unref(bus->event);
2865 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2866 assert_return(bus, NULL);
2871 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2872 assert_return(bus, NULL);
2874 return bus->current;
2877 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2882 assert(default_bus);
2885 return !!*default_bus;
2888 *ret = sd_bus_ref(*default_bus);
2896 b->default_bus_ptr = default_bus;
2904 _public_ int sd_bus_default_system(sd_bus **ret) {
2905 static thread_local sd_bus *default_system_bus = NULL;
2907 return bus_default(sd_bus_open_system, &default_system_bus, ret);
2910 _public_ int sd_bus_default_user(sd_bus **ret) {
2911 static thread_local sd_bus *default_user_bus = NULL;
2913 return bus_default(sd_bus_open_user, &default_user_bus, ret);
2916 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2917 assert_return(b, -EINVAL);
2918 assert_return(tid, -EINVAL);
2919 assert_return(!bus_pid_changed(b), -ECHILD);
2927 return sd_event_get_tid(b->event, tid);
2932 _public_ char *sd_bus_label_escape(const char *s) {
2936 assert_return(s, NULL);
2938 /* Escapes all chars that D-Bus' object path cannot deal
2939 * with. Can be reversed with bus_path_unescape(). We special
2940 * case the empty string. */
2945 r = new(char, strlen(s)*3 + 1);
2949 for (f = s, t = r; *f; f++) {
2951 /* Escape everything that is not a-zA-Z0-9. We also
2952 * escape 0-9 if it's the first character */
2954 if (!(*f >= 'A' && *f <= 'Z') &&
2955 !(*f >= 'a' && *f <= 'z') &&
2956 !(f > s && *f >= '0' && *f <= '9')) {
2958 *(t++) = hexchar(*f >> 4);
2959 *(t++) = hexchar(*f);
2969 _public_ char *sd_bus_label_unescape(const char *f) {
2972 assert_return(f, NULL);
2974 /* Special case for the empty string */
2978 r = new(char, strlen(f) + 1);
2982 for (t = r; *f; f++) {
2987 if ((a = unhexchar(f[1])) < 0 ||
2988 (b = unhexchar(f[2])) < 0) {
2989 /* Invalid escape code, let's take it literal then */
2992 *(t++) = (char) ((a << 4) | b);
3004 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3009 assert_return(bus, -EINVAL);
3010 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3011 assert_return(ret, -EINVAL);
3012 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3013 assert_return(!bus_pid_changed(bus), -ECHILD);
3014 assert_return(!bus->is_kernel, -ENOTSUP);
3016 if (!bus->ucred_valid && !isempty(bus->label))
3019 c = bus_creds_new();
3023 if (bus->ucred_valid) {
3024 pid = c->pid = bus->ucred.pid;
3025 c->uid = bus->ucred.uid;
3026 c->gid = bus->ucred.gid;
3028 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3031 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3032 c->label = strdup(bus->label);
3034 sd_bus_creds_unref(c);
3038 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3041 r = bus_creds_add_more(c, mask, pid, 0);
3049 _public_ int sd_bus_try_close(sd_bus *bus) {
3052 assert_return(bus, -EINVAL);
3053 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3054 assert_return(!bus_pid_changed(bus), -ECHILD);
3055 assert_return(bus->is_kernel, -ENOTSUP);
3057 if (bus->rqueue_size > 0)
3060 if (bus->wqueue_size > 0)
3063 r = bus_kernel_try_close(bus);
3071 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3072 assert_return(bus, -EINVAL);
3073 assert_return(name, -EINVAL);
3074 assert_return(!bus_pid_changed(bus), -ECHILD);
3076 *name = bus->connection_name;