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/>.
39 #include "bus-internal.h"
40 #include "bus-message.h"
42 #include "bus-socket.h"
43 #include "bus-kernel.h"
44 #include "bus-control.h"
45 #include "bus-introspect.h"
46 #include "bus-signature.h"
48 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
50 static void bus_close_fds(sd_bus *b) {
54 close_nointr_nofail(b->input_fd);
56 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
57 close_nointr_nofail(b->output_fd);
59 b->input_fd = b->output_fd = -1;
62 static void bus_node_destroy(sd_bus *b, struct node *n) {
63 struct node_callback *c;
64 struct node_vtable *v;
65 struct node_enumerator *e;
73 bus_node_destroy(b, n->child);
75 while ((c = n->callbacks)) {
76 LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
80 while ((v = n->vtables)) {
81 LIST_REMOVE(struct node_vtable, vtables, n->vtables, v);
86 while ((e = n->enumerators)) {
87 LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, e);
92 LIST_REMOVE(struct node, siblings, n->parent->child, n);
94 assert_se(hashmap_remove(b->nodes, n->path) == n);
99 static void bus_free(sd_bus *b) {
100 struct filter_callback *f;
109 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
112 free(b->unique_name);
113 free(b->auth_buffer);
118 strv_free(b->exec_argv);
120 close_many(b->fds, b->n_fds);
123 for (i = 0; i < b->rqueue_size; i++)
124 sd_bus_message_unref(b->rqueue[i]);
127 for (i = 0; i < b->wqueue_size; i++)
128 sd_bus_message_unref(b->wqueue[i]);
131 hashmap_free_free(b->reply_callbacks);
132 prioq_free(b->reply_callbacks_prioq);
134 while ((f = b->filter_callbacks)) {
135 LIST_REMOVE(struct filter_callback, callbacks, b->filter_callbacks, f);
139 bus_match_free(&b->match_callbacks);
141 hashmap_free_free(b->vtable_methods);
142 hashmap_free_free(b->vtable_properties);
144 while ((n = hashmap_first(b->nodes)))
145 bus_node_destroy(b, n);
147 hashmap_free(b->nodes);
149 bus_kernel_flush_memfd(b);
151 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
156 int sd_bus_new(sd_bus **ret) {
166 r->n_ref = REFCNT_INIT;
167 r->input_fd = r->output_fd = -1;
168 r->message_version = 1;
169 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
170 r->original_pid = getpid();
172 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
174 /* We guarantee that wqueue always has space for at least one
176 r->wqueue = new(sd_bus_message*, 1);
186 int sd_bus_set_address(sd_bus *bus, const char *address) {
191 if (bus->state != BUS_UNSET)
195 if (bus_pid_changed(bus))
208 int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
211 if (bus->state != BUS_UNSET)
217 if (bus_pid_changed(bus))
220 bus->input_fd = input_fd;
221 bus->output_fd = output_fd;
225 int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
230 if (bus->state != BUS_UNSET)
234 if (strv_isempty(argv))
236 if (bus_pid_changed(bus))
249 free(bus->exec_path);
250 strv_free(bus->exec_argv);
258 int sd_bus_set_bus_client(sd_bus *bus, int b) {
261 if (bus->state != BUS_UNSET)
263 if (bus_pid_changed(bus))
266 bus->bus_client = !!b;
270 int sd_bus_negotiate_fds(sd_bus *bus, int b) {
273 if (bus->state != BUS_UNSET)
275 if (bus_pid_changed(bus))
278 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
282 int sd_bus_negotiate_attach_comm(sd_bus *bus, int b) {
285 if (bus->state != BUS_UNSET)
287 if (bus_pid_changed(bus))
290 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_COMM, b);
294 int sd_bus_negotiate_attach_exe(sd_bus *bus, int b) {
297 if (bus->state != BUS_UNSET)
299 if (bus_pid_changed(bus))
302 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_EXE, b);
306 int sd_bus_negotiate_attach_cmdline(sd_bus *bus, int b) {
309 if (bus->state != BUS_UNSET)
311 if (bus_pid_changed(bus))
314 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CMDLINE, b);
318 int sd_bus_negotiate_attach_cgroup(sd_bus *bus, int b) {
321 if (bus->state != BUS_UNSET)
323 if (bus_pid_changed(bus))
326 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CGROUP, b);
330 int sd_bus_negotiate_attach_caps(sd_bus *bus, int b) {
333 if (bus->state != BUS_UNSET)
335 if (bus_pid_changed(bus))
338 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CAPS, b);
342 int sd_bus_negotiate_attach_selinux_context(sd_bus *bus, int b) {
345 if (bus->state != BUS_UNSET)
347 if (bus_pid_changed(bus))
350 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_SECLABEL, b);
354 int sd_bus_negotiate_attach_audit(sd_bus *bus, int b) {
357 if (bus->state != BUS_UNSET)
359 if (bus_pid_changed(bus))
362 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_AUDIT, b);
366 int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
369 if (!b && !sd_id128_equal(server_id, SD_ID128_NULL))
371 if (bus->state != BUS_UNSET)
373 if (bus_pid_changed(bus))
376 bus->is_server = !!b;
377 bus->server_id = server_id;
381 int sd_bus_set_anonymous(sd_bus *bus, int b) {
384 if (bus->state != BUS_UNSET)
386 if (bus_pid_changed(bus))
389 bus->anonymous_auth = !!b;
393 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata) {
398 assert(bus->state == BUS_HELLO);
401 r = bus_message_to_errno(reply);
405 r = sd_bus_message_read(reply, "s", &s);
409 if (!service_name_is_valid(s) || s[0] != ':')
412 bus->unique_name = strdup(s);
413 if (!bus->unique_name)
416 bus->state = BUS_RUNNING;
421 static int bus_send_hello(sd_bus *bus) {
422 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
427 if (!bus->bus_client || bus->is_kernel)
430 r = sd_bus_message_new_method_call(
432 "org.freedesktop.DBus",
434 "org.freedesktop.DBus",
440 return sd_bus_send_with_reply(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
443 int bus_start_running(sd_bus *bus) {
446 if (bus->bus_client && !bus->is_kernel) {
447 bus->state = BUS_HELLO;
451 bus->state = BUS_RUNNING;
455 static int parse_address_key(const char **p, const char *key, char **value) {
466 if (strncmp(*p, key, l) != 0)
479 while (*a != ';' && *a != ',' && *a != 0) {
497 c = (char) ((x << 4) | y);
504 t = realloc(r, n + 2);
532 static void skip_address_key(const char **p) {
536 *p += strcspn(*p, ",");
542 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
543 _cleanup_free_ char *path = NULL, *abstract = NULL;
552 while (**p != 0 && **p != ';') {
553 r = parse_address_key(p, "guid", guid);
559 r = parse_address_key(p, "path", &path);
565 r = parse_address_key(p, "abstract", &abstract);
574 if (!path && !abstract)
577 if (path && abstract)
582 if (l > sizeof(b->sockaddr.un.sun_path))
585 b->sockaddr.un.sun_family = AF_UNIX;
586 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
587 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
588 } else if (abstract) {
589 l = strlen(abstract);
590 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
593 b->sockaddr.un.sun_family = AF_UNIX;
594 b->sockaddr.un.sun_path[0] = 0;
595 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
596 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
602 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
603 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
605 struct addrinfo *result, hints = {
606 .ai_socktype = SOCK_STREAM,
607 .ai_flags = AI_ADDRCONFIG,
615 while (**p != 0 && **p != ';') {
616 r = parse_address_key(p, "guid", guid);
622 r = parse_address_key(p, "host", &host);
628 r = parse_address_key(p, "port", &port);
634 r = parse_address_key(p, "family", &family);
647 if (streq(family, "ipv4"))
648 hints.ai_family = AF_INET;
649 else if (streq(family, "ipv6"))
650 hints.ai_family = AF_INET6;
655 r = getaddrinfo(host, port, &hints, &result);
659 return -EADDRNOTAVAIL;
661 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
662 b->sockaddr_size = result->ai_addrlen;
664 freeaddrinfo(result);
669 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
671 unsigned n_argv = 0, j;
680 while (**p != 0 && **p != ';') {
681 r = parse_address_key(p, "guid", guid);
687 r = parse_address_key(p, "path", &path);
693 if (startswith(*p, "argv")) {
697 ul = strtoul(*p + 4, (char**) p, 10);
698 if (errno > 0 || **p != '=' || ul > 256) {
708 x = realloc(argv, sizeof(char*) * (ul + 2));
714 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
720 r = parse_address_key(p, NULL, argv + ul);
735 /* Make sure there are no holes in the array, with the
736 * exception of argv[0] */
737 for (j = 1; j < n_argv; j++)
743 if (argv && argv[0] == NULL) {
744 argv[0] = strdup(path);
756 for (j = 0; j < n_argv; j++)
764 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
765 _cleanup_free_ char *path = NULL;
773 while (**p != 0 && **p != ';') {
774 r = parse_address_key(p, "guid", guid);
780 r = parse_address_key(p, "path", &path);
799 static void bus_reset_parsed_address(sd_bus *b) {
803 b->sockaddr_size = 0;
804 strv_free(b->exec_argv);
808 b->server_id = SD_ID128_NULL;
813 static int bus_parse_next_address(sd_bus *b) {
814 _cleanup_free_ char *guid = NULL;
822 if (b->address[b->address_index] == 0)
825 bus_reset_parsed_address(b);
827 a = b->address + b->address_index;
836 if (startswith(a, "unix:")) {
839 r = parse_unix_address(b, &a, &guid);
844 } else if (startswith(a, "tcp:")) {
847 r = parse_tcp_address(b, &a, &guid);
853 } else if (startswith(a, "unixexec:")) {
856 r = parse_exec_address(b, &a, &guid);
862 } else if (startswith(a, "kernel:")) {
865 r = parse_kernel_address(b, &a, &guid);
878 r = sd_id128_from_string(guid, &b->server_id);
883 b->address_index = a - b->address;
887 static int bus_start_address(sd_bus *b) {
895 if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
897 r = bus_socket_connect(b);
901 b->last_connect_error = -r;
903 } else if (b->exec_path) {
905 r = bus_socket_exec(b);
909 b->last_connect_error = -r;
910 } else if (b->kernel) {
912 r = bus_kernel_connect(b);
916 b->last_connect_error = -r;
919 r = bus_parse_next_address(b);
923 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
927 int bus_next_address(sd_bus *b) {
930 bus_reset_parsed_address(b);
931 return bus_start_address(b);
934 static int bus_start_fd(sd_bus *b) {
939 assert(b->input_fd >= 0);
940 assert(b->output_fd >= 0);
942 r = fd_nonblock(b->input_fd, true);
946 r = fd_cloexec(b->input_fd, true);
950 if (b->input_fd != b->output_fd) {
951 r = fd_nonblock(b->output_fd, true);
955 r = fd_cloexec(b->output_fd, true);
960 if (fstat(b->input_fd, &st) < 0)
963 if (S_ISCHR(b->input_fd))
964 return bus_kernel_take_fd(b);
966 return bus_socket_take_fd(b);
969 int sd_bus_start(sd_bus *bus) {
974 if (bus->state != BUS_UNSET)
976 if (bus_pid_changed(bus))
979 bus->state = BUS_OPENING;
981 if (bus->is_server && bus->bus_client)
984 if (bus->input_fd >= 0)
985 r = bus_start_fd(bus);
986 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel)
987 r = bus_start_address(bus);
994 return bus_send_hello(bus);
997 int sd_bus_open_system(sd_bus **ret) {
1009 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1011 r = sd_bus_set_address(b, e);
1015 b->sockaddr.un.sun_family = AF_UNIX;
1016 strncpy(b->sockaddr.un.sun_path, "/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
1017 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/dbus/system_bus_socket") - 1;
1020 b->bus_client = true;
1022 r = sd_bus_start(b);
1034 int sd_bus_open_user(sd_bus **ret) {
1047 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1049 r = sd_bus_set_address(b, e);
1053 e = secure_getenv("XDG_RUNTIME_DIR");
1060 if (l + 4 > sizeof(b->sockaddr.un.sun_path)) {
1065 b->sockaddr.un.sun_family = AF_UNIX;
1066 memcpy(mempcpy(b->sockaddr.un.sun_path, e, l), "/bus", 4);
1067 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l + 4;
1070 b->bus_client = true;
1072 r = sd_bus_start(b);
1084 void sd_bus_close(sd_bus *bus) {
1087 if (bus->state == BUS_CLOSED)
1089 if (bus_pid_changed(bus))
1092 bus->state = BUS_CLOSED;
1094 if (!bus->is_kernel)
1097 /* We'll leave the fd open in case this is a kernel bus, since
1098 * there might still be memblocks around that reference this
1099 * bus, and they might need to invoke the
1100 * KDBUS_CMD_MSG_RELEASE ioctl on the fd when they are
1104 sd_bus *sd_bus_ref(sd_bus *bus) {
1108 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1113 sd_bus *sd_bus_unref(sd_bus *bus) {
1117 if (REFCNT_DEC(bus->n_ref) <= 0)
1123 int sd_bus_is_open(sd_bus *bus) {
1126 if (bus_pid_changed(bus))
1129 return BUS_IS_OPEN(bus->state);
1132 int sd_bus_can_send(sd_bus *bus, char type) {
1137 if (bus->state == BUS_UNSET)
1139 if (bus_pid_changed(bus))
1142 if (type == SD_BUS_TYPE_UNIX_FD) {
1143 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1146 r = bus_ensure_running(bus);
1150 return bus->can_fds;
1153 return bus_type_is_valid(type);
1156 int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1163 if (bus_pid_changed(bus))
1166 r = bus_ensure_running(bus);
1170 *server_id = bus->server_id;
1174 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1177 if (m->header->version > b->message_version)
1183 return bus_message_seal(m, ++b->serial);
1186 static int dispatch_wqueue(sd_bus *bus) {
1190 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1192 while (bus->wqueue_size > 0) {
1195 r = bus_kernel_write_message(bus, bus->wqueue[0]);
1197 r = bus_socket_write_message(bus, bus->wqueue[0], &bus->windex);
1203 /* Didn't do anything this time */
1205 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1206 /* Fully written. Let's drop the entry from
1209 * This isn't particularly optimized, but
1210 * well, this is supposed to be our worst-case
1211 * buffer only, and the socket buffer is
1212 * supposed to be our primary buffer, and if
1213 * it got full, then all bets are off
1216 sd_bus_message_unref(bus->wqueue[0]);
1217 bus->wqueue_size --;
1218 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1228 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1229 sd_bus_message *z = NULL;
1234 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1236 if (bus->rqueue_size > 0) {
1237 /* Dispatch a queued message */
1239 *m = bus->rqueue[0];
1240 bus->rqueue_size --;
1241 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1245 /* Try to read a new message */
1248 r = bus_kernel_read_message(bus, &z);
1250 r = bus_socket_read_message(bus, &z);
1266 int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1271 if (!BUS_IS_OPEN(bus->state))
1275 if (bus_pid_changed(bus))
1279 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1286 /* If the serial number isn't kept, then we know that no reply
1288 if (!serial && !m->sealed)
1289 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1291 r = bus_seal_message(bus, m);
1295 /* If this is a reply and no reply was requested, then let's
1296 * suppress this, if we can */
1297 if (m->dont_send && !serial)
1300 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1304 r = bus_kernel_write_message(bus, m);
1306 r = bus_socket_write_message(bus, m, &idx);
1311 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1312 /* Wasn't fully written. So let's remember how
1313 * much was written. Note that the first entry
1314 * of the wqueue array is always allocated so
1315 * that we always can remember how much was
1317 bus->wqueue[0] = sd_bus_message_ref(m);
1318 bus->wqueue_size = 1;
1324 /* Just append it to the queue. */
1326 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1329 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1334 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1338 *serial = BUS_MESSAGE_SERIAL(m);
1343 static usec_t calc_elapse(uint64_t usec) {
1344 if (usec == (uint64_t) -1)
1348 usec = BUS_DEFAULT_TIMEOUT;
1350 return now(CLOCK_MONOTONIC) + usec;
1353 static int timeout_compare(const void *a, const void *b) {
1354 const struct reply_callback *x = a, *y = b;
1356 if (x->timeout != 0 && y->timeout == 0)
1359 if (x->timeout == 0 && y->timeout != 0)
1362 if (x->timeout < y->timeout)
1365 if (x->timeout > y->timeout)
1371 int sd_bus_send_with_reply(
1374 sd_bus_message_handler_t callback,
1379 struct reply_callback *c;
1384 if (!BUS_IS_OPEN(bus->state))
1390 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1392 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1394 if (bus_pid_changed(bus))
1397 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1401 if (usec != (uint64_t) -1) {
1402 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1407 r = bus_seal_message(bus, m);
1411 c = new0(struct reply_callback, 1);
1415 c->callback = callback;
1416 c->userdata = userdata;
1417 c->serial = BUS_MESSAGE_SERIAL(m);
1418 c->timeout = calc_elapse(usec);
1420 r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1426 if (c->timeout != 0) {
1427 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1430 sd_bus_send_with_reply_cancel(bus, c->serial);
1435 r = sd_bus_send(bus, m, serial);
1437 sd_bus_send_with_reply_cancel(bus, c->serial);
1444 int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
1445 struct reply_callback *c;
1451 if (bus_pid_changed(bus))
1454 c = hashmap_remove(bus->reply_callbacks, &serial);
1458 if (c->timeout != 0)
1459 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1465 int bus_ensure_running(sd_bus *bus) {
1470 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED)
1472 if (bus->state == BUS_RUNNING)
1476 r = sd_bus_process(bus, NULL);
1479 if (bus->state == BUS_RUNNING)
1484 r = sd_bus_wait(bus, (uint64_t) -1);
1490 int sd_bus_send_with_reply_and_block(
1494 sd_bus_error *error,
1495 sd_bus_message **reply) {
1504 if (!BUS_IS_OPEN(bus->state))
1508 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1510 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1512 if (bus_error_is_dirty(error))
1514 if (bus_pid_changed(bus))
1517 r = bus_ensure_running(bus);
1521 r = sd_bus_send(bus, m, &serial);
1525 timeout = calc_elapse(usec);
1529 sd_bus_message *incoming = NULL;
1534 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1537 /* Make sure there's room for queuing this
1538 * locally, before we read the message */
1540 q = realloc(bus->rqueue, (bus->rqueue_size + 1) * sizeof(sd_bus_message*));
1549 r = bus_kernel_read_message(bus, &incoming);
1551 r = bus_socket_read_message(bus, &incoming);
1556 if (incoming->reply_serial == serial) {
1557 /* Found a match! */
1559 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_RETURN) {
1564 sd_bus_message_unref(incoming);
1569 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR) {
1572 r = sd_bus_error_copy(error, &incoming->error);
1574 sd_bus_message_unref(incoming);
1578 k = bus_error_to_errno(&incoming->error);
1579 sd_bus_message_unref(incoming);
1583 sd_bus_message_unref(incoming);
1587 /* There's already guaranteed to be room for
1588 * this, so need to resize things here */
1589 bus->rqueue[bus->rqueue_size ++] = incoming;
1592 /* Try to read more, right-away */
1601 n = now(CLOCK_MONOTONIC);
1607 left = (uint64_t) -1;
1609 r = bus_poll(bus, true, left);
1613 r = dispatch_wqueue(bus);
1619 int sd_bus_get_fd(sd_bus *bus) {
1622 if (!BUS_IS_OPEN(bus->state))
1624 if (bus->input_fd != bus->output_fd)
1626 if (bus_pid_changed(bus))
1629 return bus->input_fd;
1632 int sd_bus_get_events(sd_bus *bus) {
1637 if (!BUS_IS_OPEN(bus->state))
1639 if (bus_pid_changed(bus))
1642 if (bus->state == BUS_OPENING)
1644 else if (bus->state == BUS_AUTHENTICATING) {
1646 if (bus_socket_auth_needs_write(bus))
1651 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1652 if (bus->rqueue_size <= 0)
1654 if (bus->wqueue_size > 0)
1661 int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1662 struct reply_callback *c;
1668 if (!BUS_IS_OPEN(bus->state))
1670 if (bus_pid_changed(bus))
1673 if (bus->state == BUS_AUTHENTICATING) {
1674 *timeout_usec = bus->auth_timeout;
1678 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1679 *timeout_usec = (uint64_t) -1;
1683 c = prioq_peek(bus->reply_callbacks_prioq);
1685 *timeout_usec = (uint64_t) -1;
1689 *timeout_usec = c->timeout;
1693 static int process_timeout(sd_bus *bus) {
1694 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1695 struct reply_callback *c;
1701 c = prioq_peek(bus->reply_callbacks_prioq);
1705 n = now(CLOCK_MONOTONIC);
1709 r = bus_message_new_synthetic_error(
1712 &SD_BUS_ERROR_MAKE("org.freedesktop.DBus.Error.Timeout", "Timed out"),
1717 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1718 hashmap_remove(bus->reply_callbacks, &c->serial);
1720 r = c->callback(bus, m, c->userdata);
1723 return r < 0 ? r : 1;
1726 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1730 if (bus->state != BUS_HELLO)
1733 /* Let's make sure the first message on the bus is the HELLO
1734 * reply. But note that we don't actually parse the message
1735 * here (we leave that to the usual handling), we just verify
1736 * we don't let any earlier msg through. */
1738 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1739 m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1742 if (m->reply_serial != bus->hello_serial)
1748 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1749 struct reply_callback *c;
1755 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1756 m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1759 c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1763 if (c->timeout != 0)
1764 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1766 r = sd_bus_message_rewind(m, true);
1770 r = c->callback(bus, m, c->userdata);
1776 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1777 struct filter_callback *l;
1784 bus->filter_callbacks_modified = false;
1786 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1788 if (bus->filter_callbacks_modified)
1791 /* Don't run this more than once per iteration */
1792 if (l->last_iteration == bus->iteration_counter)
1795 l->last_iteration = bus->iteration_counter;
1797 r = sd_bus_message_rewind(m, true);
1801 r = l->callback(bus, m, l->userdata);
1807 } while (bus->filter_callbacks_modified);
1812 static int process_match(sd_bus *bus, sd_bus_message *m) {
1819 bus->match_callbacks_modified = false;
1821 r = bus_match_run(bus, &bus->match_callbacks, m);
1825 } while (bus->match_callbacks_modified);
1830 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1831 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1837 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1840 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
1843 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1846 if (streq_ptr(m->member, "Ping"))
1847 r = sd_bus_message_new_method_return(bus, m, &reply);
1848 else if (streq_ptr(m->member, "GetMachineId")) {
1852 r = sd_id128_get_machine(&id);
1856 r = sd_bus_message_new_method_return(bus, m, &reply);
1860 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
1862 r = sd_bus_message_new_method_errorf(
1864 "org.freedesktop.DBus.Error.UnknownMethod",
1865 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
1871 r = sd_bus_send(bus, reply, NULL);
1878 static int node_vtable_get_userdata(
1881 struct node_vtable *c,
1893 r = c->find(bus, path, c->interface, &u, u);
1904 static void *vtable_property_convert_userdata(const sd_bus_vtable *p, void *u) {
1907 return (uint8_t*) u + p->property.offset;
1910 static int vtable_property_get_userdata(
1913 struct vtable_member *p,
1924 r = node_vtable_get_userdata(bus, path, p->parent, &u);
1928 *userdata = vtable_property_convert_userdata(p->vtable, u);
1932 static int add_enumerated_to_set(sd_bus *bus, const char *prefix, struct node_enumerator *first, Set *s) {
1933 struct node_enumerator *c;
1940 LIST_FOREACH(enumerators, c, first) {
1941 char **children = NULL, **k;
1943 r = c->callback(bus, prefix, &children, c->userdata);
1947 STRV_FOREACH(k, children) {
1953 if (!object_path_is_valid(*k) && object_path_startswith(*k, prefix)) {
1959 r = set_consume(s, *k);
1970 static int add_subtree_to_set(sd_bus *bus, const char *prefix, struct node *n, Set *s) {
1979 r = add_enumerated_to_set(bus, prefix, n->enumerators, s);
1983 LIST_FOREACH(siblings, i, n->child) {
1986 t = strdup(i->path);
1990 r = set_consume(s, t);
1991 if (r < 0 && r != -EEXIST)
1994 r = add_subtree_to_set(bus, prefix, i, s);
2002 static int get_child_nodes(sd_bus *bus, const char *prefix, struct node *n, Set **_s) {
2010 s = set_new(string_hash_func, string_compare_func);
2014 r = add_subtree_to_set(bus, prefix, n, s);
2024 static int node_callbacks_run(
2027 struct node_callback *first,
2028 bool require_fallback,
2029 bool *found_object) {
2031 struct node_callback *c;
2036 assert(found_object);
2038 LIST_FOREACH(callbacks, c, first) {
2039 if (require_fallback && !c->is_fallback)
2042 *found_object = true;
2044 if (c->last_iteration == bus->iteration_counter)
2047 r = sd_bus_message_rewind(m, true);
2051 r = c->callback(bus, m, c->userdata);
2059 static int method_callbacks_run(
2062 struct vtable_member *c,
2063 bool require_fallback,
2064 bool *found_object) {
2066 const char *signature;
2073 assert(found_object);
2075 if (require_fallback && !c->parent->is_fallback)
2078 r = node_vtable_get_userdata(bus, m->path, c->parent, &u);
2082 *found_object = true;
2084 r = sd_bus_message_rewind(m, true);
2088 r = sd_bus_message_get_signature(m, true, &signature);
2092 if (!streq(c->vtable->method.signature, signature)) {
2093 r = sd_bus_reply_method_errorf(bus, m,
2094 "org.freedesktop.DBus.Error.InvalidArgs",
2095 "Invalid arguments '%s' to call %s:%s, expecting '%s'.",
2096 signature, c->interface, c->member, c->vtable->method.signature);
2103 return c->vtable->method.handler(bus, m, u);
2106 static int invoke_property_get(
2108 const sd_bus_vtable *v,
2110 const char *interface,
2111 const char *property,
2113 sd_bus_error *error,
2122 if (v->property.get)
2123 return v->property.get(bus, path, interface, property, m, error, userdata);
2125 /* Automatic handling if no callback is defined. */
2127 switch (v->property.signature[0]) {
2129 case SD_BUS_TYPE_STRING:
2130 case SD_BUS_TYPE_OBJECT_PATH:
2131 case SD_BUS_TYPE_SIGNATURE:
2132 p = *(char**) userdata;
2139 r = sd_bus_message_append_basic(m, v->property.signature[0], p);
2146 static int property_get_set_callbacks_run(
2149 struct vtable_member *c,
2150 bool require_fallback,
2152 bool *found_object) {
2154 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2155 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2161 assert(found_object);
2163 if (require_fallback && !c->parent->is_fallback)
2166 r = vtable_property_get_userdata(bus, m->path, c, &u);
2170 *found_object = true;
2172 r = sd_bus_message_new_method_return(bus, m, &reply);
2176 c->last_iteration = bus->iteration_counter;
2179 r = sd_bus_message_open_container(reply, 'v', c->vtable->property.signature);
2183 r = invoke_property_get(bus, c->vtable, m->path, c->interface, c->member, reply, &error, u);
2187 if (sd_bus_error_is_set(&error)) {
2188 r = sd_bus_reply_method_error(bus, m, &error);
2195 r = sd_bus_message_close_container(reply);
2200 if (c->vtable->type != _SD_BUS_VTABLE_WRITABLE_PROPERTY)
2201 sd_bus_error_setf(&error, "org.freedesktop.DBus.Error.PropertyReadOnly", "Property '%s' is not writable.", c->member);
2203 r = sd_bus_message_enter_container(m, 'v', c->vtable->property.signature);
2207 if (c->vtable->property.set) {
2208 r = c->vtable->property.set(bus, m->path, c->interface, c->member, m, &error, u);
2212 assert_not_reached("automatic properties not supported yet");
2215 if (sd_bus_error_is_set(&error)) {
2216 r = sd_bus_reply_method_error(bus, m, &error);
2223 r = sd_bus_message_exit_container(m);
2228 r = sd_bus_send(bus, reply, NULL);
2235 static int vtable_append_all_properties(
2237 sd_bus_message *reply,
2239 struct node_vtable *c,
2241 sd_bus_error *error) {
2243 const sd_bus_vtable *v;
2250 for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
2251 if (v->type != _SD_BUS_VTABLE_PROPERTY && v->type != _SD_BUS_VTABLE_WRITABLE_PROPERTY)
2254 r = sd_bus_message_open_container(reply, 'e', "sv");
2258 r = sd_bus_message_append(reply, "s", c->interface);
2262 r = sd_bus_message_open_container(reply, 'v', v->property.signature);
2266 r = invoke_property_get(bus, v, path, c->interface, v->property.member, reply, error, vtable_property_convert_userdata(v, userdata));
2270 if (sd_bus_error_is_set(error))
2273 r = sd_bus_message_close_container(reply);
2277 r = sd_bus_message_close_container(reply);
2285 static int property_get_all_callbacks_run(
2288 struct node_vtable *first,
2289 bool require_fallback,
2291 bool *found_object) {
2293 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2294 struct node_vtable *c;
2295 bool found_interface = false;
2300 assert(found_object);
2302 r = sd_bus_message_new_method_return(bus, m, &reply);
2306 r = sd_bus_message_open_container(reply, 'a', "{sv}");
2310 LIST_FOREACH(vtables, c, first) {
2311 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2314 if (require_fallback && !c->is_fallback)
2317 r = node_vtable_get_userdata(bus, m->path, c, &u);
2323 *found_object = true;
2325 if (iface && !streq(c->interface, iface))
2327 found_interface = true;
2329 c->last_iteration = bus->iteration_counter;
2331 r = vtable_append_all_properties(bus, reply, m->path, c, u, &error);
2335 if (sd_bus_error_is_set(&error)) {
2336 r = sd_bus_reply_method_error(bus, m, &error);
2344 if (!found_interface) {
2345 r = sd_bus_reply_method_errorf(
2347 "org.freedesktop.DBus.Error.UnknownInterface",
2348 "Unknown interface '%s'.", iface);
2355 r = sd_bus_message_close_container(reply);
2359 r = sd_bus_send(bus, reply, NULL);
2366 static bool bus_node_with_object_manager(sd_bus *bus, struct node *n) {
2369 if (n->object_manager)
2373 return bus_node_with_object_manager(bus, n->parent);
2378 static bool bus_node_exists(sd_bus *bus, struct node *n, const char *path, bool require_fallback) {
2379 struct node_vtable *c;
2380 struct node_callback *k;
2385 /* Tests if there's anything attached directly to this node
2386 * for the specified path */
2388 LIST_FOREACH(callbacks, k, n->callbacks) {
2389 if (require_fallback && !k->is_fallback)
2395 LIST_FOREACH(vtables, c, n->vtables) {
2397 if (require_fallback && !c->is_fallback)
2400 if (node_vtable_get_userdata(bus, path, c, NULL) > 0)
2404 return !require_fallback && (n->enumerators || n->object_manager);
2407 static int process_introspect(
2411 bool require_fallback,
2412 bool *found_object) {
2414 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2415 _cleanup_set_free_free_ Set *s = NULL;
2416 struct introspect intro;
2417 struct node_vtable *c;
2424 assert(found_object);
2426 r = get_child_nodes(bus, m->path, n, &s);
2430 r = introspect_begin(&intro);
2434 r = introspect_write_default_interfaces(&intro, bus_node_with_object_manager(bus, n));
2438 empty = set_isempty(s);
2440 LIST_FOREACH(vtables, c, n->vtables) {
2441 if (require_fallback && !c->is_fallback)
2444 r = node_vtable_get_userdata(bus, m->path, c, NULL);
2452 r = introspect_write_interface(&intro, c->interface, c->vtable);
2458 /* Nothing?, let's see if we exist at all, and if not
2459 * refuse to do anything */
2460 r = bus_node_exists(bus, n, m->path, require_fallback);
2468 *found_object = true;
2470 r = introspect_write_child_nodes(&intro, s, m->path);
2474 r = introspect_finish(&intro, bus, m, &reply);
2478 r = sd_bus_send(bus, reply, NULL);
2485 introspect_free(&intro);
2489 static int object_manager_serialize_vtable(
2491 sd_bus_message *reply,
2493 struct node_vtable *c,
2494 sd_bus_error *error) {
2505 r = node_vtable_get_userdata(bus, path, c, &u);
2509 r = sd_bus_message_open_container(reply, 'e', "sa{sv}");
2513 r = sd_bus_message_append(reply, "s", c->interface);
2517 r = sd_bus_message_open_container(reply, 'a', "{sv}");
2521 r = vtable_append_all_properties(bus, reply, path, c, u, error);
2525 r = sd_bus_message_close_container(reply);
2529 r = sd_bus_message_close_container(reply);
2536 static int object_manager_serialize_path(
2538 sd_bus_message *reply,
2541 bool require_fallback,
2542 sd_bus_error *error) {
2544 struct node_vtable *i;
2554 n = hashmap_get(bus->nodes, prefix);
2558 r = sd_bus_message_open_container(reply, 'e', "oa{sa{sv}}");
2562 r = sd_bus_message_append(reply, "o", path);
2566 r = sd_bus_message_open_container(reply, 'a', "{sa{sv}}");
2570 LIST_FOREACH(vtables, i, n->vtables) {
2572 if (require_fallback && !i->is_fallback)
2575 r = object_manager_serialize_vtable(bus, reply, path, i, error);
2578 if (sd_bus_error_is_set(error))
2582 r = sd_bus_message_close_container(reply);
2586 r = sd_bus_message_close_container(reply);
2593 static int object_manager_serialize_path_and_fallbacks(
2595 sd_bus_message *reply,
2597 sd_bus_error *error) {
2607 /* First, add all vtables registered for this path */
2608 r = object_manager_serialize_path(bus, reply, path, path, false, error);
2611 if (sd_bus_error_is_set(error))
2614 /* Second, add fallback vtables registered for any of the prefixes */
2623 e = strrchr(p, '/');
2629 r = object_manager_serialize_path(bus, reply, p, path, true, error);
2633 if (sd_bus_error_is_set(error))
2641 static int process_get_managed_objects(
2645 bool require_fallback,
2646 bool *found_object) {
2648 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2649 _cleanup_set_free_free_ Set *s = NULL;
2656 assert(found_object);
2658 if (!bus_node_with_object_manager(bus, n))
2661 r = get_child_nodes(bus, m->path, n, &s);
2665 r = sd_bus_message_new_method_return(bus, m, &reply);
2669 r = sd_bus_message_open_container(reply, 'a', "{oa{sa{sv}}}");
2673 empty = set_isempty(s);
2675 struct node_vtable *c;
2677 /* Hmm, so we have no children? Then let's check
2678 * whether we exist at all, i.e. whether at least one
2681 LIST_FOREACH(vtables, c, n->vtables) {
2683 if (require_fallback && !c->is_fallback)
2701 SET_FOREACH(path, s, i) {
2702 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2704 r = object_manager_serialize_path_and_fallbacks(bus, reply, path, &error);
2708 if (sd_bus_error_is_set(&error)) {
2709 r = sd_bus_reply_method_error(bus, m, &error);
2718 r = sd_bus_message_close_container(reply);
2722 r = sd_bus_send(bus, reply, NULL);
2729 static int object_find_and_run(
2733 bool require_fallback,
2734 bool *found_object) {
2737 struct vtable_member vtable_key, *v;
2743 assert(found_object);
2745 n = hashmap_get(bus->nodes, p);
2749 /* First, try object callbacks */
2750 r = node_callbacks_run(bus, m, n->callbacks, require_fallback, found_object);
2754 if (!m->interface || !m->member)
2757 /* Then, look for a known method */
2758 vtable_key.path = (char*) p;
2759 vtable_key.interface = m->interface;
2760 vtable_key.member = m->member;
2762 v = hashmap_get(bus->vtable_methods, &vtable_key);
2764 r = method_callbacks_run(bus, m, v, require_fallback, found_object);
2769 /* Then, look for a known property */
2770 if (streq(m->interface, "org.freedesktop.DBus.Properties")) {
2773 get = streq(m->member, "Get");
2775 if (get || streq(m->member, "Set")) {
2777 r = sd_bus_message_rewind(m, true);
2781 vtable_key.path = (char*) p;
2783 r = sd_bus_message_read(m, "ss", &vtable_key.interface, &vtable_key.member);
2787 v = hashmap_get(bus->vtable_properties, &vtable_key);
2789 r = property_get_set_callbacks_run(bus, m, v, require_fallback, get, found_object);
2794 } else if (streq(m->member, "GetAll")) {
2797 r = sd_bus_message_rewind(m, true);
2801 r = sd_bus_message_read(m, "s", &iface);
2808 r = property_get_all_callbacks_run(bus, m, n->vtables, require_fallback, iface, found_object);
2813 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
2815 r = process_introspect(bus, m, n, require_fallback, found_object);
2819 } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.ObjectManager", "GetManagedObjects")) {
2821 r = process_get_managed_objects(bus, m, n, require_fallback, found_object);
2826 if (!*found_object) {
2827 r = bus_node_exists(bus, n, m->path, require_fallback);
2832 *found_object = true;
2838 static int process_object(sd_bus *bus, sd_bus_message *m) {
2841 bool found_object = false;
2846 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
2852 if (hashmap_isempty(bus->nodes))
2855 pl = strlen(m->path);
2859 bus->nodes_modified = false;
2861 r = object_find_and_run(bus, m, m->path, false, &found_object);
2865 /* Look for fallback prefixes */
2873 if (bus->nodes_modified)
2876 e = strrchr(p, '/');
2883 r = object_find_and_run(bus, m, p, true, &found_object);
2888 } while (bus->nodes_modified);
2893 if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get") ||
2894 sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Set"))
2895 r = sd_bus_reply_method_errorf(
2897 "org.freedesktop.DBus.Error.UnknownProperty",
2898 "Unknown property or interface.");
2900 r = sd_bus_reply_method_errorf(
2902 "org.freedesktop.DBus.Error.UnknownMethod",
2903 "Unknown method '%s' or interface '%s'.", m->member, m->interface);
2911 static int process_message(sd_bus *bus, sd_bus_message *m) {
2917 bus->iteration_counter++;
2919 r = process_hello(bus, m);
2923 r = process_reply(bus, m);
2927 r = process_filter(bus, m);
2931 r = process_match(bus, m);
2935 r = process_builtin(bus, m);
2939 return process_object(bus, m);
2942 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2943 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2947 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2949 r = process_timeout(bus);
2953 r = dispatch_wqueue(bus);
2957 r = dispatch_rqueue(bus, &m);
2963 r = process_message(bus, m);
2968 r = sd_bus_message_rewind(m, true);
2977 if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL) {
2979 r = sd_bus_reply_method_errorf(
2981 "org.freedesktop.DBus.Error.UnknownObject",
2982 "Unknown object '%s'.", m->path);
2996 int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2999 /* Returns 0 when we didn't do anything. This should cause the
3000 * caller to invoke sd_bus_wait() before returning the next
3001 * time. Returns > 0 when we did something, which possibly
3002 * means *ret is filled in with an unprocessed message. */
3006 if (bus_pid_changed(bus))
3009 /* We don't allow recursively invoking sd_bus_process(). */
3010 if (bus->processing)
3013 switch (bus->state) {
3020 r = bus_socket_process_opening(bus);
3027 case BUS_AUTHENTICATING:
3029 r = bus_socket_process_authenticating(bus);
3039 bus->processing = true;
3040 r = process_running(bus, ret);
3041 bus->processing = false;
3046 assert_not_reached("Unknown state");
3049 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
3050 struct pollfd p[2] = {};
3057 if (!BUS_IS_OPEN(bus->state))
3060 e = sd_bus_get_events(bus);
3067 r = sd_bus_get_timeout(bus, &until);
3074 nw = now(CLOCK_MONOTONIC);
3075 m = until > nw ? until - nw : 0;
3078 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
3081 p[0].fd = bus->input_fd;
3082 if (bus->output_fd == bus->input_fd) {
3086 p[0].events = e & POLLIN;
3087 p[1].fd = bus->output_fd;
3088 p[1].events = e & POLLOUT;
3092 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
3096 return r > 0 ? 1 : 0;
3099 int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
3103 if (!BUS_IS_OPEN(bus->state))
3105 if (bus_pid_changed(bus))
3108 if (bus->rqueue_size > 0)
3111 return bus_poll(bus, false, timeout_usec);
3114 int sd_bus_flush(sd_bus *bus) {
3119 if (!BUS_IS_OPEN(bus->state))
3121 if (bus_pid_changed(bus))
3124 r = bus_ensure_running(bus);
3128 if (bus->wqueue_size <= 0)
3132 r = dispatch_wqueue(bus);
3136 if (bus->wqueue_size <= 0)
3139 r = bus_poll(bus, false, (uint64_t) -1);
3145 int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
3146 struct filter_callback *f;
3152 if (bus_pid_changed(bus))
3155 f = new0(struct filter_callback, 1);
3158 f->callback = callback;
3159 f->userdata = userdata;
3161 bus->filter_callbacks_modified = true;
3162 LIST_PREPEND(struct filter_callback, callbacks, bus->filter_callbacks, f);
3166 int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
3167 struct filter_callback *f;
3173 if (bus_pid_changed(bus))
3176 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
3177 if (f->callback == callback && f->userdata == userdata) {
3178 bus->filter_callbacks_modified = true;
3179 LIST_REMOVE(struct filter_callback, callbacks, bus->filter_callbacks, f);
3188 static struct node *bus_node_allocate(sd_bus *bus, const char *path) {
3189 struct node *n, *parent;
3196 assert(path[0] == '/');
3198 n = hashmap_get(bus->nodes, path);
3202 r = hashmap_ensure_allocated(&bus->nodes, string_hash_func, string_compare_func);
3210 if (streq(path, "/"))
3213 e = strrchr(path, '/');
3216 p = strndupa(path, MAX(1, path - e));
3218 parent = bus_node_allocate(bus, p);
3225 n = new0(struct node, 1);
3232 r = hashmap_put(bus->nodes, s, n);
3240 LIST_PREPEND(struct node, siblings, parent->child, n);
3245 static void bus_node_gc(sd_bus *b, struct node *n) {
3258 assert(hashmap_remove(b->nodes, n->path) == n);
3261 LIST_REMOVE(struct node, siblings, n->parent->child, n);
3264 bus_node_gc(b, n->parent);
3268 static int bus_add_object(
3272 sd_bus_message_handler_t callback,
3275 struct node_callback *c;
3281 if (!object_path_is_valid(path))
3285 if (bus_pid_changed(b))
3288 n = bus_node_allocate(b, path);
3292 c = new0(struct node_callback, 1);
3299 c->callback = callback;
3300 c->userdata = userdata;
3301 c->is_fallback = fallback;
3303 LIST_PREPEND(struct node_callback, callbacks, n->callbacks, c);
3312 static int bus_remove_object(
3316 sd_bus_message_handler_t callback,
3319 struct node_callback *c;
3324 if (!object_path_is_valid(path))
3328 if (bus_pid_changed(bus))
3331 n = hashmap_get(bus->nodes, path);
3335 LIST_FOREACH(callbacks, c, n->callbacks)
3336 if (c->callback == callback && c->userdata == userdata && c->is_fallback == fallback)
3341 LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
3344 bus_node_gc(bus, n);
3349 int sd_bus_add_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
3350 return bus_add_object(bus, false, path, callback, userdata);
3353 int sd_bus_remove_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
3354 return bus_remove_object(bus, false, path, callback, userdata);
3357 int sd_bus_add_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
3358 return bus_add_object(bus, true, prefix, callback, userdata);
3361 int sd_bus_remove_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
3362 return bus_remove_object(bus, true, prefix, callback, userdata);
3365 int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
3366 struct bus_match_component *components = NULL;
3367 unsigned n_components = 0;
3368 uint64_t cookie = 0;
3375 if (bus_pid_changed(bus))
3378 r = bus_match_parse(match, &components, &n_components);
3382 if (bus->bus_client) {
3383 cookie = ++bus->match_cookie;
3385 r = bus_add_match_internal(bus, match, components, n_components, cookie);
3390 bus->match_callbacks_modified = true;
3391 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
3393 if (bus->bus_client)
3394 bus_remove_match_internal(bus, match, cookie);
3398 bus_match_parse_free(components, n_components);
3402 int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
3403 struct bus_match_component *components = NULL;
3404 unsigned n_components = 0;
3406 uint64_t cookie = 0;
3412 if (bus_pid_changed(bus))
3415 r = bus_match_parse(match, &components, &n_components);
3419 bus->match_callbacks_modified = true;
3420 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
3422 if (bus->bus_client)
3423 q = bus_remove_match_internal(bus, match, cookie);
3425 bus_match_parse_free(components, n_components);
3427 return r < 0 ? r : q;
3430 int sd_bus_emit_signal(
3433 const char *interface,
3435 const char *types, ...) {
3437 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3442 if (!BUS_IS_OPEN(bus->state))
3444 if (bus_pid_changed(bus))
3447 r = sd_bus_message_new_signal(bus, path, interface, member, &m);
3451 if (!isempty(types)) {
3454 va_start(ap, types);
3455 r = bus_message_append_ap(m, types, ap);
3461 return sd_bus_send(bus, m, NULL);
3464 int sd_bus_call_method(
3466 const char *destination,
3468 const char *interface,
3470 sd_bus_error *error,
3471 sd_bus_message **reply,
3472 const char *types, ...) {
3474 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3480 if (!BUS_IS_OPEN(bus->state))
3482 if (bus_pid_changed(bus))
3485 r = sd_bus_message_new_method_call(bus, destination, path, interface, member, &m);
3489 if (!isempty(types)) {
3492 va_start(ap, types);
3493 r = bus_message_append_ap(m, types, ap);
3499 return sd_bus_send_with_reply_and_block(bus, m, 0, error, reply);
3502 int sd_bus_reply_method_return(
3504 sd_bus_message *call,
3505 const char *types, ...) {
3507 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3516 if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
3518 if (!BUS_IS_OPEN(bus->state))
3520 if (bus_pid_changed(bus))
3523 if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
3526 r = sd_bus_message_new_method_return(bus, call, &m);
3530 if (!isempty(types)) {
3533 va_start(ap, types);
3534 r = bus_message_append_ap(m, types, ap);
3540 return sd_bus_send(bus, m, NULL);
3543 int sd_bus_reply_method_error(
3545 sd_bus_message *call,
3546 const sd_bus_error *e) {
3548 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3557 if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
3559 if (!sd_bus_error_is_set(e))
3561 if (!BUS_IS_OPEN(bus->state))
3563 if (bus_pid_changed(bus))
3566 if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
3569 r = sd_bus_message_new_method_error(bus, call, e, &m);
3573 return sd_bus_send(bus, m, NULL);
3576 int sd_bus_reply_method_errorf(
3578 sd_bus_message *call,
3583 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
3593 va_start(ap, format);
3594 r = vasprintf(&m, format, ap);
3605 error.need_free = true;
3607 return sd_bus_reply_method_error(bus, call, &error);
3610 bool bus_pid_changed(sd_bus *bus) {
3613 /* We don't support people creating a bus connection and
3614 * keeping it around over a fork(). Let's complain. */
3616 return bus->original_pid != getpid();
3619 static void free_node_vtable(sd_bus *bus, struct node_vtable *w) {
3625 if (w->interface && w->node && w->vtable) {
3626 const sd_bus_vtable *v;
3628 for (v = w->vtable; v->type != _SD_BUS_VTABLE_END; v++) {
3629 struct vtable_member *x = NULL;
3633 case _SD_BUS_VTABLE_METHOD: {
3634 struct vtable_member key;
3636 key.path = w->node->path;
3637 key.interface = w->interface;
3638 key.member = v->method.member;
3640 x = hashmap_remove(bus->vtable_methods, &key);
3644 case _SD_BUS_VTABLE_PROPERTY:
3645 case _SD_BUS_VTABLE_WRITABLE_PROPERTY: {
3646 struct vtable_member key;
3648 key.path = w->node->path;
3649 key.interface = w->interface;
3650 key.member = v->property.member;
3651 x = hashmap_remove(bus->vtable_properties, &key);
3663 static unsigned vtable_member_hash_func(const void *a) {
3664 const struct vtable_member *m = a;
3667 string_hash_func(m->path) ^
3668 string_hash_func(m->interface) ^
3669 string_hash_func(m->member);
3672 static int vtable_member_compare_func(const void *a, const void *b) {
3673 const struct vtable_member *x = a, *y = b;
3676 r = strcmp(x->path, y->path);
3680 r = strcmp(x->interface, y->interface);
3684 return strcmp(x->member, y->member);
3687 static int add_object_vtable_internal(
3690 const char *interface,
3691 const sd_bus_vtable *vtable,
3693 sd_bus_object_find_t find,
3696 struct node_vtable *c = NULL, *i;
3697 const sd_bus_vtable *v;
3703 if (!object_path_is_valid(path))
3705 if (!interface_name_is_valid(interface))
3707 if (!vtable || vtable[0].type != _SD_BUS_VTABLE_START || vtable[0].start.element_size != sizeof(struct sd_bus_vtable))
3709 if (bus_pid_changed(bus))
3712 r = hashmap_ensure_allocated(&bus->vtable_methods, vtable_member_hash_func, vtable_member_compare_func);
3716 r = hashmap_ensure_allocated(&bus->vtable_properties, vtable_member_hash_func, vtable_member_compare_func);
3720 n = bus_node_allocate(bus, path);
3724 LIST_FOREACH(vtables, i, n->vtables) {
3725 if (streq(i->interface, interface)) {
3730 if (i->is_fallback != fallback) {
3736 c = new0(struct node_vtable, 1);
3743 c->is_fallback = fallback;
3745 c->userdata = userdata;
3748 c->interface = strdup(interface);
3749 if (!c->interface) {
3754 for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
3758 case _SD_BUS_VTABLE_METHOD: {
3759 struct vtable_member *m;
3761 if (!member_name_is_valid(v->method.member) ||
3762 !signature_is_valid(v->method.signature, false) ||
3763 !signature_is_valid(v->method.result, false) ||
3764 !v->method.handler ||
3765 v->flags & (SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE|SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY)) {
3770 m = new0(struct vtable_member, 1);
3778 m->interface = c->interface;
3779 m->member = v->method.member;
3782 r = hashmap_put(bus->vtable_methods, m, m);
3791 case _SD_BUS_VTABLE_PROPERTY:
3792 case _SD_BUS_VTABLE_WRITABLE_PROPERTY: {
3793 struct vtable_member *m;
3795 if (!member_name_is_valid(v->property.member) ||
3796 !signature_is_single(v->property.signature, false) ||
3797 !(v->property.get || bus_type_is_basic(v->property.signature[0])) ||
3798 v->flags & SD_BUS_VTABLE_METHOD_NO_REPLY ||
3799 (v->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY && !(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))) {
3805 m = new0(struct vtable_member, 1);
3813 m->interface = c->interface;
3814 m->member = v->property.member;
3817 r = hashmap_put(bus->vtable_properties, m, m);
3826 case _SD_BUS_VTABLE_SIGNAL:
3828 if (!member_name_is_valid(v->signal.member) ||
3829 !signature_is_single(v->signal.signature, false)) {
3842 LIST_PREPEND(struct node_vtable, vtables, n->vtables, c);
3847 free_node_vtable(bus, c);
3849 bus_node_gc(bus, n);
3853 static int remove_object_vtable_internal(
3856 const char *interface,
3859 struct node_vtable *c;
3864 if (!object_path_is_valid(path))
3866 if (!interface_name_is_valid(interface))
3868 if (bus_pid_changed(bus))
3871 n = hashmap_get(bus->nodes, path);
3875 LIST_FOREACH(vtables, c, n->vtables)
3876 if (streq(c->interface, interface) && c->is_fallback == fallback)
3882 LIST_REMOVE(struct node_vtable, vtables, n->vtables, c);
3884 free_node_vtable(bus, c);
3888 int sd_bus_add_object_vtable(
3891 const char *interface,
3892 const sd_bus_vtable *vtable,
3895 return add_object_vtable_internal(bus, path, interface, vtable, false, NULL, userdata);
3898 int sd_bus_remove_object_vtable(
3901 const char *interface) {
3903 return remove_object_vtable_internal(bus, path, interface, false);
3906 int sd_bus_add_fallback_vtable(
3909 const char *interface,
3910 const sd_bus_vtable *vtable,
3911 sd_bus_object_find_t find,
3914 return add_object_vtable_internal(bus, path, interface, vtable, true, find, userdata);
3917 int sd_bus_remove_fallback_vtable(
3920 const char *interface) {
3922 return remove_object_vtable_internal(bus, path, interface, true);
3925 int sd_bus_add_node_enumerator(
3928 sd_bus_node_enumerator_t callback,
3931 struct node_enumerator *c;
3937 if (!object_path_is_valid(path))
3941 if (bus_pid_changed(bus))
3944 n = bus_node_allocate(bus, path);
3948 c = new0(struct node_enumerator, 1);
3955 c->callback = callback;
3956 c->userdata = userdata;
3958 LIST_PREPEND(struct node_enumerator, enumerators, n->enumerators, c);
3963 bus_node_gc(bus, n);
3967 int sd_bus_remove_node_enumerator(
3970 sd_bus_node_enumerator_t callback,
3973 struct node_enumerator *c;
3978 if (!object_path_is_valid(path))
3982 if (bus_pid_changed(bus))
3985 n = hashmap_get(bus->nodes, path);
3989 LIST_FOREACH(enumerators, c, n->enumerators)
3990 if (c->callback == callback && c->userdata == userdata)
3996 LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, c);
3999 bus_node_gc(bus, n);
4004 static int emit_properties_changed_on_interface(
4008 const char *interface,
4009 bool require_fallback,
4012 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4013 bool has_invalidating = false;
4014 struct vtable_member key;
4015 struct node_vtable *c;
4025 n = hashmap_get(bus->nodes, prefix);
4029 LIST_FOREACH(vtables, c, n->vtables) {
4030 if (require_fallback && !c->is_fallback)
4033 if (streq(c->interface, interface))
4040 r = node_vtable_get_userdata(bus, path, c, &u);
4044 r = sd_bus_message_new_signal(bus, path, "org.freedesktop.DBus.Properties", "PropertiesChanged", &m);
4048 r = sd_bus_message_append(m, "s", interface);
4052 r = sd_bus_message_open_container(m, 'a', "{sv}");
4057 key.interface = interface;
4059 STRV_FOREACH(property, names) {
4060 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4061 struct vtable_member *v;
4063 key.member = *property;
4064 v = hashmap_get(bus->vtable_properties, &key);
4068 assert(c == v->parent);
4070 if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))
4072 if (v->vtable->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY) {
4073 has_invalidating = true;
4077 r = sd_bus_message_open_container(m, 'e', "sv");
4081 r = sd_bus_message_append(m, "s", *property);
4085 r = sd_bus_message_open_container(m, 'v', v->vtable->property.signature);
4089 r = invoke_property_get(bus, v->vtable, m->path, interface, *property, m, &error, vtable_property_convert_userdata(v->vtable, u));
4093 if (sd_bus_error_is_set(&error))
4094 return bus_error_to_errno(&error);
4096 r = sd_bus_message_close_container(m);
4100 r = sd_bus_message_close_container(m);
4105 r = sd_bus_message_close_container(m);
4109 r = sd_bus_message_open_container(m, 'a', "s");
4113 if (has_invalidating) {
4114 STRV_FOREACH(property, names) {
4115 struct vtable_member *v;
4117 key.member = *property;
4118 assert_se(v = hashmap_get(bus->vtable_properties, &key));
4119 assert(c == v->parent);
4121 if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY))
4124 r = sd_bus_message_append(m, "s", *property);
4130 r = sd_bus_message_close_container(m);
4134 r = sd_bus_send(bus, m, NULL);
4141 int sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names) {
4147 if (!object_path_is_valid(path))
4149 if (!interface_name_is_valid(interface))
4152 r = emit_properties_changed_on_interface(bus, path, path, interface, false, names);
4167 e = strrchr(p, '/');
4174 r = emit_properties_changed_on_interface(bus, p, path, interface, true, names);
4183 int sd_bus_emit_properties_changed(sd_bus *bus, const char *path, const char *interface, const char *name, ...) {
4184 _cleanup_strv_free_ char **names = NULL;
4188 names = strv_new_ap(name, ap);
4194 return sd_bus_emit_properties_changed_strv(bus, path, interface, names);
4197 int sd_bus_emit_interfaces_added(sd_bus *bus, const char *path, const char *interfaces, ...) {
4201 int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const char *interfaces, ...) {
4205 int sd_bus_get_property(
4207 const char *destination,
4209 const char *interface,
4211 sd_bus_error *error,
4212 sd_bus_message **reply,
4215 sd_bus_message *rep = NULL;
4218 if (interface && !interface_name_is_valid(interface))
4220 if (!member_name_is_valid(member))
4222 if (!signature_is_single(type, false))
4227 r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", error, &rep, "ss", strempty(interface), member);
4231 r = sd_bus_message_enter_container(rep, 'v', type);
4233 sd_bus_message_unref(rep);
4241 int sd_bus_set_property(
4243 const char *destination,
4245 const char *interface,
4247 sd_bus_error *error,
4248 const char *type, ...) {
4250 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4254 if (interface && !interface_name_is_valid(interface))
4256 if (!member_name_is_valid(member))
4258 if (!signature_is_single(type, false))
4261 r = sd_bus_message_new_method_call(bus, destination, path, "org.freedesktop.DBus.Properties", "Set", &m);
4265 r = sd_bus_message_append(m, "ss", strempty(interface), member);
4269 r = sd_bus_message_open_container(m, 'v', type);
4274 r = bus_message_append_ap(m, type, ap);
4279 r = sd_bus_message_close_container(m);
4283 return sd_bus_send_with_reply_and_block(bus, m, 0, error, NULL);
4286 int sd_bus_add_object_manager(sd_bus *bus, const char *path) {
4291 if (!object_path_is_valid(path))
4293 if (bus_pid_changed(bus))
4296 n = bus_node_allocate(bus, path);
4300 n->object_manager = true;
4304 int sd_bus_remove_object_manager(sd_bus *bus, const char *path) {
4309 if (!object_path_is_valid(path))
4311 if (bus_pid_changed(bus))
4314 n = hashmap_get(bus->nodes, path);
4318 if (!n->object_manager)
4321 n->object_manager = false;
4322 bus_node_gc(bus, n);