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);
54 static void bus_close_fds(sd_bus *b) {
58 close_nointr_nofail(b->input_fd);
60 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
61 close_nointr_nofail(b->output_fd);
63 b->input_fd = b->output_fd = -1;
66 static void bus_node_destroy(sd_bus *b, struct node *n) {
67 struct node_callback *c;
68 struct node_vtable *v;
69 struct node_enumerator *e;
77 bus_node_destroy(b, n->child);
79 while ((c = n->callbacks)) {
80 LIST_REMOVE(callbacks, n->callbacks, c);
84 while ((v = n->vtables)) {
85 LIST_REMOVE(vtables, n->vtables, v);
90 while ((e = n->enumerators)) {
91 LIST_REMOVE(enumerators, n->enumerators, e);
96 LIST_REMOVE(siblings, n->parent->child, n);
98 assert_se(hashmap_remove(b->nodes, n->path) == n);
103 static void bus_reset_queues(sd_bus *b) {
108 for (i = 0; i < b->rqueue_size; i++)
109 sd_bus_message_unref(b->rqueue[i]);
112 for (i = 0; i < b->wqueue_size; i++)
113 sd_bus_message_unref(b->wqueue[i]);
116 b->rqueue = b->wqueue = NULL;
117 b->rqueue_size = b->wqueue_size = 0;
120 static void bus_free(sd_bus *b) {
121 struct filter_callback *f;
126 sd_bus_detach_event(b);
131 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
134 free(b->unique_name);
135 free(b->auth_buffer);
141 strv_free(b->exec_argv);
143 close_many(b->fds, b->n_fds);
148 hashmap_free_free(b->reply_callbacks);
149 prioq_free(b->reply_callbacks_prioq);
151 while ((f = b->filter_callbacks)) {
152 LIST_REMOVE(callbacks, b->filter_callbacks, f);
156 bus_match_free(&b->match_callbacks);
158 hashmap_free_free(b->vtable_methods);
159 hashmap_free_free(b->vtable_properties);
161 while ((n = hashmap_first(b->nodes)))
162 bus_node_destroy(b, n);
164 hashmap_free(b->nodes);
166 bus_kernel_flush_memfd(b);
168 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
173 _public_ int sd_bus_new(sd_bus **ret) {
176 assert_return(ret, -EINVAL);
182 r->n_ref = REFCNT_INIT;
183 r->input_fd = r->output_fd = -1;
184 r->message_version = 1;
185 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
186 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
187 r->attach_flags |= KDBUS_ATTACH_NAMES;
188 r->original_pid = getpid();
190 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
192 /* We guarantee that wqueue always has space for at least one
194 r->wqueue = new(sd_bus_message*, 1);
204 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
207 assert_return(bus, -EINVAL);
208 assert_return(bus->state == BUS_UNSET, -EPERM);
209 assert_return(address, -EINVAL);
210 assert_return(!bus_pid_changed(bus), -ECHILD);
222 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
223 assert_return(bus, -EINVAL);
224 assert_return(bus->state == BUS_UNSET, -EPERM);
225 assert_return(input_fd >= 0, -EINVAL);
226 assert_return(output_fd >= 0, -EINVAL);
227 assert_return(!bus_pid_changed(bus), -ECHILD);
229 bus->input_fd = input_fd;
230 bus->output_fd = output_fd;
234 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
237 assert_return(bus, -EINVAL);
238 assert_return(bus->state == BUS_UNSET, -EPERM);
239 assert_return(path, -EINVAL);
240 assert_return(!strv_isempty(argv), -EINVAL);
241 assert_return(!bus_pid_changed(bus), -ECHILD);
253 free(bus->exec_path);
254 strv_free(bus->exec_argv);
262 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
263 assert_return(bus, -EINVAL);
264 assert_return(bus->state == BUS_UNSET, -EPERM);
265 assert_return(!bus_pid_changed(bus), -ECHILD);
267 bus->bus_client = !!b;
271 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
272 assert_return(bus, -EINVAL);
273 assert_return(bus->state == BUS_UNSET, -EPERM);
274 assert_return(!bus_pid_changed(bus), -ECHILD);
276 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
280 _public_ int sd_bus_negotiate_attach_timestamp(sd_bus *bus, int b) {
281 assert_return(bus, -EINVAL);
282 assert_return(bus->state == BUS_UNSET, -EPERM);
283 assert_return(!bus_pid_changed(bus), -ECHILD);
285 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
289 _public_ int sd_bus_negotiate_attach_creds(sd_bus *bus, uint64_t mask) {
290 assert_return(bus, -EINVAL);
291 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
292 assert_return(bus->state == BUS_UNSET, -EPERM);
293 assert_return(!bus_pid_changed(bus), -ECHILD);
295 /* The well knowns we need unconditionally, so that matches can work */
296 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
298 return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
301 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
302 assert_return(bus, -EINVAL);
303 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
304 assert_return(bus->state == BUS_UNSET, -EPERM);
305 assert_return(!bus_pid_changed(bus), -ECHILD);
307 bus->is_server = !!b;
308 bus->server_id = server_id;
312 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
313 assert_return(bus, -EINVAL);
314 assert_return(bus->state == BUS_UNSET, -EPERM);
315 assert_return(!bus_pid_changed(bus), -ECHILD);
317 bus->anonymous_auth = !!b;
321 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
322 assert_return(bus, -EINVAL);
323 assert_return(bus->state == BUS_UNSET, -EPERM);
324 assert_return(!bus_pid_changed(bus), -ECHILD);
330 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
335 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
338 r = sd_bus_message_get_errno(reply);
344 r = sd_bus_message_read(reply, "s", &s);
348 if (!service_name_is_valid(s) || s[0] != ':')
351 bus->unique_name = strdup(s);
352 if (!bus->unique_name)
355 if (bus->state == BUS_HELLO)
356 bus->state = BUS_RUNNING;
361 static int bus_send_hello(sd_bus *bus) {
362 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
367 if (!bus->bus_client || bus->is_kernel)
370 r = sd_bus_message_new_method_call(
372 "org.freedesktop.DBus",
374 "org.freedesktop.DBus",
380 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
383 int bus_start_running(sd_bus *bus) {
386 if (bus->bus_client && !bus->is_kernel) {
387 bus->state = BUS_HELLO;
391 bus->state = BUS_RUNNING;
395 static int parse_address_key(const char **p, const char *key, char **value) {
406 if (strncmp(*p, key, l) != 0)
419 while (*a != ';' && *a != ',' && *a != 0) {
437 c = (char) ((x << 4) | y);
444 t = realloc(r, 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;
620 while (**p != 0 && **p != ';') {
621 r = parse_address_key(p, "guid", guid);
627 r = parse_address_key(p, "path", &path);
633 if (startswith(*p, "argv")) {
637 ul = strtoul(*p + 4, (char**) p, 10);
638 if (errno > 0 || **p != '=' || ul > 256) {
648 x = realloc(argv, sizeof(char*) * (ul + 2));
654 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
660 r = parse_address_key(p, NULL, argv + ul);
675 /* Make sure there are no holes in the array, with the
676 * exception of argv[0] */
677 for (j = 1; j < n_argv; j++)
683 if (argv && argv[0] == NULL) {
684 argv[0] = strdup(path);
696 for (j = 0; j < n_argv; j++)
704 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
705 _cleanup_free_ char *path = NULL;
713 while (**p != 0 && **p != ';') {
714 r = parse_address_key(p, "guid", guid);
720 r = parse_address_key(p, "path", &path);
739 static int parse_container_address(sd_bus *b, const char **p, char **guid) {
740 _cleanup_free_ char *machine = NULL;
748 while (**p != 0 && **p != ';') {
749 r = parse_address_key(p, "guid", guid);
755 r = parse_address_key(p, "machine", &machine);
768 b->machine = machine;
771 b->sockaddr.un.sun_family = AF_UNIX;
772 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
773 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
778 static void bus_reset_parsed_address(sd_bus *b) {
782 b->sockaddr_size = 0;
783 strv_free(b->exec_argv);
787 b->server_id = SD_ID128_NULL;
794 static int bus_parse_next_address(sd_bus *b) {
795 _cleanup_free_ char *guid = NULL;
803 if (b->address[b->address_index] == 0)
806 bus_reset_parsed_address(b);
808 a = b->address + b->address_index;
817 if (startswith(a, "unix:")) {
820 r = parse_unix_address(b, &a, &guid);
825 } else if (startswith(a, "tcp:")) {
828 r = parse_tcp_address(b, &a, &guid);
834 } else if (startswith(a, "unixexec:")) {
837 r = parse_exec_address(b, &a, &guid);
843 } else if (startswith(a, "kernel:")) {
846 r = parse_kernel_address(b, &a, &guid);
851 } else if (startswith(a, "x-container:")) {
854 r = parse_container_address(b, &a, &guid);
867 r = sd_id128_from_string(guid, &b->server_id);
872 b->address_index = a - b->address;
876 static int bus_start_address(sd_bus *b) {
886 r = bus_socket_exec(b);
890 b->last_connect_error = -r;
891 } else if (b->kernel) {
893 r = bus_kernel_connect(b);
897 b->last_connect_error = -r;
899 } else if (b->machine) {
901 r = bus_container_connect(b);
905 b->last_connect_error = -r;
907 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
909 r = bus_socket_connect(b);
913 b->last_connect_error = -r;
916 r = bus_parse_next_address(b);
920 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
924 int bus_next_address(sd_bus *b) {
927 bus_reset_parsed_address(b);
928 return bus_start_address(b);
931 static int bus_start_fd(sd_bus *b) {
936 assert(b->input_fd >= 0);
937 assert(b->output_fd >= 0);
939 r = fd_nonblock(b->input_fd, true);
943 r = fd_cloexec(b->input_fd, true);
947 if (b->input_fd != b->output_fd) {
948 r = fd_nonblock(b->output_fd, true);
952 r = fd_cloexec(b->output_fd, true);
957 if (fstat(b->input_fd, &st) < 0)
960 if (S_ISCHR(b->input_fd))
961 return bus_kernel_take_fd(b);
963 return bus_socket_take_fd(b);
966 _public_ int sd_bus_start(sd_bus *bus) {
969 assert_return(bus, -EINVAL);
970 assert_return(bus->state == BUS_UNSET, -EPERM);
971 assert_return(!bus_pid_changed(bus), -ECHILD);
973 bus->state = BUS_OPENING;
975 if (bus->is_server && bus->bus_client)
978 if (bus->input_fd >= 0)
979 r = bus_start_fd(bus);
980 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
981 r = bus_start_address(bus);
988 return bus_send_hello(bus);
991 _public_ int sd_bus_open_system(sd_bus **ret) {
996 assert_return(ret, -EINVAL);
1002 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1004 r = sd_bus_set_address(b, e);
1007 r = sd_bus_set_address(b, "kernel:path=/dev/kdbus/0-system/bus;unix:path=/run/dbus/system_bus_socket");
1009 r = sd_bus_set_address(b, "unix:path=/run/dbus/system_bus_socket");
1015 b->bus_client = true;
1017 /* Let's do per-method access control on the system bus. We
1018 * need the caller's UID and capability set for that. */
1020 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1022 r = sd_bus_start(b);
1034 _public_ int sd_bus_open_user(sd_bus **ret) {
1039 assert_return(ret, -EINVAL);
1045 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1047 r = sd_bus_set_address(b, e);
1051 e = secure_getenv("XDG_RUNTIME_DIR");
1053 _cleanup_free_ char *ee = NULL;
1055 ee = bus_address_escape(e);
1062 asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus;unix:path=%s/bus", (unsigned long) getuid(), ee);
1064 b->address = strjoin("unix:path=", ee, "/bus", NULL);
1068 asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus", (unsigned long) getuid());
1070 return -ECONNREFUSED;
1080 b->bus_client = true;
1082 /* We don't do any per-method access control on the user
1086 r = sd_bus_start(b);
1098 _public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) {
1099 _cleanup_free_ char *e = NULL;
1104 assert_return(host, -EINVAL);
1105 assert_return(ret, -EINVAL);
1107 e = bus_address_escape(host);
1111 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1115 r = sd_bus_new(&bus);
1122 bus->bus_client = true;
1124 r = sd_bus_start(bus);
1134 _public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) {
1135 _cleanup_free_ char *e = NULL;
1140 assert_return(machine, -EINVAL);
1141 assert_return(ret, -EINVAL);
1143 e = bus_address_escape(machine);
1147 p = strjoin("x-container:machine=", e, NULL);
1151 r = sd_bus_new(&bus);
1158 bus->bus_client = true;
1160 r = sd_bus_start(bus);
1170 _public_ void sd_bus_close(sd_bus *bus) {
1174 if (bus->state == BUS_CLOSED)
1176 if (bus_pid_changed(bus))
1179 bus->state = BUS_CLOSED;
1181 sd_bus_detach_event(bus);
1183 /* Drop all queued messages so that they drop references to
1184 * the bus object and the bus may be freed */
1185 bus_reset_queues(bus);
1187 if (!bus->is_kernel)
1190 /* We'll leave the fd open in case this is a kernel bus, since
1191 * there might still be memblocks around that reference this
1192 * bus, and they might need to invoke the * KDBUS_CMD_FREE
1193 * ioctl on the fd when they are freed. */
1196 static void bus_enter_closing(sd_bus *bus) {
1199 if (bus->state != BUS_OPENING &&
1200 bus->state != BUS_AUTHENTICATING &&
1201 bus->state != BUS_HELLO &&
1202 bus->state != BUS_RUNNING)
1205 bus->state = BUS_CLOSING;
1208 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1209 assert_return(bus, NULL);
1211 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1216 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1221 if (REFCNT_DEC(bus->n_ref) <= 0)
1227 _public_ int sd_bus_is_open(sd_bus *bus) {
1229 assert_return(bus, -EINVAL);
1230 assert_return(!bus_pid_changed(bus), -ECHILD);
1232 return BUS_IS_OPEN(bus->state);
1235 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1238 assert_return(bus, -EINVAL);
1239 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1240 assert_return(!bus_pid_changed(bus), -ECHILD);
1242 if (type == SD_BUS_TYPE_UNIX_FD) {
1243 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1246 r = bus_ensure_running(bus);
1250 return bus->can_fds;
1253 return bus_type_is_valid(type);
1256 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1259 assert_return(bus, -EINVAL);
1260 assert_return(server_id, -EINVAL);
1261 assert_return(!bus_pid_changed(bus), -ECHILD);
1263 r = bus_ensure_running(bus);
1267 *server_id = bus->server_id;
1271 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1275 if (m->header->version > b->message_version)
1279 /* If we copy the same message to multiple
1280 * destinations, avoid using the same serial
1282 b->serial = MAX(b->serial, BUS_MESSAGE_SERIAL(m));
1286 return bus_message_seal(m, ++b->serial);
1289 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1293 if (m->header->version > b->message_version)
1296 /* The bus specification says the serial number cannot be 0,
1297 * hence let's fill something in for synthetic messages. Since
1298 * synthetic messages might have a fake sender and we don't
1299 * want to interfere with the real sender's serial numbers we
1300 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1301 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1302 * even though kdbus can do 64bit. */
1304 return bus_message_seal(m, 0xFFFFFFFFULL);
1307 static int bus_write_message(sd_bus *bus, sd_bus_message *message, size_t *idx) {
1312 return bus_kernel_write_message(bus, message);
1314 return bus_socket_write_message(bus, message, idx);
1317 static int dispatch_wqueue(sd_bus *bus) {
1321 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1323 while (bus->wqueue_size > 0) {
1325 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1329 /* Didn't do anything this time */
1331 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1332 /* Fully written. Let's drop the entry from
1335 * This isn't particularly optimized, but
1336 * well, this is supposed to be our worst-case
1337 * buffer only, and the socket buffer is
1338 * supposed to be our primary buffer, and if
1339 * it got full, then all bets are off
1342 sd_bus_message_unref(bus->wqueue[0]);
1343 bus->wqueue_size --;
1344 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1354 static int bus_read_message(sd_bus *bus) {
1358 return bus_kernel_read_message(bus);
1360 return bus_socket_read_message(bus);
1363 int bus_rqueue_make_room(sd_bus *bus) {
1367 x = bus->rqueue_size + 1;
1369 if (bus->rqueue_allocated >= x)
1372 if (x > BUS_RQUEUE_MAX)
1375 q = realloc(bus->rqueue, x * sizeof(sd_bus_message*));
1380 bus->rqueue_allocated = x;
1385 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1390 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1393 if (bus->rqueue_size > 0) {
1394 /* Dispatch a queued message */
1396 *m = bus->rqueue[0];
1397 bus->rqueue_size --;
1398 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1402 /* Try to read a new message */
1403 r = bus_read_message(bus);
1413 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1416 assert_return(bus, -EINVAL);
1417 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1418 assert_return(m, -EINVAL);
1419 assert_return(!bus_pid_changed(bus), -ECHILD);
1422 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1429 /* If the serial number isn't kept, then we know that no reply
1431 if (!serial && !m->sealed)
1432 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1434 r = bus_seal_message(bus, m);
1438 /* If this is a reply and no reply was requested, then let's
1439 * suppress this, if we can */
1440 if (m->dont_send && !serial)
1443 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1446 r = bus_write_message(bus, m, &idx);
1448 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1449 bus_enter_closing(bus);
1452 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1453 /* Wasn't fully written. So let's remember how
1454 * much was written. Note that the first entry
1455 * of the wqueue array is always allocated so
1456 * that we always can remember how much was
1458 bus->wqueue[0] = sd_bus_message_ref(m);
1459 bus->wqueue_size = 1;
1465 /* Just append it to the queue. */
1467 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1470 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1475 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1479 *serial = BUS_MESSAGE_SERIAL(m);
1484 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *serial) {
1487 assert_return(bus, -EINVAL);
1488 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1489 assert_return(m, -EINVAL);
1490 assert_return(!bus_pid_changed(bus), -ECHILD);
1492 if (!streq_ptr(m->destination, destination)) {
1497 r = sd_bus_message_set_destination(m, destination);
1502 return sd_bus_send(bus, m, serial);
1505 static usec_t calc_elapse(uint64_t usec) {
1506 if (usec == (uint64_t) -1)
1510 usec = BUS_DEFAULT_TIMEOUT;
1512 return now(CLOCK_MONOTONIC) + usec;
1515 static int timeout_compare(const void *a, const void *b) {
1516 const struct reply_callback *x = a, *y = b;
1518 if (x->timeout != 0 && y->timeout == 0)
1521 if (x->timeout == 0 && y->timeout != 0)
1524 if (x->timeout < y->timeout)
1527 if (x->timeout > y->timeout)
1533 _public_ int sd_bus_call_async(
1536 sd_bus_message_handler_t callback,
1541 struct reply_callback *c;
1544 assert_return(bus, -EINVAL);
1545 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1546 assert_return(m, -EINVAL);
1547 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1548 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1549 assert_return(callback, -EINVAL);
1550 assert_return(!bus_pid_changed(bus), -ECHILD);
1552 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1556 if (usec != (uint64_t) -1) {
1557 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1562 r = bus_seal_message(bus, m);
1566 c = new0(struct reply_callback, 1);
1570 c->callback = callback;
1571 c->userdata = userdata;
1572 c->serial = BUS_MESSAGE_SERIAL(m);
1573 c->timeout = calc_elapse(usec);
1575 r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1581 if (c->timeout != 0) {
1582 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1585 sd_bus_call_async_cancel(bus, c->serial);
1590 r = sd_bus_send(bus, m, serial);
1592 sd_bus_call_async_cancel(bus, c->serial);
1599 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t serial) {
1600 struct reply_callback *c;
1602 assert_return(bus, -EINVAL);
1603 assert_return(serial != 0, -EINVAL);
1604 assert_return(!bus_pid_changed(bus), -ECHILD);
1606 c = hashmap_remove(bus->reply_callbacks, &serial);
1610 if (c->timeout != 0)
1611 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1617 int bus_ensure_running(sd_bus *bus) {
1622 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1624 if (bus->state == BUS_RUNNING)
1628 r = sd_bus_process(bus, NULL);
1631 if (bus->state == BUS_RUNNING)
1636 r = sd_bus_wait(bus, (uint64_t) -1);
1642 _public_ int sd_bus_call(
1646 sd_bus_error *error,
1647 sd_bus_message **reply) {
1654 assert_return(bus, -EINVAL);
1655 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1656 assert_return(m, -EINVAL);
1657 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1658 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1659 assert_return(!bus_error_is_dirty(error), -EINVAL);
1660 assert_return(!bus_pid_changed(bus), -ECHILD);
1662 r = bus_ensure_running(bus);
1666 i = bus->rqueue_size;
1668 r = sd_bus_send(bus, m, &serial);
1672 timeout = calc_elapse(usec);
1677 while (i < bus->rqueue_size) {
1678 sd_bus_message *incoming = NULL;
1680 incoming = bus->rqueue[i];
1682 if (incoming->reply_serial == serial) {
1683 /* Found a match! */
1685 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1688 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1693 sd_bus_message_unref(incoming);
1696 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1697 r = sd_bus_error_copy(error, &incoming->error);
1701 sd_bus_message_unref(incoming);
1704 } else if (incoming->header->serial == serial &&
1707 streq(bus->unique_name, incoming->sender)) {
1709 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1712 /* Our own message? Somebody is trying
1713 * to send its own client a message,
1714 * let's not dead-lock, let's fail
1717 sd_bus_message_unref(incoming);
1721 /* Try to read more, right-away */
1725 r = bus_read_message(bus);
1727 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1728 bus_enter_closing(bus);
1738 n = now(CLOCK_MONOTONIC);
1744 left = (uint64_t) -1;
1746 r = bus_poll(bus, true, left);
1750 r = dispatch_wqueue(bus);
1752 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1753 bus_enter_closing(bus);
1760 _public_ int sd_bus_get_fd(sd_bus *bus) {
1762 assert_return(bus, -EINVAL);
1763 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1764 assert_return(!bus_pid_changed(bus), -ECHILD);
1766 return bus->input_fd;
1769 _public_ int sd_bus_get_events(sd_bus *bus) {
1772 assert_return(bus, -EINVAL);
1773 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1774 assert_return(!bus_pid_changed(bus), -ECHILD);
1776 if (bus->state == BUS_OPENING)
1778 else if (bus->state == BUS_AUTHENTICATING) {
1780 if (bus_socket_auth_needs_write(bus))
1785 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1786 if (bus->rqueue_size <= 0)
1788 if (bus->wqueue_size > 0)
1795 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1796 struct reply_callback *c;
1798 assert_return(bus, -EINVAL);
1799 assert_return(timeout_usec, -EINVAL);
1800 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1801 assert_return(!bus_pid_changed(bus), -ECHILD);
1803 if (bus->state == BUS_CLOSING) {
1808 if (bus->state == BUS_AUTHENTICATING) {
1809 *timeout_usec = bus->auth_timeout;
1813 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1814 *timeout_usec = (uint64_t) -1;
1818 if (bus->rqueue_size > 0) {
1823 c = prioq_peek(bus->reply_callbacks_prioq);
1825 *timeout_usec = (uint64_t) -1;
1829 *timeout_usec = c->timeout;
1833 static int process_timeout(sd_bus *bus) {
1834 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1835 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1836 struct reply_callback *c;
1842 c = prioq_peek(bus->reply_callbacks_prioq);
1846 n = now(CLOCK_MONOTONIC);
1850 r = bus_message_new_synthetic_error(
1853 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
1858 m->sender = "org.freedesktop.DBus";
1860 r = bus_seal_synthetic_message(bus, m);
1864 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1865 hashmap_remove(bus->reply_callbacks, &c->serial);
1868 bus->iteration_counter ++;
1870 r = c->callback(bus, m, c->userdata, &error_buffer);
1871 r = bus_maybe_reply_error(m, r, &error_buffer);
1874 bus->current = NULL;
1879 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1883 if (bus->state != BUS_HELLO)
1886 /* Let's make sure the first message on the bus is the HELLO
1887 * reply. But note that we don't actually parse the message
1888 * here (we leave that to the usual handling), we just verify
1889 * we don't let any earlier msg through. */
1891 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1892 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1895 if (m->reply_serial != bus->hello_serial)
1901 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1902 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1903 struct reply_callback *c;
1909 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1910 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1913 c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1917 if (c->timeout != 0)
1918 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1920 r = sd_bus_message_rewind(m, true);
1924 r = c->callback(bus, m, c->userdata, &error_buffer);
1925 r = bus_maybe_reply_error(m, r, &error_buffer);
1931 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1932 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1933 struct filter_callback *l;
1940 bus->filter_callbacks_modified = false;
1942 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1944 if (bus->filter_callbacks_modified)
1947 /* Don't run this more than once per iteration */
1948 if (l->last_iteration == bus->iteration_counter)
1951 l->last_iteration = bus->iteration_counter;
1953 r = sd_bus_message_rewind(m, true);
1957 r = l->callback(bus, m, l->userdata, &error_buffer);
1958 r = bus_maybe_reply_error(m, r, &error_buffer);
1964 } while (bus->filter_callbacks_modified);
1969 static int process_match(sd_bus *bus, sd_bus_message *m) {
1976 bus->match_callbacks_modified = false;
1978 r = bus_match_run(bus, &bus->match_callbacks, m);
1982 } while (bus->match_callbacks_modified);
1987 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1988 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1994 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1997 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2000 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2003 if (streq_ptr(m->member, "Ping"))
2004 r = sd_bus_message_new_method_return(m, &reply);
2005 else if (streq_ptr(m->member, "GetMachineId")) {
2009 r = sd_id128_get_machine(&id);
2013 r = sd_bus_message_new_method_return(m, &reply);
2017 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2019 r = sd_bus_message_new_method_errorf(
2021 SD_BUS_ERROR_UNKNOWN_METHOD,
2022 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2028 r = sd_bus_send(bus, reply, NULL);
2035 static int process_message(sd_bus *bus, sd_bus_message *m) {
2042 bus->iteration_counter++;
2044 log_debug("Got message sender=%s object=%s interface=%s member=%s",
2045 strna(sd_bus_message_get_sender(m)),
2046 strna(sd_bus_message_get_path(m)),
2047 strna(sd_bus_message_get_interface(m)),
2048 strna(sd_bus_message_get_member(m)));
2050 r = process_hello(bus, m);
2054 r = process_reply(bus, m);
2058 r = process_filter(bus, m);
2062 r = process_match(bus, m);
2066 r = process_builtin(bus, m);
2070 r = bus_process_object(bus, m);
2073 bus->current = NULL;
2077 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2078 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2082 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2084 r = process_timeout(bus);
2088 r = dispatch_wqueue(bus);
2092 r = dispatch_rqueue(bus, &m);
2098 r = process_message(bus, m);
2103 r = sd_bus_message_rewind(m, true);
2112 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2114 r = sd_bus_reply_method_errorf(
2116 SD_BUS_ERROR_UNKNOWN_OBJECT,
2117 "Unknown object '%s'.", m->path);
2131 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2132 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2133 struct reply_callback *c;
2137 assert(bus->state == BUS_CLOSING);
2139 c = hashmap_first(bus->reply_callbacks);
2141 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2143 /* First, fail all outstanding method calls */
2144 r = bus_message_new_synthetic_error(
2147 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2152 r = bus_seal_synthetic_message(bus, m);
2156 if (c->timeout != 0)
2157 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2159 hashmap_remove(bus->reply_callbacks, &c->serial);
2162 bus->iteration_counter++;
2164 r = c->callback(bus, m, c->userdata, &error_buffer);
2165 r = bus_maybe_reply_error(m, r, &error_buffer);
2171 /* Then, synthesize a Disconnected message */
2172 r = sd_bus_message_new_signal(
2174 "/org/freedesktop/DBus/Local",
2175 "org.freedesktop.DBus.Local",
2181 m->sender = "org.freedesktop.DBus.Local";
2183 r = bus_seal_synthetic_message(bus, m);
2190 bus->iteration_counter++;
2192 r = process_filter(bus, m);
2196 r = process_match(bus, m);
2208 bus->current = NULL;
2212 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2213 BUS_DONT_DESTROY(bus);
2216 /* Returns 0 when we didn't do anything. This should cause the
2217 * caller to invoke sd_bus_wait() before returning the next
2218 * time. Returns > 0 when we did something, which possibly
2219 * means *ret is filled in with an unprocessed message. */
2221 assert_return(bus, -EINVAL);
2222 assert_return(!bus_pid_changed(bus), -ECHILD);
2224 /* We don't allow recursively invoking sd_bus_process(). */
2225 assert_return(!bus->current, -EBUSY);
2227 switch (bus->state) {
2234 r = bus_socket_process_opening(bus);
2235 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2236 bus_enter_closing(bus);
2244 case BUS_AUTHENTICATING:
2245 r = bus_socket_process_authenticating(bus);
2246 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2247 bus_enter_closing(bus);
2259 r = process_running(bus, ret);
2260 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2261 bus_enter_closing(bus);
2271 return process_closing(bus, ret);
2274 assert_not_reached("Unknown state");
2277 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2278 struct pollfd p[2] = {};
2281 usec_t m = (usec_t) -1;
2285 if (bus->state == BUS_CLOSING)
2288 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2290 e = sd_bus_get_events(bus);
2295 /* The caller really needs some more data, he doesn't
2296 * care about what's already read, or any timeouts
2301 /* The caller wants to process if there's something to
2302 * process, but doesn't care otherwise */
2304 r = sd_bus_get_timeout(bus, &until);
2309 nw = now(CLOCK_MONOTONIC);
2310 m = until > nw ? until - nw : 0;
2314 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2317 p[0].fd = bus->input_fd;
2318 if (bus->output_fd == bus->input_fd) {
2322 p[0].events = e & POLLIN;
2323 p[1].fd = bus->output_fd;
2324 p[1].events = e & POLLOUT;
2328 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2332 return r > 0 ? 1 : 0;
2335 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2337 assert_return(bus, -EINVAL);
2338 assert_return(!bus_pid_changed(bus), -ECHILD);
2340 if (bus->state == BUS_CLOSING)
2343 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2345 if (bus->rqueue_size > 0)
2348 return bus_poll(bus, false, timeout_usec);
2351 _public_ int sd_bus_flush(sd_bus *bus) {
2354 assert_return(bus, -EINVAL);
2355 assert_return(!bus_pid_changed(bus), -ECHILD);
2357 if (bus->state == BUS_CLOSING)
2360 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2362 r = bus_ensure_running(bus);
2366 if (bus->wqueue_size <= 0)
2370 r = dispatch_wqueue(bus);
2372 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
2373 bus_enter_closing(bus);
2378 if (bus->wqueue_size <= 0)
2381 r = bus_poll(bus, false, (uint64_t) -1);
2387 _public_ int sd_bus_add_filter(sd_bus *bus,
2388 sd_bus_message_handler_t callback,
2391 struct filter_callback *f;
2393 assert_return(bus, -EINVAL);
2394 assert_return(callback, -EINVAL);
2395 assert_return(!bus_pid_changed(bus), -ECHILD);
2397 f = new0(struct filter_callback, 1);
2400 f->callback = callback;
2401 f->userdata = userdata;
2403 bus->filter_callbacks_modified = true;
2404 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2408 _public_ int sd_bus_remove_filter(sd_bus *bus,
2409 sd_bus_message_handler_t callback,
2412 struct filter_callback *f;
2414 assert_return(bus, -EINVAL);
2415 assert_return(callback, -EINVAL);
2416 assert_return(!bus_pid_changed(bus), -ECHILD);
2418 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2419 if (f->callback == callback && f->userdata == userdata) {
2420 bus->filter_callbacks_modified = true;
2421 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2430 _public_ int sd_bus_add_match(sd_bus *bus,
2432 sd_bus_message_handler_t callback,
2435 struct bus_match_component *components = NULL;
2436 unsigned n_components = 0;
2437 uint64_t cookie = 0;
2440 assert_return(bus, -EINVAL);
2441 assert_return(match, -EINVAL);
2442 assert_return(!bus_pid_changed(bus), -ECHILD);
2444 r = bus_match_parse(match, &components, &n_components);
2448 if (bus->bus_client) {
2449 cookie = ++bus->match_cookie;
2451 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2456 bus->match_callbacks_modified = true;
2457 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2459 if (bus->bus_client)
2460 bus_remove_match_internal(bus, match, cookie);
2464 bus_match_parse_free(components, n_components);
2468 _public_ int sd_bus_remove_match(sd_bus *bus,
2470 sd_bus_message_handler_t callback,
2473 struct bus_match_component *components = NULL;
2474 unsigned n_components = 0;
2476 uint64_t cookie = 0;
2478 assert_return(bus, -EINVAL);
2479 assert_return(match, -EINVAL);
2480 assert_return(!bus_pid_changed(bus), -ECHILD);
2482 r = bus_match_parse(match, &components, &n_components);
2486 bus->match_callbacks_modified = true;
2487 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2489 if (bus->bus_client)
2490 q = bus_remove_match_internal(bus, match, cookie);
2492 bus_match_parse_free(components, n_components);
2494 return r < 0 ? r : q;
2497 bool bus_pid_changed(sd_bus *bus) {
2500 /* We don't support people creating a bus connection and
2501 * keeping it around over a fork(). Let's complain. */
2503 return bus->original_pid != getpid();
2506 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2507 sd_bus *bus = userdata;
2512 r = sd_bus_process(bus, NULL);
2519 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2520 sd_bus *bus = userdata;
2525 r = sd_bus_process(bus, NULL);
2532 static int prepare_callback(sd_event_source *s, void *userdata) {
2533 sd_bus *bus = userdata;
2540 e = sd_bus_get_events(bus);
2544 if (bus->output_fd != bus->input_fd) {
2546 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2550 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2554 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2559 r = sd_bus_get_timeout(bus, &until);
2565 j = sd_event_source_set_time(bus->time_event_source, until);
2570 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2577 static int quit_callback(sd_event_source *event, void *userdata) {
2578 sd_bus *bus = userdata;
2587 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2590 assert_return(bus, -EINVAL);
2591 assert_return(!bus->event, -EBUSY);
2593 assert(!bus->input_io_event_source);
2594 assert(!bus->output_io_event_source);
2595 assert(!bus->time_event_source);
2598 bus->event = sd_event_ref(event);
2600 r = sd_event_default(&bus->event);
2605 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2609 r = sd_event_source_set_priority(bus->input_io_event_source, priority);
2613 if (bus->output_fd != bus->input_fd) {
2614 r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2618 r = sd_event_source_set_priority(bus->output_io_event_source, priority);
2623 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2627 r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2631 r = sd_event_source_set_priority(bus->time_event_source, priority);
2635 r = sd_event_add_quit(bus->event, quit_callback, bus, &bus->quit_event_source);
2642 sd_bus_detach_event(bus);
2646 _public_ int sd_bus_detach_event(sd_bus *bus) {
2647 assert_return(bus, -EINVAL);
2648 assert_return(bus->event, -ENXIO);
2650 if (bus->input_io_event_source) {
2651 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2652 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2655 if (bus->output_io_event_source) {
2656 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2657 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2660 if (bus->time_event_source) {
2661 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2662 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2665 if (bus->quit_event_source) {
2666 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2667 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2671 bus->event = sd_event_unref(bus->event);
2676 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2677 assert_return(bus, NULL);
2682 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2683 assert_return(bus, NULL);
2685 return bus->current;
2688 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2693 assert(default_bus);
2696 return !!*default_bus;
2699 *ret = sd_bus_ref(*default_bus);
2707 b->default_bus_ptr = default_bus;
2715 _public_ int sd_bus_default_system(sd_bus **ret) {
2716 static __thread sd_bus *default_system_bus = NULL;
2718 return bus_default(sd_bus_open_system, &default_system_bus, ret);
2721 _public_ int sd_bus_default_user(sd_bus **ret) {
2722 static __thread sd_bus *default_user_bus = NULL;
2724 return bus_default(sd_bus_open_user, &default_user_bus, ret);
2727 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2728 assert_return(b, -EINVAL);
2729 assert_return(tid, -EINVAL);
2730 assert_return(!bus_pid_changed(b), -ECHILD);
2738 return sd_event_get_tid(b->event, tid);
2743 _public_ char *sd_bus_label_escape(const char *s) {
2747 assert_return(s, NULL);
2749 /* Escapes all chars that D-Bus' object path cannot deal
2750 * with. Can be reversed with bus_path_unescape(). We special
2751 * case the empty string. */
2756 r = new(char, strlen(s)*3 + 1);
2760 for (f = s, t = r; *f; f++) {
2762 /* Escape everything that is not a-zA-Z0-9. We also
2763 * escape 0-9 if it's the first character */
2765 if (!(*f >= 'A' && *f <= 'Z') &&
2766 !(*f >= 'a' && *f <= 'z') &&
2767 !(f > s && *f >= '0' && *f <= '9')) {
2769 *(t++) = hexchar(*f >> 4);
2770 *(t++) = hexchar(*f);
2780 _public_ char *sd_bus_label_unescape(const char *f) {
2783 assert_return(f, NULL);
2785 /* Special case for the empty string */
2789 r = new(char, strlen(f) + 1);
2793 for (t = r; *f; f++) {
2798 if ((a = unhexchar(f[1])) < 0 ||
2799 (b = unhexchar(f[2])) < 0) {
2800 /* Invalid escape code, let's take it literal then */
2803 *(t++) = (char) ((a << 4) | b);
2815 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
2820 assert_return(bus, -EINVAL);
2821 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
2822 assert_return(ret, -EINVAL);
2823 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2824 assert_return(!bus_pid_changed(bus), -ECHILD);
2825 assert_return(!bus->is_kernel, -ENOTSUP);
2827 if (!bus->ucred_valid && !isempty(bus->label))
2830 c = bus_creds_new();
2834 if (bus->ucred_valid) {
2835 pid = c->pid = bus->ucred.pid;
2836 c->uid = bus->ucred.uid;
2837 c->gid = bus->ucred.gid;
2839 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
2842 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
2843 c->label = strdup(bus->label);
2845 sd_bus_creds_unref(c);
2849 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
2852 r = bus_creds_add_more(c, mask, pid, 0);