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"
47 #include "bus-objects.h"
49 #include "bus-container.h"
50 #include "bus-protocol.h"
52 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
53 static int attach_io_events(sd_bus *b);
54 static void detach_io_events(sd_bus *b);
56 static void bus_close_fds(sd_bus *b) {
62 close_nointr_nofail(b->input_fd);
64 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
65 close_nointr_nofail(b->output_fd);
67 b->input_fd = b->output_fd = -1;
70 static void bus_node_destroy(sd_bus *b, struct node *n) {
71 struct node_callback *c;
72 struct node_vtable *v;
73 struct node_enumerator *e;
81 bus_node_destroy(b, n->child);
83 while ((c = n->callbacks)) {
84 LIST_REMOVE(callbacks, n->callbacks, c);
88 while ((v = n->vtables)) {
89 LIST_REMOVE(vtables, n->vtables, v);
94 while ((e = n->enumerators)) {
95 LIST_REMOVE(enumerators, n->enumerators, e);
100 LIST_REMOVE(siblings, n->parent->child, n);
102 assert_se(hashmap_remove(b->nodes, n->path) == n);
107 static void bus_reset_queues(sd_bus *b) {
112 for (i = 0; i < b->rqueue_size; i++)
113 sd_bus_message_unref(b->rqueue[i]);
116 for (i = 0; i < b->wqueue_size; i++)
117 sd_bus_message_unref(b->wqueue[i]);
120 b->rqueue = b->wqueue = NULL;
121 b->rqueue_allocated = b->wqueue_allocated = 0;
122 b->rqueue_size = b->wqueue_size = 0;
125 static void bus_free(sd_bus *b) {
126 struct filter_callback *f;
131 sd_bus_detach_event(b);
136 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
139 free(b->unique_name);
140 free(b->auth_buffer);
146 strv_free(b->exec_argv);
148 close_many(b->fds, b->n_fds);
153 hashmap_free_free(b->reply_callbacks);
154 prioq_free(b->reply_callbacks_prioq);
156 while ((f = b->filter_callbacks)) {
157 LIST_REMOVE(callbacks, b->filter_callbacks, f);
161 bus_match_free(&b->match_callbacks);
163 hashmap_free_free(b->vtable_methods);
164 hashmap_free_free(b->vtable_properties);
166 while ((n = hashmap_first(b->nodes)))
167 bus_node_destroy(b, n);
169 hashmap_free(b->nodes);
171 bus_kernel_flush_memfd(b);
173 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
178 _public_ int sd_bus_new(sd_bus **ret) {
181 assert_return(ret, -EINVAL);
187 r->n_ref = REFCNT_INIT;
188 r->input_fd = r->output_fd = -1;
189 r->message_version = 1;
190 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
191 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
192 r->attach_flags |= KDBUS_ATTACH_NAMES;
193 r->original_pid = getpid();
195 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
197 /* We guarantee that wqueue always has space for at least one
199 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
208 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
211 assert_return(bus, -EINVAL);
212 assert_return(bus->state == BUS_UNSET, -EPERM);
213 assert_return(address, -EINVAL);
214 assert_return(!bus_pid_changed(bus), -ECHILD);
226 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
227 assert_return(bus, -EINVAL);
228 assert_return(bus->state == BUS_UNSET, -EPERM);
229 assert_return(input_fd >= 0, -EINVAL);
230 assert_return(output_fd >= 0, -EINVAL);
231 assert_return(!bus_pid_changed(bus), -ECHILD);
233 bus->input_fd = input_fd;
234 bus->output_fd = output_fd;
238 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
241 assert_return(bus, -EINVAL);
242 assert_return(bus->state == BUS_UNSET, -EPERM);
243 assert_return(path, -EINVAL);
244 assert_return(!strv_isempty(argv), -EINVAL);
245 assert_return(!bus_pid_changed(bus), -ECHILD);
257 free(bus->exec_path);
258 strv_free(bus->exec_argv);
266 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
267 assert_return(bus, -EINVAL);
268 assert_return(bus->state == BUS_UNSET, -EPERM);
269 assert_return(!bus_pid_changed(bus), -ECHILD);
271 bus->bus_client = !!b;
275 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
276 assert_return(bus, -EINVAL);
277 assert_return(bus->state == BUS_UNSET, -EPERM);
278 assert_return(!bus_pid_changed(bus), -ECHILD);
280 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
284 _public_ int sd_bus_negotiate_attach_timestamp(sd_bus *bus, int b) {
285 assert_return(bus, -EINVAL);
286 assert_return(bus->state == BUS_UNSET, -EPERM);
287 assert_return(!bus_pid_changed(bus), -ECHILD);
289 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
293 _public_ int sd_bus_negotiate_attach_creds(sd_bus *bus, uint64_t mask) {
294 assert_return(bus, -EINVAL);
295 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
296 assert_return(bus->state == BUS_UNSET, -EPERM);
297 assert_return(!bus_pid_changed(bus), -ECHILD);
299 /* The well knowns we need unconditionally, so that matches can work */
300 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
302 return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
305 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
306 assert_return(bus, -EINVAL);
307 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
308 assert_return(bus->state == BUS_UNSET, -EPERM);
309 assert_return(!bus_pid_changed(bus), -ECHILD);
311 bus->is_server = !!b;
312 bus->server_id = server_id;
316 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
317 assert_return(bus, -EINVAL);
318 assert_return(bus->state == BUS_UNSET, -EPERM);
319 assert_return(!bus_pid_changed(bus), -ECHILD);
321 bus->anonymous_auth = !!b;
325 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
326 assert_return(bus, -EINVAL);
327 assert_return(bus->state == BUS_UNSET, -EPERM);
328 assert_return(!bus_pid_changed(bus), -ECHILD);
334 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
339 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
342 r = sd_bus_message_get_errno(reply);
348 r = sd_bus_message_read(reply, "s", &s);
352 if (!service_name_is_valid(s) || s[0] != ':')
355 bus->unique_name = strdup(s);
356 if (!bus->unique_name)
359 if (bus->state == BUS_HELLO)
360 bus->state = BUS_RUNNING;
365 static int bus_send_hello(sd_bus *bus) {
366 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
371 if (!bus->bus_client || bus->is_kernel)
374 r = sd_bus_message_new_method_call(
376 "org.freedesktop.DBus",
377 "/org/freedesktop/DBus",
378 "org.freedesktop.DBus",
384 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
387 int bus_start_running(sd_bus *bus) {
390 if (bus->bus_client && !bus->is_kernel) {
391 bus->state = BUS_HELLO;
395 bus->state = BUS_RUNNING;
399 static int parse_address_key(const char **p, const char *key, char **value) {
400 size_t l, n = 0, allocated = 0;
410 if (strncmp(*p, key, l) != 0)
423 while (*a != ';' && *a != ',' && *a != 0) {
441 c = (char) ((x << 4) | y);
448 if (!GREEDY_REALLOC(r, allocated, n + 2))
472 static void skip_address_key(const char **p) {
476 *p += strcspn(*p, ",");
482 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
483 _cleanup_free_ char *path = NULL, *abstract = NULL;
492 while (**p != 0 && **p != ';') {
493 r = parse_address_key(p, "guid", guid);
499 r = parse_address_key(p, "path", &path);
505 r = parse_address_key(p, "abstract", &abstract);
514 if (!path && !abstract)
517 if (path && abstract)
522 if (l > sizeof(b->sockaddr.un.sun_path))
525 b->sockaddr.un.sun_family = AF_UNIX;
526 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
527 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
528 } else if (abstract) {
529 l = strlen(abstract);
530 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
533 b->sockaddr.un.sun_family = AF_UNIX;
534 b->sockaddr.un.sun_path[0] = 0;
535 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
536 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
542 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
543 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
545 struct addrinfo *result, hints = {
546 .ai_socktype = SOCK_STREAM,
547 .ai_flags = AI_ADDRCONFIG,
555 while (**p != 0 && **p != ';') {
556 r = parse_address_key(p, "guid", guid);
562 r = parse_address_key(p, "host", &host);
568 r = parse_address_key(p, "port", &port);
574 r = parse_address_key(p, "family", &family);
587 if (streq(family, "ipv4"))
588 hints.ai_family = AF_INET;
589 else if (streq(family, "ipv6"))
590 hints.ai_family = AF_INET6;
595 r = getaddrinfo(host, port, &hints, &result);
599 return -EADDRNOTAVAIL;
601 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
602 b->sockaddr_size = result->ai_addrlen;
604 freeaddrinfo(result);
609 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
611 unsigned n_argv = 0, j;
613 size_t allocated = 0;
621 while (**p != 0 && **p != ';') {
622 r = parse_address_key(p, "guid", guid);
628 r = parse_address_key(p, "path", &path);
634 if (startswith(*p, "argv")) {
638 ul = strtoul(*p + 4, (char**) p, 10);
639 if (errno > 0 || **p != '=' || ul > 256) {
647 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
655 r = parse_address_key(p, NULL, argv + ul);
670 /* Make sure there are no holes in the array, with the
671 * exception of argv[0] */
672 for (j = 1; j < n_argv; j++)
678 if (argv && argv[0] == NULL) {
679 argv[0] = strdup(path);
691 for (j = 0; j < n_argv; j++)
699 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
700 _cleanup_free_ char *path = NULL;
708 while (**p != 0 && **p != ';') {
709 r = parse_address_key(p, "guid", guid);
715 r = parse_address_key(p, "path", &path);
734 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
735 _cleanup_free_ char *machine = NULL;
743 while (**p != 0 && **p != ';') {
744 r = parse_address_key(p, "guid", guid);
750 r = parse_address_key(p, "machine", &machine);
762 if (!filename_is_safe(machine))
766 b->machine = machine;
769 b->sockaddr.un.sun_family = AF_UNIX;
770 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
771 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
776 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
777 _cleanup_free_ char *machine = NULL;
785 while (**p != 0 && **p != ';') {
786 r = parse_address_key(p, "guid", guid);
792 r = parse_address_key(p, "machine", &machine);
804 if (!filename_is_safe(machine))
808 b->machine = machine;
812 b->kernel = strdup("/dev/kdbus/0-system/bus");
819 static void bus_reset_parsed_address(sd_bus *b) {
823 b->sockaddr_size = 0;
824 strv_free(b->exec_argv);
828 b->server_id = SD_ID128_NULL;
835 static int bus_parse_next_address(sd_bus *b) {
836 _cleanup_free_ char *guid = NULL;
844 if (b->address[b->address_index] == 0)
847 bus_reset_parsed_address(b);
849 a = b->address + b->address_index;
858 if (startswith(a, "unix:")) {
861 r = parse_unix_address(b, &a, &guid);
866 } else if (startswith(a, "tcp:")) {
869 r = parse_tcp_address(b, &a, &guid);
875 } else if (startswith(a, "unixexec:")) {
878 r = parse_exec_address(b, &a, &guid);
884 } else if (startswith(a, "kernel:")) {
887 r = parse_kernel_address(b, &a, &guid);
892 } else if (startswith(a, "x-container-unix:")) {
895 r = parse_container_unix_address(b, &a, &guid);
900 } else if (startswith(a, "x-container-kernel:")) {
903 r = parse_container_kernel_address(b, &a, &guid);
916 r = sd_id128_from_string(guid, &b->server_id);
921 b->address_index = a - b->address;
925 static int bus_start_address(sd_bus *b) {
931 bool skipped = false;
936 r = bus_socket_exec(b);
937 else if (b->machine && b->kernel)
938 r = bus_container_connect_kernel(b);
939 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
940 r = bus_container_connect_socket(b);
942 r = bus_kernel_connect(b);
943 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
944 r = bus_socket_connect(b);
950 r = attach_io_events(b);
955 b->last_connect_error = -r;
958 r = bus_parse_next_address(b);
962 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
966 int bus_next_address(sd_bus *b) {
969 bus_reset_parsed_address(b);
970 return bus_start_address(b);
973 static int bus_start_fd(sd_bus *b) {
978 assert(b->input_fd >= 0);
979 assert(b->output_fd >= 0);
981 r = fd_nonblock(b->input_fd, true);
985 r = fd_cloexec(b->input_fd, true);
989 if (b->input_fd != b->output_fd) {
990 r = fd_nonblock(b->output_fd, true);
994 r = fd_cloexec(b->output_fd, true);
999 if (fstat(b->input_fd, &st) < 0)
1002 if (S_ISCHR(b->input_fd))
1003 return bus_kernel_take_fd(b);
1005 return bus_socket_take_fd(b);
1008 _public_ int sd_bus_start(sd_bus *bus) {
1011 assert_return(bus, -EINVAL);
1012 assert_return(bus->state == BUS_UNSET, -EPERM);
1013 assert_return(!bus_pid_changed(bus), -ECHILD);
1015 bus->state = BUS_OPENING;
1017 if (bus->is_server && bus->bus_client)
1020 if (bus->input_fd >= 0)
1021 r = bus_start_fd(bus);
1022 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1023 r = bus_start_address(bus);
1030 return bus_send_hello(bus);
1033 _public_ int sd_bus_open_system(sd_bus **ret) {
1038 assert_return(ret, -EINVAL);
1044 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1046 r = sd_bus_set_address(b, e);
1049 r = sd_bus_set_address(b, "kernel:path=/dev/kdbus/0-system/bus;unix:path=/run/dbus/system_bus_socket");
1051 r = sd_bus_set_address(b, "unix:path=/run/dbus/system_bus_socket");
1057 b->bus_client = true;
1059 /* Let's do per-method access control on the system bus. We
1060 * need the caller's UID and capability set for that. */
1062 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1064 r = sd_bus_start(b);
1076 _public_ int sd_bus_open_user(sd_bus **ret) {
1081 assert_return(ret, -EINVAL);
1087 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1089 r = sd_bus_set_address(b, e);
1093 e = secure_getenv("XDG_RUNTIME_DIR");
1095 _cleanup_free_ char *ee = NULL;
1097 ee = bus_address_escape(e);
1104 asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus;unix:path=%s/bus", (unsigned long) getuid(), ee);
1106 b->address = strjoin("unix:path=", ee, "/bus", NULL);
1110 asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus", (unsigned long) getuid());
1112 return -ECONNREFUSED;
1122 b->bus_client = true;
1124 /* We don't do any per-method access control on the user
1128 r = sd_bus_start(b);
1140 _public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) {
1141 _cleanup_free_ char *e = NULL;
1146 assert_return(host, -EINVAL);
1147 assert_return(ret, -EINVAL);
1149 e = bus_address_escape(host);
1153 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1157 r = sd_bus_new(&bus);
1164 bus->bus_client = true;
1166 r = sd_bus_start(bus);
1176 _public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) {
1177 _cleanup_free_ char *e = NULL;
1182 assert_return(machine, -EINVAL);
1183 assert_return(ret, -EINVAL);
1184 assert_return(filename_is_safe(machine), -EINVAL);
1186 e = bus_address_escape(machine);
1191 p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1193 p = strjoin("x-container-unix:machine=", e, NULL);
1198 r = sd_bus_new(&bus);
1205 bus->bus_client = true;
1207 r = sd_bus_start(bus);
1217 _public_ void sd_bus_close(sd_bus *bus) {
1221 if (bus->state == BUS_CLOSED)
1223 if (bus_pid_changed(bus))
1226 bus->state = BUS_CLOSED;
1228 sd_bus_detach_event(bus);
1230 /* Drop all queued messages so that they drop references to
1231 * the bus object and the bus may be freed */
1232 bus_reset_queues(bus);
1234 if (!bus->is_kernel)
1237 /* We'll leave the fd open in case this is a kernel bus, since
1238 * there might still be memblocks around that reference this
1239 * bus, and they might need to invoke the * KDBUS_CMD_FREE
1240 * ioctl on the fd when they are freed. */
1243 static void bus_enter_closing(sd_bus *bus) {
1246 if (bus->state != BUS_OPENING &&
1247 bus->state != BUS_AUTHENTICATING &&
1248 bus->state != BUS_HELLO &&
1249 bus->state != BUS_RUNNING)
1252 bus->state = BUS_CLOSING;
1255 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1256 assert_return(bus, NULL);
1258 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1263 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1268 if (REFCNT_DEC(bus->n_ref) <= 0)
1274 _public_ int sd_bus_is_open(sd_bus *bus) {
1276 assert_return(bus, -EINVAL);
1277 assert_return(!bus_pid_changed(bus), -ECHILD);
1279 return BUS_IS_OPEN(bus->state);
1282 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1285 assert_return(bus, -EINVAL);
1286 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1287 assert_return(!bus_pid_changed(bus), -ECHILD);
1289 if (type == SD_BUS_TYPE_UNIX_FD) {
1290 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1293 r = bus_ensure_running(bus);
1297 return bus->can_fds;
1300 return bus_type_is_valid(type);
1303 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1306 assert_return(bus, -EINVAL);
1307 assert_return(server_id, -EINVAL);
1308 assert_return(!bus_pid_changed(bus), -ECHILD);
1310 r = bus_ensure_running(bus);
1314 *server_id = bus->server_id;
1318 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1323 /* If we copy the same message to multiple
1324 * destinations, avoid using the same serial
1326 b->serial = MAX(b->serial, BUS_MESSAGE_SERIAL(m));
1331 timeout = BUS_DEFAULT_TIMEOUT;
1333 return bus_message_seal(m, ++b->serial, timeout);
1336 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1339 /* Do packet version and endianess already match? */
1340 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1341 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1344 /* No? Then remarshal! */
1345 return bus_message_remarshal(b, m);
1348 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1352 /* The bus specification says the serial number cannot be 0,
1353 * hence let's fill something in for synthetic messages. Since
1354 * synthetic messages might have a fake sender and we don't
1355 * want to interfere with the real sender's serial numbers we
1356 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1357 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1358 * even though kdbus can do 64bit. */
1360 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1363 static int bus_write_message(sd_bus *bus, sd_bus_message *message, size_t *idx) {
1368 return bus_kernel_write_message(bus, message);
1370 return bus_socket_write_message(bus, message, idx);
1373 static int dispatch_wqueue(sd_bus *bus) {
1377 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1379 while (bus->wqueue_size > 0) {
1381 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1385 /* Didn't do anything this time */
1387 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1388 /* Fully written. Let's drop the entry from
1391 * This isn't particularly optimized, but
1392 * well, this is supposed to be our worst-case
1393 * buffer only, and the socket buffer is
1394 * supposed to be our primary buffer, and if
1395 * it got full, then all bets are off
1398 sd_bus_message_unref(bus->wqueue[0]);
1399 bus->wqueue_size --;
1400 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1410 static int bus_read_message(sd_bus *bus) {
1414 return bus_kernel_read_message(bus);
1416 return bus_socket_read_message(bus);
1419 int bus_rqueue_make_room(sd_bus *bus) {
1422 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1425 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1431 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1436 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1439 if (bus->rqueue_size > 0) {
1440 /* Dispatch a queued message */
1442 *m = bus->rqueue[0];
1443 bus->rqueue_size --;
1444 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1448 /* Try to read a new message */
1449 r = bus_read_message(bus);
1459 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *_m, uint64_t *serial) {
1460 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1463 assert_return(bus, -EINVAL);
1464 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1465 assert_return(m, -EINVAL);
1466 assert_return(!bus_pid_changed(bus), -ECHILD);
1469 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1476 /* If the serial number isn't kept, then we know that no reply
1478 if (!serial && !m->sealed)
1479 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1481 r = bus_seal_message(bus, m, 0);
1485 /* Remarshall if we have to. This will possible unref the
1486 * message and place a replacement in m */
1487 r = bus_remarshal_message(bus, &m);
1491 /* If this is a reply and no reply was requested, then let's
1492 * suppress this, if we can */
1493 if (m->dont_send && !serial)
1496 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1499 r = bus_write_message(bus, m, &idx);
1501 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1502 bus_enter_closing(bus);
1505 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1506 /* Wasn't fully written. So let's remember how
1507 * much was written. Note that the first entry
1508 * of the wqueue array is always allocated so
1509 * that we always can remember how much was
1511 bus->wqueue[0] = sd_bus_message_ref(m);
1512 bus->wqueue_size = 1;
1516 /* Just append it to the queue. */
1518 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1521 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1524 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1528 *serial = BUS_MESSAGE_SERIAL(m);
1533 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *serial) {
1536 assert_return(bus, -EINVAL);
1537 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1538 assert_return(m, -EINVAL);
1539 assert_return(!bus_pid_changed(bus), -ECHILD);
1541 if (!streq_ptr(m->destination, destination)) {
1546 r = sd_bus_message_set_destination(m, destination);
1551 return sd_bus_send(bus, m, serial);
1554 static usec_t calc_elapse(uint64_t usec) {
1555 if (usec == (uint64_t) -1)
1558 return now(CLOCK_MONOTONIC) + usec;
1561 static int timeout_compare(const void *a, const void *b) {
1562 const struct reply_callback *x = a, *y = b;
1564 if (x->timeout != 0 && y->timeout == 0)
1567 if (x->timeout == 0 && y->timeout != 0)
1570 if (x->timeout < y->timeout)
1573 if (x->timeout > y->timeout)
1579 _public_ int sd_bus_call_async(
1582 sd_bus_message_handler_t callback,
1587 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1588 struct reply_callback *c;
1591 assert_return(bus, -EINVAL);
1592 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1593 assert_return(m, -EINVAL);
1594 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1595 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1596 assert_return(callback, -EINVAL);
1597 assert_return(!bus_pid_changed(bus), -ECHILD);
1599 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1603 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1607 r = bus_seal_message(bus, m, usec);
1611 r = bus_remarshal_message(bus, &m);
1615 c = new0(struct reply_callback, 1);
1619 c->callback = callback;
1620 c->userdata = userdata;
1621 c->serial = BUS_MESSAGE_SERIAL(m);
1622 c->timeout = calc_elapse(m->timeout);
1624 r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1630 if (c->timeout != 0) {
1631 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1634 sd_bus_call_async_cancel(bus, c->serial);
1639 r = sd_bus_send(bus, m, serial);
1641 sd_bus_call_async_cancel(bus, c->serial);
1648 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t serial) {
1649 struct reply_callback *c;
1651 assert_return(bus, -EINVAL);
1652 assert_return(serial != 0, -EINVAL);
1653 assert_return(!bus_pid_changed(bus), -ECHILD);
1655 c = hashmap_remove(bus->reply_callbacks, &serial);
1659 if (c->timeout != 0)
1660 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1666 int bus_ensure_running(sd_bus *bus) {
1671 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1673 if (bus->state == BUS_RUNNING)
1677 r = sd_bus_process(bus, NULL);
1680 if (bus->state == BUS_RUNNING)
1685 r = sd_bus_wait(bus, (uint64_t) -1);
1691 _public_ int sd_bus_call(
1695 sd_bus_error *error,
1696 sd_bus_message **reply) {
1698 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1704 assert_return(bus, -EINVAL);
1705 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1706 assert_return(m, -EINVAL);
1707 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1708 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1709 assert_return(!bus_error_is_dirty(error), -EINVAL);
1710 assert_return(!bus_pid_changed(bus), -ECHILD);
1712 r = bus_ensure_running(bus);
1716 i = bus->rqueue_size;
1718 r = bus_seal_message(bus, m, usec);
1722 r = bus_remarshal_message(bus, &m);
1726 r = sd_bus_send(bus, m, &serial);
1730 timeout = calc_elapse(m->timeout);
1735 while (i < bus->rqueue_size) {
1736 sd_bus_message *incoming = NULL;
1738 incoming = bus->rqueue[i];
1740 if (incoming->reply_serial == serial) {
1741 /* Found a match! */
1743 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1746 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1751 sd_bus_message_unref(incoming);
1754 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1755 r = sd_bus_error_copy(error, &incoming->error);
1759 sd_bus_message_unref(incoming);
1762 } else if (incoming->header->serial == serial &&
1765 streq(bus->unique_name, incoming->sender)) {
1767 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1770 /* Our own message? Somebody is trying
1771 * to send its own client a message,
1772 * let's not dead-lock, let's fail
1775 sd_bus_message_unref(incoming);
1779 /* Try to read more, right-away */
1783 r = bus_read_message(bus);
1785 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1786 bus_enter_closing(bus);
1796 n = now(CLOCK_MONOTONIC);
1802 left = (uint64_t) -1;
1804 r = bus_poll(bus, true, left);
1810 r = dispatch_wqueue(bus);
1812 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1813 bus_enter_closing(bus);
1820 _public_ int sd_bus_get_fd(sd_bus *bus) {
1822 assert_return(bus, -EINVAL);
1823 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1824 assert_return(!bus_pid_changed(bus), -ECHILD);
1826 return bus->input_fd;
1829 _public_ int sd_bus_get_events(sd_bus *bus) {
1832 assert_return(bus, -EINVAL);
1833 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1834 assert_return(!bus_pid_changed(bus), -ECHILD);
1836 if (bus->state == BUS_OPENING)
1838 else if (bus->state == BUS_AUTHENTICATING) {
1840 if (bus_socket_auth_needs_write(bus))
1845 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1846 if (bus->rqueue_size <= 0)
1848 if (bus->wqueue_size > 0)
1855 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1856 struct reply_callback *c;
1858 assert_return(bus, -EINVAL);
1859 assert_return(timeout_usec, -EINVAL);
1860 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1861 assert_return(!bus_pid_changed(bus), -ECHILD);
1863 if (bus->state == BUS_CLOSING) {
1868 if (bus->state == BUS_AUTHENTICATING) {
1869 *timeout_usec = bus->auth_timeout;
1873 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1874 *timeout_usec = (uint64_t) -1;
1878 if (bus->rqueue_size > 0) {
1883 c = prioq_peek(bus->reply_callbacks_prioq);
1885 *timeout_usec = (uint64_t) -1;
1889 *timeout_usec = c->timeout;
1893 static int process_timeout(sd_bus *bus) {
1894 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1895 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1896 struct reply_callback *c;
1902 c = prioq_peek(bus->reply_callbacks_prioq);
1906 n = now(CLOCK_MONOTONIC);
1910 r = bus_message_new_synthetic_error(
1913 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
1918 m->sender = "org.freedesktop.DBus";
1920 r = bus_seal_synthetic_message(bus, m);
1924 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1925 hashmap_remove(bus->reply_callbacks, &c->serial);
1928 bus->iteration_counter ++;
1930 r = c->callback(bus, m, c->userdata, &error_buffer);
1931 r = bus_maybe_reply_error(m, r, &error_buffer);
1934 bus->current = NULL;
1939 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1943 if (bus->state != BUS_HELLO)
1946 /* Let's make sure the first message on the bus is the HELLO
1947 * reply. But note that we don't actually parse the message
1948 * here (we leave that to the usual handling), we just verify
1949 * we don't let any earlier msg through. */
1951 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1952 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1955 if (m->reply_serial != bus->hello_serial)
1961 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1962 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1963 struct reply_callback *c;
1969 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1970 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1973 c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1977 if (c->timeout != 0)
1978 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1980 r = sd_bus_message_rewind(m, true);
1984 r = c->callback(bus, m, c->userdata, &error_buffer);
1985 r = bus_maybe_reply_error(m, r, &error_buffer);
1991 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1992 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1993 struct filter_callback *l;
2000 bus->filter_callbacks_modified = false;
2002 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2004 if (bus->filter_callbacks_modified)
2007 /* Don't run this more than once per iteration */
2008 if (l->last_iteration == bus->iteration_counter)
2011 l->last_iteration = bus->iteration_counter;
2013 r = sd_bus_message_rewind(m, true);
2017 r = l->callback(bus, m, l->userdata, &error_buffer);
2018 r = bus_maybe_reply_error(m, r, &error_buffer);
2024 } while (bus->filter_callbacks_modified);
2029 static int process_match(sd_bus *bus, sd_bus_message *m) {
2036 bus->match_callbacks_modified = false;
2038 r = bus_match_run(bus, &bus->match_callbacks, m);
2042 } while (bus->match_callbacks_modified);
2047 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2048 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2054 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2057 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2060 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2063 if (streq_ptr(m->member, "Ping"))
2064 r = sd_bus_message_new_method_return(m, &reply);
2065 else if (streq_ptr(m->member, "GetMachineId")) {
2069 r = sd_id128_get_machine(&id);
2073 r = sd_bus_message_new_method_return(m, &reply);
2077 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2079 r = sd_bus_message_new_method_errorf(
2081 SD_BUS_ERROR_UNKNOWN_METHOD,
2082 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2088 r = sd_bus_send(bus, reply, NULL);
2095 static int process_message(sd_bus *bus, sd_bus_message *m) {
2102 bus->iteration_counter++;
2104 log_debug("Got message sender=%s object=%s interface=%s member=%s",
2105 strna(sd_bus_message_get_sender(m)),
2106 strna(sd_bus_message_get_path(m)),
2107 strna(sd_bus_message_get_interface(m)),
2108 strna(sd_bus_message_get_member(m)));
2110 r = process_hello(bus, m);
2114 r = process_reply(bus, m);
2118 r = process_filter(bus, m);
2122 r = process_match(bus, m);
2126 r = process_builtin(bus, m);
2130 r = bus_process_object(bus, m);
2133 bus->current = NULL;
2137 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2138 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2142 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2144 r = process_timeout(bus);
2148 r = dispatch_wqueue(bus);
2152 r = dispatch_rqueue(bus, &m);
2158 r = process_message(bus, m);
2163 r = sd_bus_message_rewind(m, true);
2172 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2174 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2175 strna(sd_bus_message_get_sender(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)));
2180 r = sd_bus_reply_method_errorf(
2182 SD_BUS_ERROR_UNKNOWN_OBJECT,
2183 "Unknown object '%s'.", m->path);
2197 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2198 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2199 struct reply_callback *c;
2203 assert(bus->state == BUS_CLOSING);
2205 c = hashmap_first(bus->reply_callbacks);
2207 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2209 /* First, fail all outstanding method calls */
2210 r = bus_message_new_synthetic_error(
2213 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2218 r = bus_seal_synthetic_message(bus, m);
2222 if (c->timeout != 0)
2223 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2225 hashmap_remove(bus->reply_callbacks, &c->serial);
2228 bus->iteration_counter++;
2230 r = c->callback(bus, m, c->userdata, &error_buffer);
2231 r = bus_maybe_reply_error(m, r, &error_buffer);
2237 /* Then, synthesize a Disconnected message */
2238 r = sd_bus_message_new_signal(
2240 "/org/freedesktop/DBus/Local",
2241 "org.freedesktop.DBus.Local",
2247 m->sender = "org.freedesktop.DBus.Local";
2249 r = bus_seal_synthetic_message(bus, m);
2256 bus->iteration_counter++;
2258 r = process_filter(bus, m);
2262 r = process_match(bus, m);
2274 bus->current = NULL;
2278 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2279 BUS_DONT_DESTROY(bus);
2282 /* Returns 0 when we didn't do anything. This should cause the
2283 * caller to invoke sd_bus_wait() before returning the next
2284 * time. Returns > 0 when we did something, which possibly
2285 * means *ret is filled in with an unprocessed message. */
2287 assert_return(bus, -EINVAL);
2288 assert_return(!bus_pid_changed(bus), -ECHILD);
2290 /* We don't allow recursively invoking sd_bus_process(). */
2291 assert_return(!bus->current, -EBUSY);
2293 switch (bus->state) {
2302 r = bus_socket_process_opening(bus);
2303 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2304 bus_enter_closing(bus);
2312 case BUS_AUTHENTICATING:
2313 r = bus_socket_process_authenticating(bus);
2314 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2315 bus_enter_closing(bus);
2327 r = process_running(bus, ret);
2328 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2329 bus_enter_closing(bus);
2339 return process_closing(bus, ret);
2342 assert_not_reached("Unknown state");
2345 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2346 struct pollfd p[2] = {};
2349 usec_t m = (usec_t) -1;
2353 if (bus->state == BUS_CLOSING)
2356 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2358 e = sd_bus_get_events(bus);
2363 /* The caller really needs some more data, he doesn't
2364 * care about what's already read, or any timeouts
2369 /* The caller wants to process if there's something to
2370 * process, but doesn't care otherwise */
2372 r = sd_bus_get_timeout(bus, &until);
2377 nw = now(CLOCK_MONOTONIC);
2378 m = until > nw ? until - nw : 0;
2382 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2385 p[0].fd = bus->input_fd;
2386 if (bus->output_fd == bus->input_fd) {
2390 p[0].events = e & POLLIN;
2391 p[1].fd = bus->output_fd;
2392 p[1].events = e & POLLOUT;
2396 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2400 return r > 0 ? 1 : 0;
2403 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2405 assert_return(bus, -EINVAL);
2406 assert_return(!bus_pid_changed(bus), -ECHILD);
2408 if (bus->state == BUS_CLOSING)
2411 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2413 if (bus->rqueue_size > 0)
2416 return bus_poll(bus, false, timeout_usec);
2419 _public_ int sd_bus_flush(sd_bus *bus) {
2422 assert_return(bus, -EINVAL);
2423 assert_return(!bus_pid_changed(bus), -ECHILD);
2425 if (bus->state == BUS_CLOSING)
2428 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2430 r = bus_ensure_running(bus);
2434 if (bus->wqueue_size <= 0)
2438 r = dispatch_wqueue(bus);
2440 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
2441 bus_enter_closing(bus);
2446 if (bus->wqueue_size <= 0)
2449 r = bus_poll(bus, false, (uint64_t) -1);
2455 _public_ int sd_bus_add_filter(sd_bus *bus,
2456 sd_bus_message_handler_t callback,
2459 struct filter_callback *f;
2461 assert_return(bus, -EINVAL);
2462 assert_return(callback, -EINVAL);
2463 assert_return(!bus_pid_changed(bus), -ECHILD);
2465 f = new0(struct filter_callback, 1);
2468 f->callback = callback;
2469 f->userdata = userdata;
2471 bus->filter_callbacks_modified = true;
2472 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2476 _public_ int sd_bus_remove_filter(sd_bus *bus,
2477 sd_bus_message_handler_t callback,
2480 struct filter_callback *f;
2482 assert_return(bus, -EINVAL);
2483 assert_return(callback, -EINVAL);
2484 assert_return(!bus_pid_changed(bus), -ECHILD);
2486 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2487 if (f->callback == callback && f->userdata == userdata) {
2488 bus->filter_callbacks_modified = true;
2489 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2498 _public_ int sd_bus_add_match(sd_bus *bus,
2500 sd_bus_message_handler_t callback,
2503 struct bus_match_component *components = NULL;
2504 unsigned n_components = 0;
2505 uint64_t cookie = 0;
2508 assert_return(bus, -EINVAL);
2509 assert_return(match, -EINVAL);
2510 assert_return(!bus_pid_changed(bus), -ECHILD);
2512 r = bus_match_parse(match, &components, &n_components);
2516 if (bus->bus_client) {
2517 cookie = ++bus->match_cookie;
2519 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2524 bus->match_callbacks_modified = true;
2525 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2527 if (bus->bus_client)
2528 bus_remove_match_internal(bus, match, cookie);
2532 bus_match_parse_free(components, n_components);
2536 _public_ int sd_bus_remove_match(sd_bus *bus,
2538 sd_bus_message_handler_t callback,
2541 struct bus_match_component *components = NULL;
2542 unsigned n_components = 0;
2544 uint64_t cookie = 0;
2546 assert_return(bus, -EINVAL);
2547 assert_return(match, -EINVAL);
2548 assert_return(!bus_pid_changed(bus), -ECHILD);
2550 r = bus_match_parse(match, &components, &n_components);
2554 bus->match_callbacks_modified = true;
2555 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2557 if (bus->bus_client)
2558 q = bus_remove_match_internal(bus, match, cookie);
2560 bus_match_parse_free(components, n_components);
2562 return r < 0 ? r : q;
2565 bool bus_pid_changed(sd_bus *bus) {
2568 /* We don't support people creating a bus connection and
2569 * keeping it around over a fork(). Let's complain. */
2571 return bus->original_pid != getpid();
2574 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2575 sd_bus *bus = userdata;
2580 r = sd_bus_process(bus, NULL);
2587 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2588 sd_bus *bus = userdata;
2593 r = sd_bus_process(bus, NULL);
2600 static int prepare_callback(sd_event_source *s, void *userdata) {
2601 sd_bus *bus = userdata;
2608 e = sd_bus_get_events(bus);
2612 if (bus->output_fd != bus->input_fd) {
2614 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2618 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2622 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2627 r = sd_bus_get_timeout(bus, &until);
2633 j = sd_event_source_set_time(bus->time_event_source, until);
2638 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2645 static int quit_callback(sd_event_source *event, void *userdata) {
2646 sd_bus *bus = userdata;
2655 static int attach_io_events(sd_bus *bus) {
2660 if (bus->input_fd < 0)
2666 if (!bus->input_io_event_source) {
2667 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2671 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2675 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2677 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2682 if (bus->output_fd != bus->input_fd) {
2683 assert(bus->output_fd >= 0);
2685 if (!bus->output_io_event_source) {
2686 r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2690 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2692 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2701 static void detach_io_events(sd_bus *bus) {
2704 if (bus->input_io_event_source) {
2705 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2706 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2709 if (bus->output_io_event_source) {
2710 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2711 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2715 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2718 assert_return(bus, -EINVAL);
2719 assert_return(!bus->event, -EBUSY);
2721 assert(!bus->input_io_event_source);
2722 assert(!bus->output_io_event_source);
2723 assert(!bus->time_event_source);
2726 bus->event = sd_event_ref(event);
2728 r = sd_event_default(&bus->event);
2733 bus->event_priority = priority;
2735 r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2739 r = sd_event_source_set_priority(bus->time_event_source, priority);
2743 r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
2747 r = attach_io_events(bus);
2754 sd_bus_detach_event(bus);
2758 _public_ int sd_bus_detach_event(sd_bus *bus) {
2759 assert_return(bus, -EINVAL);
2764 detach_io_events(bus);
2766 if (bus->time_event_source) {
2767 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2768 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2771 if (bus->quit_event_source) {
2772 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2773 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2777 bus->event = sd_event_unref(bus->event);
2782 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2783 assert_return(bus, NULL);
2788 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2789 assert_return(bus, NULL);
2791 return bus->current;
2794 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2799 assert(default_bus);
2802 return !!*default_bus;
2805 *ret = sd_bus_ref(*default_bus);
2813 b->default_bus_ptr = default_bus;
2821 _public_ int sd_bus_default_system(sd_bus **ret) {
2822 static thread_local sd_bus *default_system_bus = NULL;
2824 return bus_default(sd_bus_open_system, &default_system_bus, ret);
2827 _public_ int sd_bus_default_user(sd_bus **ret) {
2828 static thread_local sd_bus *default_user_bus = NULL;
2830 return bus_default(sd_bus_open_user, &default_user_bus, ret);
2833 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2834 assert_return(b, -EINVAL);
2835 assert_return(tid, -EINVAL);
2836 assert_return(!bus_pid_changed(b), -ECHILD);
2844 return sd_event_get_tid(b->event, tid);
2849 _public_ char *sd_bus_label_escape(const char *s) {
2853 assert_return(s, NULL);
2855 /* Escapes all chars that D-Bus' object path cannot deal
2856 * with. Can be reversed with bus_path_unescape(). We special
2857 * case the empty string. */
2862 r = new(char, strlen(s)*3 + 1);
2866 for (f = s, t = r; *f; f++) {
2868 /* Escape everything that is not a-zA-Z0-9. We also
2869 * escape 0-9 if it's the first character */
2871 if (!(*f >= 'A' && *f <= 'Z') &&
2872 !(*f >= 'a' && *f <= 'z') &&
2873 !(f > s && *f >= '0' && *f <= '9')) {
2875 *(t++) = hexchar(*f >> 4);
2876 *(t++) = hexchar(*f);
2886 _public_ char *sd_bus_label_unescape(const char *f) {
2889 assert_return(f, NULL);
2891 /* Special case for the empty string */
2895 r = new(char, strlen(f) + 1);
2899 for (t = r; *f; f++) {
2904 if ((a = unhexchar(f[1])) < 0 ||
2905 (b = unhexchar(f[2])) < 0) {
2906 /* Invalid escape code, let's take it literal then */
2909 *(t++) = (char) ((a << 4) | b);
2921 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
2926 assert_return(bus, -EINVAL);
2927 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
2928 assert_return(ret, -EINVAL);
2929 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2930 assert_return(!bus_pid_changed(bus), -ECHILD);
2931 assert_return(!bus->is_kernel, -ENOTSUP);
2933 if (!bus->ucred_valid && !isempty(bus->label))
2936 c = bus_creds_new();
2940 if (bus->ucred_valid) {
2941 pid = c->pid = bus->ucred.pid;
2942 c->uid = bus->ucred.uid;
2943 c->gid = bus->ucred.gid;
2945 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
2948 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
2949 c->label = strdup(bus->label);
2951 sd_bus_creds_unref(c);
2955 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
2958 r = bus_creds_add_more(c, mask, pid, 0);
2966 _public_ int sd_bus_try_close(sd_bus *bus) {
2969 assert_return(bus, -EINVAL);
2970 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2971 assert_return(!bus_pid_changed(bus), -ECHILD);
2972 assert_return(bus->is_kernel, -ENOTSUP);
2974 if (bus->rqueue_size > 0)
2977 if (bus->wqueue_size > 0)
2980 r = bus_kernel_try_close(bus);