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 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
326 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
329 r = sd_bus_message_get_errno(reply);
335 r = sd_bus_message_read(reply, "s", &s);
339 if (!service_name_is_valid(s) || s[0] != ':')
342 bus->unique_name = strdup(s);
343 if (!bus->unique_name)
346 if (bus->state == BUS_HELLO)
347 bus->state = BUS_RUNNING;
352 static int bus_send_hello(sd_bus *bus) {
353 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
358 if (!bus->bus_client || bus->is_kernel)
361 r = sd_bus_message_new_method_call(
363 "org.freedesktop.DBus",
365 "org.freedesktop.DBus",
371 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
374 int bus_start_running(sd_bus *bus) {
377 if (bus->bus_client && !bus->is_kernel) {
378 bus->state = BUS_HELLO;
382 bus->state = BUS_RUNNING;
386 static int parse_address_key(const char **p, const char *key, char **value) {
397 if (strncmp(*p, key, l) != 0)
410 while (*a != ';' && *a != ',' && *a != 0) {
428 c = (char) ((x << 4) | y);
435 t = realloc(r, n + 2);
463 static void skip_address_key(const char **p) {
467 *p += strcspn(*p, ",");
473 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
474 _cleanup_free_ char *path = NULL, *abstract = NULL;
483 while (**p != 0 && **p != ';') {
484 r = parse_address_key(p, "guid", guid);
490 r = parse_address_key(p, "path", &path);
496 r = parse_address_key(p, "abstract", &abstract);
505 if (!path && !abstract)
508 if (path && abstract)
513 if (l > sizeof(b->sockaddr.un.sun_path))
516 b->sockaddr.un.sun_family = AF_UNIX;
517 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
518 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
519 } else if (abstract) {
520 l = strlen(abstract);
521 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
524 b->sockaddr.un.sun_family = AF_UNIX;
525 b->sockaddr.un.sun_path[0] = 0;
526 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
527 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
533 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
534 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
536 struct addrinfo *result, hints = {
537 .ai_socktype = SOCK_STREAM,
538 .ai_flags = AI_ADDRCONFIG,
546 while (**p != 0 && **p != ';') {
547 r = parse_address_key(p, "guid", guid);
553 r = parse_address_key(p, "host", &host);
559 r = parse_address_key(p, "port", &port);
565 r = parse_address_key(p, "family", &family);
578 if (streq(family, "ipv4"))
579 hints.ai_family = AF_INET;
580 else if (streq(family, "ipv6"))
581 hints.ai_family = AF_INET6;
586 r = getaddrinfo(host, port, &hints, &result);
590 return -EADDRNOTAVAIL;
592 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
593 b->sockaddr_size = result->ai_addrlen;
595 freeaddrinfo(result);
600 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
602 unsigned n_argv = 0, j;
611 while (**p != 0 && **p != ';') {
612 r = parse_address_key(p, "guid", guid);
618 r = parse_address_key(p, "path", &path);
624 if (startswith(*p, "argv")) {
628 ul = strtoul(*p + 4, (char**) p, 10);
629 if (errno > 0 || **p != '=' || ul > 256) {
639 x = realloc(argv, sizeof(char*) * (ul + 2));
645 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
651 r = parse_address_key(p, NULL, argv + ul);
666 /* Make sure there are no holes in the array, with the
667 * exception of argv[0] */
668 for (j = 1; j < n_argv; j++)
674 if (argv && argv[0] == NULL) {
675 argv[0] = strdup(path);
687 for (j = 0; j < n_argv; j++)
695 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
696 _cleanup_free_ char *path = NULL;
704 while (**p != 0 && **p != ';') {
705 r = parse_address_key(p, "guid", guid);
711 r = parse_address_key(p, "path", &path);
730 static int parse_container_address(sd_bus *b, const char **p, char **guid) {
731 _cleanup_free_ char *machine = NULL;
739 while (**p != 0 && **p != ';') {
740 r = parse_address_key(p, "guid", guid);
746 r = parse_address_key(p, "machine", &machine);
759 b->machine = machine;
762 b->sockaddr.un.sun_family = AF_UNIX;
763 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
764 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
769 static void bus_reset_parsed_address(sd_bus *b) {
773 b->sockaddr_size = 0;
774 strv_free(b->exec_argv);
778 b->server_id = SD_ID128_NULL;
785 static int bus_parse_next_address(sd_bus *b) {
786 _cleanup_free_ char *guid = NULL;
794 if (b->address[b->address_index] == 0)
797 bus_reset_parsed_address(b);
799 a = b->address + b->address_index;
808 if (startswith(a, "unix:")) {
811 r = parse_unix_address(b, &a, &guid);
816 } else if (startswith(a, "tcp:")) {
819 r = parse_tcp_address(b, &a, &guid);
825 } else if (startswith(a, "unixexec:")) {
828 r = parse_exec_address(b, &a, &guid);
834 } else if (startswith(a, "kernel:")) {
837 r = parse_kernel_address(b, &a, &guid);
842 } else if (startswith(a, "x-container:")) {
845 r = parse_container_address(b, &a, &guid);
858 r = sd_id128_from_string(guid, &b->server_id);
863 b->address_index = a - b->address;
867 static int bus_start_address(sd_bus *b) {
877 r = bus_socket_exec(b);
881 b->last_connect_error = -r;
882 } else if (b->kernel) {
884 r = bus_kernel_connect(b);
888 b->last_connect_error = -r;
890 } else if (b->machine) {
892 r = bus_container_connect(b);
896 b->last_connect_error = -r;
898 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
900 r = bus_socket_connect(b);
904 b->last_connect_error = -r;
907 r = bus_parse_next_address(b);
911 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
915 int bus_next_address(sd_bus *b) {
918 bus_reset_parsed_address(b);
919 return bus_start_address(b);
922 static int bus_start_fd(sd_bus *b) {
927 assert(b->input_fd >= 0);
928 assert(b->output_fd >= 0);
930 r = fd_nonblock(b->input_fd, true);
934 r = fd_cloexec(b->input_fd, true);
938 if (b->input_fd != b->output_fd) {
939 r = fd_nonblock(b->output_fd, true);
943 r = fd_cloexec(b->output_fd, true);
948 if (fstat(b->input_fd, &st) < 0)
951 if (S_ISCHR(b->input_fd))
952 return bus_kernel_take_fd(b);
954 return bus_socket_take_fd(b);
957 _public_ int sd_bus_start(sd_bus *bus) {
960 assert_return(bus, -EINVAL);
961 assert_return(bus->state == BUS_UNSET, -EPERM);
962 assert_return(!bus_pid_changed(bus), -ECHILD);
964 bus->state = BUS_OPENING;
966 if (bus->is_server && bus->bus_client)
969 if (bus->input_fd >= 0)
970 r = bus_start_fd(bus);
971 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
972 r = bus_start_address(bus);
979 return bus_send_hello(bus);
982 _public_ int sd_bus_open_system(sd_bus **ret) {
987 assert_return(ret, -EINVAL);
993 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
995 r = sd_bus_set_address(b, e);
998 r = sd_bus_set_address(b, "kernel:path=/dev/kdbus/0-system/bus;unix:path=/run/dbus/system_bus_socket");
1000 r = sd_bus_set_address(b, "unix:path=/run/dbus/system_bus_socket");
1006 b->bus_client = true;
1008 r = sd_bus_start(b);
1020 _public_ int sd_bus_open_user(sd_bus **ret) {
1025 assert_return(ret, -EINVAL);
1031 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1033 r = sd_bus_set_address(b, e);
1037 e = secure_getenv("XDG_RUNTIME_DIR");
1039 _cleanup_free_ char *ee = NULL;
1041 ee = bus_address_escape(e);
1048 asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus;unix:path=%s/bus", (unsigned long) getuid(), ee);
1050 b->address = strjoin("unix:path=", ee, "/bus", NULL);
1054 asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus", (unsigned long) getuid());
1056 return -ECONNREFUSED;
1066 b->bus_client = true;
1068 r = sd_bus_start(b);
1080 _public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) {
1081 _cleanup_free_ char *e = NULL;
1086 assert_return(host, -EINVAL);
1087 assert_return(ret, -EINVAL);
1089 e = bus_address_escape(host);
1093 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1097 r = sd_bus_new(&bus);
1104 bus->bus_client = true;
1106 r = sd_bus_start(bus);
1116 _public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) {
1117 _cleanup_free_ char *e = NULL;
1122 assert_return(machine, -EINVAL);
1123 assert_return(ret, -EINVAL);
1125 e = bus_address_escape(machine);
1129 p = strjoin("x-container:machine=", e, NULL);
1133 r = sd_bus_new(&bus);
1140 bus->bus_client = true;
1142 r = sd_bus_start(bus);
1152 _public_ void sd_bus_close(sd_bus *bus) {
1156 if (bus->state == BUS_CLOSED)
1158 if (bus_pid_changed(bus))
1161 bus->state = BUS_CLOSED;
1163 sd_bus_detach_event(bus);
1165 /* Drop all queued messages so that they drop references to
1166 * the bus object and the bus may be freed */
1167 bus_reset_queues(bus);
1169 if (!bus->is_kernel)
1172 /* We'll leave the fd open in case this is a kernel bus, since
1173 * there might still be memblocks around that reference this
1174 * bus, and they might need to invoke the * KDBUS_CMD_FREE
1175 * ioctl on the fd when they are freed. */
1178 static void bus_enter_closing(sd_bus *bus) {
1181 if (bus->state != BUS_OPENING &&
1182 bus->state != BUS_AUTHENTICATING &&
1183 bus->state != BUS_HELLO &&
1184 bus->state != BUS_RUNNING)
1187 bus->state = BUS_CLOSING;
1190 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1191 assert_return(bus, NULL);
1193 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1198 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1199 assert_return(bus, NULL);
1201 if (REFCNT_DEC(bus->n_ref) <= 0)
1207 _public_ int sd_bus_is_open(sd_bus *bus) {
1209 assert_return(bus, -EINVAL);
1210 assert_return(!bus_pid_changed(bus), -ECHILD);
1212 return BUS_IS_OPEN(bus->state);
1215 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1218 assert_return(bus, -EINVAL);
1219 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1220 assert_return(!bus_pid_changed(bus), -ECHILD);
1222 if (type == SD_BUS_TYPE_UNIX_FD) {
1223 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1226 r = bus_ensure_running(bus);
1230 return bus->can_fds;
1233 return bus_type_is_valid(type);
1236 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1239 assert_return(bus, -EINVAL);
1240 assert_return(server_id, -EINVAL);
1241 assert_return(!bus_pid_changed(bus), -ECHILD);
1243 r = bus_ensure_running(bus);
1247 *server_id = bus->server_id;
1251 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1255 if (m->header->version > b->message_version)
1259 /* If we copy the same message to multiple
1260 * destinations, avoid using the same serial
1262 b->serial = MAX(b->serial, BUS_MESSAGE_SERIAL(m));
1266 return bus_message_seal(m, ++b->serial);
1269 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1273 if (m->header->version > b->message_version)
1276 /* The bus specification says the serial number cannot be 0,
1277 * hence let's fill something in for synthetic messages. Since
1278 * synthetic messages might have a fake sender and we don't
1279 * want to interfere with the real sender's serial numbers we
1280 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1281 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1282 * even though kdbus can do 64bit. */
1284 return bus_message_seal(m, 0xFFFFFFFFULL);
1287 static int bus_write_message(sd_bus *bus, sd_bus_message *message, size_t *idx) {
1292 return bus_kernel_write_message(bus, message);
1294 return bus_socket_write_message(bus, message, idx);
1297 static int dispatch_wqueue(sd_bus *bus) {
1301 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1303 while (bus->wqueue_size > 0) {
1305 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1309 /* Didn't do anything this time */
1311 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1312 /* Fully written. Let's drop the entry from
1315 * This isn't particularly optimized, but
1316 * well, this is supposed to be our worst-case
1317 * buffer only, and the socket buffer is
1318 * supposed to be our primary buffer, and if
1319 * it got full, then all bets are off
1322 sd_bus_message_unref(bus->wqueue[0]);
1323 bus->wqueue_size --;
1324 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1334 static int bus_read_message(sd_bus *bus) {
1338 return bus_kernel_read_message(bus);
1340 return bus_socket_read_message(bus);
1343 int bus_rqueue_make_room(sd_bus *bus) {
1347 x = bus->rqueue_size + 1;
1349 if (bus->rqueue_allocated >= x)
1352 if (x > BUS_RQUEUE_MAX)
1355 q = realloc(bus->rqueue, x * sizeof(sd_bus_message*));
1360 bus->rqueue_allocated = x;
1365 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1370 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1373 if (bus->rqueue_size > 0) {
1374 /* Dispatch a queued message */
1376 *m = bus->rqueue[0];
1377 bus->rqueue_size --;
1378 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1382 /* Try to read a new message */
1383 r = bus_read_message(bus);
1393 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1396 assert_return(bus, -EINVAL);
1397 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1398 assert_return(m, -EINVAL);
1399 assert_return(!bus_pid_changed(bus), -ECHILD);
1402 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1409 /* If the serial number isn't kept, then we know that no reply
1411 if (!serial && !m->sealed)
1412 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1414 r = bus_seal_message(bus, m);
1418 /* If this is a reply and no reply was requested, then let's
1419 * suppress this, if we can */
1420 if (m->dont_send && !serial)
1423 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1426 r = bus_write_message(bus, m, &idx);
1428 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1429 bus_enter_closing(bus);
1432 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1433 /* Wasn't fully written. So let's remember how
1434 * much was written. Note that the first entry
1435 * of the wqueue array is always allocated so
1436 * that we always can remember how much was
1438 bus->wqueue[0] = sd_bus_message_ref(m);
1439 bus->wqueue_size = 1;
1445 /* Just append it to the queue. */
1447 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1450 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1455 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1459 *serial = BUS_MESSAGE_SERIAL(m);
1464 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *serial) {
1467 assert_return(bus, -EINVAL);
1468 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1469 assert_return(m, -EINVAL);
1470 assert_return(!bus_pid_changed(bus), -ECHILD);
1472 if (!streq_ptr(m->destination, destination)) {
1477 r = sd_bus_message_set_destination(m, destination);
1482 return sd_bus_send(bus, m, serial);
1485 static usec_t calc_elapse(uint64_t usec) {
1486 if (usec == (uint64_t) -1)
1490 usec = BUS_DEFAULT_TIMEOUT;
1492 return now(CLOCK_MONOTONIC) + usec;
1495 static int timeout_compare(const void *a, const void *b) {
1496 const struct reply_callback *x = a, *y = b;
1498 if (x->timeout != 0 && y->timeout == 0)
1501 if (x->timeout == 0 && y->timeout != 0)
1504 if (x->timeout < y->timeout)
1507 if (x->timeout > y->timeout)
1513 _public_ int sd_bus_call_async(
1516 sd_bus_message_handler_t callback,
1521 struct reply_callback *c;
1524 assert_return(bus, -EINVAL);
1525 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1526 assert_return(m, -EINVAL);
1527 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1528 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1529 assert_return(callback, -EINVAL);
1530 assert_return(!bus_pid_changed(bus), -ECHILD);
1532 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1536 if (usec != (uint64_t) -1) {
1537 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1542 r = bus_seal_message(bus, m);
1546 c = new0(struct reply_callback, 1);
1550 c->callback = callback;
1551 c->userdata = userdata;
1552 c->serial = BUS_MESSAGE_SERIAL(m);
1553 c->timeout = calc_elapse(usec);
1555 r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1561 if (c->timeout != 0) {
1562 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1565 sd_bus_call_async_cancel(bus, c->serial);
1570 r = sd_bus_send(bus, m, serial);
1572 sd_bus_call_async_cancel(bus, c->serial);
1579 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t serial) {
1580 struct reply_callback *c;
1582 assert_return(bus, -EINVAL);
1583 assert_return(serial != 0, -EINVAL);
1584 assert_return(!bus_pid_changed(bus), -ECHILD);
1586 c = hashmap_remove(bus->reply_callbacks, &serial);
1590 if (c->timeout != 0)
1591 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1597 int bus_ensure_running(sd_bus *bus) {
1602 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1604 if (bus->state == BUS_RUNNING)
1608 r = sd_bus_process(bus, NULL);
1611 if (bus->state == BUS_RUNNING)
1616 r = sd_bus_wait(bus, (uint64_t) -1);
1622 _public_ int sd_bus_call(
1626 sd_bus_error *error,
1627 sd_bus_message **reply) {
1634 assert_return(bus, -EINVAL);
1635 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1636 assert_return(m, -EINVAL);
1637 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1638 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1639 assert_return(!bus_error_is_dirty(error), -EINVAL);
1640 assert_return(!bus_pid_changed(bus), -ECHILD);
1642 r = bus_ensure_running(bus);
1646 i = bus->rqueue_size;
1648 r = sd_bus_send(bus, m, &serial);
1652 timeout = calc_elapse(usec);
1657 while (i < bus->rqueue_size) {
1658 sd_bus_message *incoming = NULL;
1660 incoming = bus->rqueue[i];
1662 if (incoming->reply_serial == serial) {
1663 /* Found a match! */
1665 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1668 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1673 sd_bus_message_unref(incoming);
1676 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1677 r = sd_bus_error_copy(error, &incoming->error);
1681 sd_bus_message_unref(incoming);
1684 } else if (incoming->header->serial == serial &&
1687 streq(bus->unique_name, incoming->sender)) {
1689 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1692 /* Our own message? Somebody is trying
1693 * to send its own client a message,
1694 * let's not dead-lock, let's fail
1697 sd_bus_message_unref(incoming);
1701 /* Try to read more, right-away */
1705 r = bus_read_message(bus);
1707 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1708 bus_enter_closing(bus);
1718 n = now(CLOCK_MONOTONIC);
1724 left = (uint64_t) -1;
1726 r = bus_poll(bus, true, left);
1730 r = dispatch_wqueue(bus);
1732 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1733 bus_enter_closing(bus);
1740 _public_ int sd_bus_get_fd(sd_bus *bus) {
1742 assert_return(bus, -EINVAL);
1743 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1744 assert_return(!bus_pid_changed(bus), -ECHILD);
1746 return bus->input_fd;
1749 _public_ int sd_bus_get_events(sd_bus *bus) {
1752 assert_return(bus, -EINVAL);
1753 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1754 assert_return(!bus_pid_changed(bus), -ECHILD);
1756 if (bus->state == BUS_OPENING)
1758 else if (bus->state == BUS_AUTHENTICATING) {
1760 if (bus_socket_auth_needs_write(bus))
1765 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1766 if (bus->rqueue_size <= 0)
1768 if (bus->wqueue_size > 0)
1775 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1776 struct reply_callback *c;
1778 assert_return(bus, -EINVAL);
1779 assert_return(timeout_usec, -EINVAL);
1780 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1781 assert_return(!bus_pid_changed(bus), -ECHILD);
1783 if (bus->state == BUS_CLOSING) {
1788 if (bus->state == BUS_AUTHENTICATING) {
1789 *timeout_usec = bus->auth_timeout;
1793 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1794 *timeout_usec = (uint64_t) -1;
1798 if (bus->rqueue_size > 0) {
1803 c = prioq_peek(bus->reply_callbacks_prioq);
1805 *timeout_usec = (uint64_t) -1;
1809 *timeout_usec = c->timeout;
1813 static int process_timeout(sd_bus *bus) {
1814 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1815 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1816 struct reply_callback *c;
1822 c = prioq_peek(bus->reply_callbacks_prioq);
1826 n = now(CLOCK_MONOTONIC);
1830 r = bus_message_new_synthetic_error(
1833 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
1838 m->sender = "org.freedesktop.DBus";
1840 r = bus_seal_synthetic_message(bus, m);
1844 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1845 hashmap_remove(bus->reply_callbacks, &c->serial);
1848 bus->iteration_counter ++;
1850 r = c->callback(bus, m, c->userdata, &error_buffer);
1851 r = bus_maybe_reply_error(m, r, &error_buffer);
1854 bus->current = NULL;
1859 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1863 if (bus->state != BUS_HELLO)
1866 /* Let's make sure the first message on the bus is the HELLO
1867 * reply. But note that we don't actually parse the message
1868 * here (we leave that to the usual handling), we just verify
1869 * we don't let any earlier msg through. */
1871 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1872 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1875 if (m->reply_serial != bus->hello_serial)
1881 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1882 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1883 struct reply_callback *c;
1889 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1890 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1893 c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1897 if (c->timeout != 0)
1898 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1900 r = sd_bus_message_rewind(m, true);
1904 r = c->callback(bus, m, c->userdata, &error_buffer);
1905 r = bus_maybe_reply_error(m, r, &error_buffer);
1911 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1912 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1913 struct filter_callback *l;
1920 bus->filter_callbacks_modified = false;
1922 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1924 if (bus->filter_callbacks_modified)
1927 /* Don't run this more than once per iteration */
1928 if (l->last_iteration == bus->iteration_counter)
1931 l->last_iteration = bus->iteration_counter;
1933 r = sd_bus_message_rewind(m, true);
1937 r = l->callback(bus, m, l->userdata, &error_buffer);
1938 r = bus_maybe_reply_error(m, r, &error_buffer);
1944 } while (bus->filter_callbacks_modified);
1949 static int process_match(sd_bus *bus, sd_bus_message *m) {
1956 bus->match_callbacks_modified = false;
1958 r = bus_match_run(bus, &bus->match_callbacks, m);
1962 } while (bus->match_callbacks_modified);
1967 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1968 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1974 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1977 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
1980 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
1983 if (streq_ptr(m->member, "Ping"))
1984 r = sd_bus_message_new_method_return(m, &reply);
1985 else if (streq_ptr(m->member, "GetMachineId")) {
1989 r = sd_id128_get_machine(&id);
1993 r = sd_bus_message_new_method_return(m, &reply);
1997 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
1999 r = sd_bus_message_new_method_errorf(
2001 SD_BUS_ERROR_UNKNOWN_METHOD,
2002 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2008 r = sd_bus_send(bus, reply, NULL);
2015 static int process_message(sd_bus *bus, sd_bus_message *m) {
2022 bus->iteration_counter++;
2024 log_debug("Got message sender=%s object=%s interface=%s member=%s",
2025 strna(sd_bus_message_get_sender(m)),
2026 strna(sd_bus_message_get_path(m)),
2027 strna(sd_bus_message_get_interface(m)),
2028 strna(sd_bus_message_get_member(m)));
2030 r = process_hello(bus, m);
2034 r = process_reply(bus, m);
2038 r = process_filter(bus, m);
2042 r = process_match(bus, m);
2046 r = process_builtin(bus, m);
2050 r = bus_process_object(bus, m);
2053 bus->current = NULL;
2057 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2058 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2062 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2064 r = process_timeout(bus);
2068 r = dispatch_wqueue(bus);
2072 r = dispatch_rqueue(bus, &m);
2078 r = process_message(bus, m);
2083 r = sd_bus_message_rewind(m, true);
2092 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2094 r = sd_bus_reply_method_errorf(
2096 SD_BUS_ERROR_UNKNOWN_OBJECT,
2097 "Unknown object '%s'.", m->path);
2111 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2112 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2113 struct reply_callback *c;
2117 assert(bus->state == BUS_CLOSING);
2119 c = hashmap_first(bus->reply_callbacks);
2121 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2123 /* First, fail all outstanding method calls */
2124 r = bus_message_new_synthetic_error(
2127 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2132 r = bus_seal_synthetic_message(bus, m);
2136 if (c->timeout != 0)
2137 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2139 hashmap_remove(bus->reply_callbacks, &c->serial);
2142 bus->iteration_counter++;
2144 r = c->callback(bus, m, c->userdata, &error_buffer);
2145 r = bus_maybe_reply_error(m, r, &error_buffer);
2151 /* Then, synthesize a Disconnected message */
2152 r = sd_bus_message_new_signal(
2154 "/org/freedesktop/DBus/Local",
2155 "org.freedesktop.DBus.Local",
2161 m->sender = "org.freedesktop.DBus.Local";
2163 r = bus_seal_synthetic_message(bus, m);
2170 bus->iteration_counter++;
2172 r = process_filter(bus, m);
2176 r = process_match(bus, m);
2188 bus->current = NULL;
2192 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2193 BUS_DONT_DESTROY(bus);
2196 /* Returns 0 when we didn't do anything. This should cause the
2197 * caller to invoke sd_bus_wait() before returning the next
2198 * time. Returns > 0 when we did something, which possibly
2199 * means *ret is filled in with an unprocessed message. */
2201 assert_return(bus, -EINVAL);
2202 assert_return(!bus_pid_changed(bus), -ECHILD);
2204 /* We don't allow recursively invoking sd_bus_process(). */
2205 assert_return(!bus->current, -EBUSY);
2207 switch (bus->state) {
2214 r = bus_socket_process_opening(bus);
2215 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2216 bus_enter_closing(bus);
2224 case BUS_AUTHENTICATING:
2225 r = bus_socket_process_authenticating(bus);
2226 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2227 bus_enter_closing(bus);
2239 r = process_running(bus, ret);
2240 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2241 bus_enter_closing(bus);
2251 return process_closing(bus, ret);
2254 assert_not_reached("Unknown state");
2257 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2258 struct pollfd p[2] = {};
2261 usec_t m = (usec_t) -1;
2265 if (bus->state == BUS_CLOSING)
2268 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2270 e = sd_bus_get_events(bus);
2275 /* The caller really needs some more data, he doesn't
2276 * care about what's already read, or any timeouts
2281 /* The caller wants to process if there's something to
2282 * process, but doesn't care otherwise */
2284 r = sd_bus_get_timeout(bus, &until);
2289 nw = now(CLOCK_MONOTONIC);
2290 m = until > nw ? until - nw : 0;
2294 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2297 p[0].fd = bus->input_fd;
2298 if (bus->output_fd == bus->input_fd) {
2302 p[0].events = e & POLLIN;
2303 p[1].fd = bus->output_fd;
2304 p[1].events = e & POLLOUT;
2308 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2312 return r > 0 ? 1 : 0;
2315 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2317 assert_return(bus, -EINVAL);
2318 assert_return(!bus_pid_changed(bus), -ECHILD);
2320 if (bus->state == BUS_CLOSING)
2323 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2325 if (bus->rqueue_size > 0)
2328 return bus_poll(bus, false, timeout_usec);
2331 _public_ int sd_bus_flush(sd_bus *bus) {
2334 assert_return(bus, -EINVAL);
2335 assert_return(!bus_pid_changed(bus), -ECHILD);
2337 if (bus->state == BUS_CLOSING)
2340 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2342 r = bus_ensure_running(bus);
2346 if (bus->wqueue_size <= 0)
2350 r = dispatch_wqueue(bus);
2352 if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
2353 bus_enter_closing(bus);
2358 if (bus->wqueue_size <= 0)
2361 r = bus_poll(bus, false, (uint64_t) -1);
2367 _public_ int sd_bus_add_filter(sd_bus *bus,
2368 sd_bus_message_handler_t callback,
2371 struct filter_callback *f;
2373 assert_return(bus, -EINVAL);
2374 assert_return(callback, -EINVAL);
2375 assert_return(!bus_pid_changed(bus), -ECHILD);
2377 f = new0(struct filter_callback, 1);
2380 f->callback = callback;
2381 f->userdata = userdata;
2383 bus->filter_callbacks_modified = true;
2384 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2388 _public_ int sd_bus_remove_filter(sd_bus *bus,
2389 sd_bus_message_handler_t callback,
2392 struct filter_callback *f;
2394 assert_return(bus, -EINVAL);
2395 assert_return(callback, -EINVAL);
2396 assert_return(!bus_pid_changed(bus), -ECHILD);
2398 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2399 if (f->callback == callback && f->userdata == userdata) {
2400 bus->filter_callbacks_modified = true;
2401 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2410 _public_ int sd_bus_add_match(sd_bus *bus,
2412 sd_bus_message_handler_t callback,
2415 struct bus_match_component *components = NULL;
2416 unsigned n_components = 0;
2417 uint64_t cookie = 0;
2420 assert_return(bus, -EINVAL);
2421 assert_return(match, -EINVAL);
2422 assert_return(!bus_pid_changed(bus), -ECHILD);
2424 r = bus_match_parse(match, &components, &n_components);
2428 if (bus->bus_client) {
2429 cookie = ++bus->match_cookie;
2431 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2436 bus->match_callbacks_modified = true;
2437 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2439 if (bus->bus_client)
2440 bus_remove_match_internal(bus, match, cookie);
2444 bus_match_parse_free(components, n_components);
2448 _public_ int sd_bus_remove_match(sd_bus *bus,
2450 sd_bus_message_handler_t callback,
2453 struct bus_match_component *components = NULL;
2454 unsigned n_components = 0;
2456 uint64_t cookie = 0;
2458 assert_return(bus, -EINVAL);
2459 assert_return(match, -EINVAL);
2460 assert_return(!bus_pid_changed(bus), -ECHILD);
2462 r = bus_match_parse(match, &components, &n_components);
2466 bus->match_callbacks_modified = true;
2467 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2469 if (bus->bus_client)
2470 q = bus_remove_match_internal(bus, match, cookie);
2472 bus_match_parse_free(components, n_components);
2474 return r < 0 ? r : q;
2477 bool bus_pid_changed(sd_bus *bus) {
2480 /* We don't support people creating a bus connection and
2481 * keeping it around over a fork(). Let's complain. */
2483 return bus->original_pid != getpid();
2486 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2487 sd_bus *bus = userdata;
2492 r = sd_bus_process(bus, NULL);
2499 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2500 sd_bus *bus = userdata;
2505 r = sd_bus_process(bus, NULL);
2512 static int prepare_callback(sd_event_source *s, void *userdata) {
2513 sd_bus *bus = userdata;
2520 e = sd_bus_get_events(bus);
2524 if (bus->output_fd != bus->input_fd) {
2526 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2530 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2534 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2539 r = sd_bus_get_timeout(bus, &until);
2545 j = sd_event_source_set_time(bus->time_event_source, until);
2550 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2557 static int quit_callback(sd_event_source *event, void *userdata) {
2558 sd_bus *bus = userdata;
2567 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2570 assert_return(bus, -EINVAL);
2571 assert_return(!bus->event, -EBUSY);
2573 assert(!bus->input_io_event_source);
2574 assert(!bus->output_io_event_source);
2575 assert(!bus->time_event_source);
2578 bus->event = sd_event_ref(event);
2580 r = sd_event_default(&bus->event);
2585 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2589 r = sd_event_source_set_priority(bus->input_io_event_source, priority);
2593 if (bus->output_fd != bus->input_fd) {
2594 r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2598 r = sd_event_source_set_priority(bus->output_io_event_source, priority);
2603 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2607 r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2611 r = sd_event_source_set_priority(bus->time_event_source, priority);
2615 r = sd_event_add_quit(bus->event, quit_callback, bus, &bus->quit_event_source);
2622 sd_bus_detach_event(bus);
2626 _public_ int sd_bus_detach_event(sd_bus *bus) {
2627 assert_return(bus, -EINVAL);
2628 assert_return(bus->event, -ENXIO);
2630 if (bus->input_io_event_source) {
2631 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2632 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2635 if (bus->output_io_event_source) {
2636 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2637 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2640 if (bus->time_event_source) {
2641 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2642 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2645 if (bus->quit_event_source) {
2646 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2647 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2651 bus->event = sd_event_unref(bus->event);
2656 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2657 assert_return(bus, NULL);
2662 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2663 assert_return(bus, NULL);
2665 return bus->current;
2668 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2673 assert(default_bus);
2676 return !!*default_bus;
2679 *ret = sd_bus_ref(*default_bus);
2687 b->default_bus_ptr = default_bus;
2695 _public_ int sd_bus_default_system(sd_bus **ret) {
2696 static __thread sd_bus *default_system_bus = NULL;
2698 return bus_default(sd_bus_open_system, &default_system_bus, ret);
2701 _public_ int sd_bus_default_user(sd_bus **ret) {
2702 static __thread sd_bus *default_user_bus = NULL;
2704 return bus_default(sd_bus_open_user, &default_user_bus, ret);
2707 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2708 assert_return(b, -EINVAL);
2709 assert_return(tid, -EINVAL);
2710 assert_return(!bus_pid_changed(b), -ECHILD);
2718 return sd_event_get_tid(b->event, tid);
2723 _public_ char *sd_bus_label_escape(const char *s) {
2727 assert_return(s, NULL);
2729 /* Escapes all chars that D-Bus' object path cannot deal
2730 * with. Can be reversed with bus_path_unescape(). We special
2731 * case the empty string. */
2736 r = new(char, strlen(s)*3 + 1);
2740 for (f = s, t = r; *f; f++) {
2742 /* Escape everything that is not a-zA-Z0-9. We also
2743 * escape 0-9 if it's the first character */
2745 if (!(*f >= 'A' && *f <= 'Z') &&
2746 !(*f >= 'a' && *f <= 'z') &&
2747 !(f > s && *f >= '0' && *f <= '9')) {
2749 *(t++) = hexchar(*f >> 4);
2750 *(t++) = hexchar(*f);
2760 _public_ char *sd_bus_label_unescape(const char *f) {
2763 assert_return(f, NULL);
2765 /* Special case for the empty string */
2769 r = new(char, strlen(f) + 1);
2773 for (t = r; *f; f++) {
2778 if ((a = unhexchar(f[1])) < 0 ||
2779 (b = unhexchar(f[2])) < 0) {
2780 /* Invalid escape code, let's take it literal then */
2783 *(t++) = (char) ((a << 4) | b);
2795 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
2800 assert_return(bus, -EINVAL);
2801 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
2802 assert_return(ret, -EINVAL);
2803 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2804 assert_return(!bus_pid_changed(bus), -ECHILD);
2805 assert_return(!bus->is_kernel, -ENOTSUP);
2807 if (!bus->ucred_valid && !isempty(bus->label))
2810 c = bus_creds_new();
2814 if (bus->ucred_valid) {
2815 pid = c->pid = bus->ucred.pid;
2816 c->uid = bus->ucred.uid;
2817 c->gid = bus->ucred.gid;
2819 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
2822 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
2823 c->label = strdup(bus->label);
2825 sd_bus_creds_unref(c);
2829 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
2832 r = bus_creds_add_more(c, mask, pid, 0);