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/>.
38 #include "cgroup-util.h"
39 #include "bus-label.h"
42 #include "bus-internal.h"
43 #include "bus-message.h"
45 #include "bus-socket.h"
46 #include "bus-kernel.h"
47 #include "bus-control.h"
48 #include "bus-introspect.h"
49 #include "bus-signature.h"
50 #include "bus-objects.h"
52 #include "bus-container.h"
53 #include "bus-protocol.h"
54 #include "bus-track.h"
56 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
57 static int attach_io_events(sd_bus *b);
58 static void detach_io_events(sd_bus *b);
60 static void bus_close_fds(sd_bus *b) {
66 close_nointr_nofail(b->input_fd);
68 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
69 close_nointr_nofail(b->output_fd);
71 b->input_fd = b->output_fd = -1;
74 static void bus_node_destroy(sd_bus *b, struct node *n) {
75 struct node_callback *c;
76 struct node_vtable *v;
77 struct node_enumerator *e;
85 bus_node_destroy(b, n->child);
87 while ((c = n->callbacks)) {
88 LIST_REMOVE(callbacks, n->callbacks, c);
92 while ((v = n->vtables)) {
93 LIST_REMOVE(vtables, n->vtables, v);
98 while ((e = n->enumerators)) {
99 LIST_REMOVE(enumerators, n->enumerators, e);
104 LIST_REMOVE(siblings, n->parent->child, n);
106 assert_se(hashmap_remove(b->nodes, n->path) == n);
111 static void bus_reset_queues(sd_bus *b) {
114 while (b->rqueue_size > 0)
115 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
119 b->rqueue_allocated = 0;
121 while (b->wqueue_size > 0)
122 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
126 b->wqueue_allocated = 0;
129 static void bus_free(sd_bus *b) {
130 struct filter_callback *f;
135 assert(!b->track_queue);
137 sd_bus_detach_event(b);
139 if (b->default_bus_ptr)
140 *b->default_bus_ptr = NULL;
145 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
148 free(b->unique_name);
149 free(b->auth_buffer);
154 free(b->cgroup_root);
155 free(b->connection_name);
158 strv_free(b->exec_argv);
160 close_many(b->fds, b->n_fds);
165 hashmap_free_free(b->reply_callbacks);
166 prioq_free(b->reply_callbacks_prioq);
168 while ((f = b->filter_callbacks)) {
169 LIST_REMOVE(callbacks, b->filter_callbacks, f);
173 bus_match_free(&b->match_callbacks);
175 hashmap_free_free(b->vtable_methods);
176 hashmap_free_free(b->vtable_properties);
178 while ((n = hashmap_first(b->nodes)))
179 bus_node_destroy(b, n);
181 hashmap_free(b->nodes);
183 bus_kernel_flush_memfd(b);
185 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
190 _public_ int sd_bus_new(sd_bus **ret) {
193 assert_return(ret, -EINVAL);
199 r->n_ref = REFCNT_INIT;
200 r->input_fd = r->output_fd = -1;
201 r->message_version = 1;
202 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
203 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
204 r->attach_flags |= KDBUS_ATTACH_NAMES;
205 r->original_pid = getpid();
207 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
209 /* We guarantee that wqueue always has space for at least one
211 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
220 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
223 assert_return(bus, -EINVAL);
224 assert_return(bus->state == BUS_UNSET, -EPERM);
225 assert_return(address, -EINVAL);
226 assert_return(!bus_pid_changed(bus), -ECHILD);
238 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
239 assert_return(bus, -EINVAL);
240 assert_return(bus->state == BUS_UNSET, -EPERM);
241 assert_return(input_fd >= 0, -EINVAL);
242 assert_return(output_fd >= 0, -EINVAL);
243 assert_return(!bus_pid_changed(bus), -ECHILD);
245 bus->input_fd = input_fd;
246 bus->output_fd = output_fd;
250 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
253 assert_return(bus, -EINVAL);
254 assert_return(bus->state == BUS_UNSET, -EPERM);
255 assert_return(path, -EINVAL);
256 assert_return(!strv_isempty(argv), -EINVAL);
257 assert_return(!bus_pid_changed(bus), -ECHILD);
269 free(bus->exec_path);
270 strv_free(bus->exec_argv);
278 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
279 assert_return(bus, -EINVAL);
280 assert_return(bus->state == BUS_UNSET, -EPERM);
281 assert_return(!bus_pid_changed(bus), -ECHILD);
283 bus->bus_client = !!b;
287 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
288 assert_return(bus, -EINVAL);
289 assert_return(bus->state == BUS_UNSET, -EPERM);
290 assert_return(!bus_pid_changed(bus), -ECHILD);
292 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
296 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
297 assert_return(bus, -EINVAL);
298 assert_return(bus->state == BUS_UNSET, -EPERM);
299 assert_return(!bus_pid_changed(bus), -ECHILD);
301 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
305 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
306 assert_return(bus, -EINVAL);
307 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
308 assert_return(bus->state == BUS_UNSET, -EPERM);
309 assert_return(!bus_pid_changed(bus), -ECHILD);
311 /* The well knowns we need unconditionally, so that matches can work */
312 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
314 return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
317 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
318 assert_return(bus, -EINVAL);
319 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
320 assert_return(bus->state == BUS_UNSET, -EPERM);
321 assert_return(!bus_pid_changed(bus), -ECHILD);
323 bus->is_server = !!b;
324 bus->server_id = server_id;
328 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
329 assert_return(bus, -EINVAL);
330 assert_return(bus->state == BUS_UNSET, -EPERM);
331 assert_return(!bus_pid_changed(bus), -ECHILD);
333 bus->anonymous_auth = !!b;
337 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
338 assert_return(bus, -EINVAL);
339 assert_return(bus->state == BUS_UNSET, -EPERM);
340 assert_return(!bus_pid_changed(bus), -ECHILD);
346 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
349 assert_return(bus, -EINVAL);
350 assert_return(name, -EINVAL);
351 assert_return(bus->state == BUS_UNSET, -EPERM);
352 assert_return(!bus_pid_changed(bus), -ECHILD);
358 free(bus->connection_name);
359 bus->connection_name = n;
364 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
369 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
372 r = sd_bus_message_get_errno(reply);
378 r = sd_bus_message_read(reply, "s", &s);
382 if (!service_name_is_valid(s) || s[0] != ':')
385 bus->unique_name = strdup(s);
386 if (!bus->unique_name)
389 if (bus->state == BUS_HELLO)
390 bus->state = BUS_RUNNING;
395 static int bus_send_hello(sd_bus *bus) {
396 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
401 if (!bus->bus_client || bus->is_kernel)
404 r = sd_bus_message_new_method_call(
407 "org.freedesktop.DBus",
408 "/org/freedesktop/DBus",
409 "org.freedesktop.DBus",
414 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie);
417 int bus_start_running(sd_bus *bus) {
420 if (bus->bus_client && !bus->is_kernel) {
421 bus->state = BUS_HELLO;
425 bus->state = BUS_RUNNING;
429 static int parse_address_key(const char **p, const char *key, char **value) {
430 size_t l, n = 0, allocated = 0;
440 if (strncmp(*p, key, l) != 0)
453 while (*a != ';' && *a != ',' && *a != 0) {
471 c = (char) ((x << 4) | y);
478 if (!GREEDY_REALLOC(r, allocated, n + 2))
502 static void skip_address_key(const char **p) {
506 *p += strcspn(*p, ",");
512 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
513 _cleanup_free_ char *path = NULL, *abstract = NULL;
522 while (**p != 0 && **p != ';') {
523 r = parse_address_key(p, "guid", guid);
529 r = parse_address_key(p, "path", &path);
535 r = parse_address_key(p, "abstract", &abstract);
544 if (!path && !abstract)
547 if (path && abstract)
552 if (l > sizeof(b->sockaddr.un.sun_path))
555 b->sockaddr.un.sun_family = AF_UNIX;
556 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
557 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
558 } else if (abstract) {
559 l = strlen(abstract);
560 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
563 b->sockaddr.un.sun_family = AF_UNIX;
564 b->sockaddr.un.sun_path[0] = 0;
565 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
566 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
572 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
573 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
575 struct addrinfo *result, hints = {
576 .ai_socktype = SOCK_STREAM,
577 .ai_flags = AI_ADDRCONFIG,
585 while (**p != 0 && **p != ';') {
586 r = parse_address_key(p, "guid", guid);
592 r = parse_address_key(p, "host", &host);
598 r = parse_address_key(p, "port", &port);
604 r = parse_address_key(p, "family", &family);
617 if (streq(family, "ipv4"))
618 hints.ai_family = AF_INET;
619 else if (streq(family, "ipv6"))
620 hints.ai_family = AF_INET6;
625 r = getaddrinfo(host, port, &hints, &result);
629 return -EADDRNOTAVAIL;
631 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
632 b->sockaddr_size = result->ai_addrlen;
634 freeaddrinfo(result);
639 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
641 unsigned n_argv = 0, j;
643 size_t allocated = 0;
651 while (**p != 0 && **p != ';') {
652 r = parse_address_key(p, "guid", guid);
658 r = parse_address_key(p, "path", &path);
664 if (startswith(*p, "argv")) {
668 ul = strtoul(*p + 4, (char**) p, 10);
669 if (errno > 0 || **p != '=' || ul > 256) {
677 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
685 r = parse_address_key(p, NULL, argv + ul);
700 /* Make sure there are no holes in the array, with the
701 * exception of argv[0] */
702 for (j = 1; j < n_argv; j++)
708 if (argv && argv[0] == NULL) {
709 argv[0] = strdup(path);
721 for (j = 0; j < n_argv; j++)
729 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
730 _cleanup_free_ char *path = NULL;
738 while (**p != 0 && **p != ';') {
739 r = parse_address_key(p, "guid", guid);
745 r = parse_address_key(p, "path", &path);
764 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
765 _cleanup_free_ char *machine = NULL;
773 while (**p != 0 && **p != ';') {
774 r = parse_address_key(p, "guid", guid);
780 r = parse_address_key(p, "machine", &machine);
792 if (!filename_is_safe(machine))
796 b->machine = machine;
799 b->sockaddr.un.sun_family = AF_UNIX;
800 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
801 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
806 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
807 _cleanup_free_ char *machine = NULL;
815 while (**p != 0 && **p != ';') {
816 r = parse_address_key(p, "guid", guid);
822 r = parse_address_key(p, "machine", &machine);
834 if (!filename_is_safe(machine))
838 b->machine = machine;
842 b->kernel = strdup("/dev/kdbus/0-system/bus");
849 static void bus_reset_parsed_address(sd_bus *b) {
853 b->sockaddr_size = 0;
854 strv_free(b->exec_argv);
858 b->server_id = SD_ID128_NULL;
865 static int bus_parse_next_address(sd_bus *b) {
866 _cleanup_free_ char *guid = NULL;
874 if (b->address[b->address_index] == 0)
877 bus_reset_parsed_address(b);
879 a = b->address + b->address_index;
888 if (startswith(a, "unix:")) {
891 r = parse_unix_address(b, &a, &guid);
896 } else if (startswith(a, "tcp:")) {
899 r = parse_tcp_address(b, &a, &guid);
905 } else if (startswith(a, "unixexec:")) {
908 r = parse_exec_address(b, &a, &guid);
914 } else if (startswith(a, "kernel:")) {
917 r = parse_kernel_address(b, &a, &guid);
922 } else if (startswith(a, "x-container-unix:")) {
925 r = parse_container_unix_address(b, &a, &guid);
930 } else if (startswith(a, "x-container-kernel:")) {
933 r = parse_container_kernel_address(b, &a, &guid);
946 r = sd_id128_from_string(guid, &b->server_id);
951 b->address_index = a - b->address;
955 static int bus_start_address(sd_bus *b) {
961 bool skipped = false;
966 r = bus_socket_exec(b);
967 else if (b->machine && b->kernel)
968 r = bus_container_connect_kernel(b);
969 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
970 r = bus_container_connect_socket(b);
972 r = bus_kernel_connect(b);
973 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
974 r = bus_socket_connect(b);
980 r = attach_io_events(b);
985 b->last_connect_error = -r;
988 r = bus_parse_next_address(b);
992 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
996 int bus_next_address(sd_bus *b) {
999 bus_reset_parsed_address(b);
1000 return bus_start_address(b);
1003 static int bus_start_fd(sd_bus *b) {
1008 assert(b->input_fd >= 0);
1009 assert(b->output_fd >= 0);
1011 r = fd_nonblock(b->input_fd, true);
1015 r = fd_cloexec(b->input_fd, true);
1019 if (b->input_fd != b->output_fd) {
1020 r = fd_nonblock(b->output_fd, true);
1024 r = fd_cloexec(b->output_fd, true);
1029 if (fstat(b->input_fd, &st) < 0)
1032 if (S_ISCHR(b->input_fd))
1033 return bus_kernel_take_fd(b);
1035 return bus_socket_take_fd(b);
1038 _public_ int sd_bus_start(sd_bus *bus) {
1041 assert_return(bus, -EINVAL);
1042 assert_return(bus->state == BUS_UNSET, -EPERM);
1043 assert_return(!bus_pid_changed(bus), -ECHILD);
1045 bus->state = BUS_OPENING;
1047 if (bus->is_server && bus->bus_client)
1050 if (bus->input_fd >= 0)
1051 r = bus_start_fd(bus);
1052 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1053 r = bus_start_address(bus);
1060 return bus_send_hello(bus);
1063 _public_ int sd_bus_open(sd_bus **ret) {
1068 assert_return(ret, -EINVAL);
1070 /* Let's connect to the starter bus if it is set, and
1071 * otherwise to the bus that is appropropriate for the scope
1072 * we are running in */
1074 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1076 if (streq(e, "system"))
1077 return sd_bus_open_system(ret);
1078 else if (streq(e, "session") || streq(e, "user"))
1079 return sd_bus_open_user(ret);
1082 e = secure_getenv("DBUS_STARTER_ADDRESS");
1084 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1085 return sd_bus_open_user(ret);
1087 return sd_bus_open_system(ret);
1094 r = sd_bus_set_address(b, e);
1098 b->bus_client = true;
1100 /* We don't know whether the bus is trusted or not, so better
1101 * be safe, and authenticate everything */
1103 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1105 r = sd_bus_start(b);
1117 _public_ int sd_bus_open_system(sd_bus **ret) {
1122 assert_return(ret, -EINVAL);
1128 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1130 r = sd_bus_set_address(b, e);
1132 r = sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1136 b->bus_client = true;
1137 b->is_system = true;
1139 /* Let's do per-method access control on the system bus. We
1140 * need the caller's UID and capability set for that. */
1142 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1144 r = sd_bus_start(b);
1156 _public_ int sd_bus_open_user(sd_bus **ret) {
1161 assert_return(ret, -EINVAL);
1167 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1169 r = sd_bus_set_address(b, e);
1173 e = secure_getenv("XDG_RUNTIME_DIR");
1175 _cleanup_free_ char *ee = NULL;
1177 ee = bus_address_escape(e);
1184 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee);
1186 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1190 asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
1203 b->bus_client = true;
1206 /* We don't do any per-method access control on the user
1210 r = sd_bus_start(b);
1222 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1223 _cleanup_free_ char *e = NULL;
1228 assert_return(host, -EINVAL);
1229 assert_return(ret, -EINVAL);
1231 e = bus_address_escape(host);
1235 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1239 r = sd_bus_new(&bus);
1246 bus->bus_client = true;
1248 r = sd_bus_start(bus);
1258 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1259 _cleanup_free_ char *e = NULL;
1264 assert_return(machine, -EINVAL);
1265 assert_return(ret, -EINVAL);
1266 assert_return(filename_is_safe(machine), -EINVAL);
1268 e = bus_address_escape(machine);
1273 p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1275 p = strjoin("x-container-unix:machine=", e, NULL);
1280 r = sd_bus_new(&bus);
1287 bus->bus_client = true;
1289 r = sd_bus_start(bus);
1299 _public_ void sd_bus_close(sd_bus *bus) {
1303 if (bus->state == BUS_CLOSED)
1305 if (bus_pid_changed(bus))
1308 bus->state = BUS_CLOSED;
1310 sd_bus_detach_event(bus);
1312 /* Drop all queued messages so that they drop references to
1313 * the bus object and the bus may be freed */
1314 bus_reset_queues(bus);
1316 if (!bus->is_kernel)
1319 /* We'll leave the fd open in case this is a kernel bus, since
1320 * there might still be memblocks around that reference this
1321 * bus, and they might need to invoke the KDBUS_CMD_FREE
1322 * ioctl on the fd when they are freed. */
1325 static void bus_enter_closing(sd_bus *bus) {
1328 if (bus->state != BUS_OPENING &&
1329 bus->state != BUS_AUTHENTICATING &&
1330 bus->state != BUS_HELLO &&
1331 bus->state != BUS_RUNNING)
1334 bus->state = BUS_CLOSING;
1337 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1338 assert_return(bus, NULL);
1340 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1345 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1351 if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
1354 for (i = 0; i < bus->rqueue_size; i++)
1355 if (bus->rqueue[i]->n_ref > 1) {
1361 for (i = 0; i < bus->wqueue_size; i++)
1362 if (bus->wqueue[i]->n_ref > 1) {
1368 /* We are the only holders on the messages, and the
1369 * messages are the only holders on us, so let's drop
1370 * the messages and thus implicitly also kill our own
1371 * last references */
1374 bus_reset_queues(bus);
1377 i = REFCNT_DEC(bus->n_ref);
1385 _public_ int sd_bus_is_open(sd_bus *bus) {
1387 assert_return(bus, -EINVAL);
1388 assert_return(!bus_pid_changed(bus), -ECHILD);
1390 return BUS_IS_OPEN(bus->state);
1393 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1396 assert_return(bus, -EINVAL);
1397 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1398 assert_return(!bus_pid_changed(bus), -ECHILD);
1400 if (type == SD_BUS_TYPE_UNIX_FD) {
1401 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1404 r = bus_ensure_running(bus);
1408 return bus->can_fds;
1411 return bus_type_is_valid(type);
1414 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1417 assert_return(bus, -EINVAL);
1418 assert_return(server_id, -EINVAL);
1419 assert_return(!bus_pid_changed(bus), -ECHILD);
1421 r = bus_ensure_running(bus);
1425 *server_id = bus->server_id;
1429 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1434 /* If we copy the same message to multiple
1435 * destinations, avoid using the same cookie
1437 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1442 timeout = BUS_DEFAULT_TIMEOUT;
1444 return bus_message_seal(m, ++b->cookie, timeout);
1447 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1450 /* Do packet version and endianess already match? */
1451 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1452 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1455 /* No? Then remarshal! */
1456 return bus_message_remarshal(b, m);
1459 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1463 /* The bus specification says the serial number cannot be 0,
1464 * hence let's fill something in for synthetic messages. Since
1465 * synthetic messages might have a fake sender and we don't
1466 * want to interfere with the real sender's serial numbers we
1467 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1468 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1469 * even though kdbus can do 64bit. */
1471 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1474 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1481 r = bus_kernel_write_message(bus, m, hint_sync_call);
1483 r = bus_socket_write_message(bus, m, idx);
1488 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1489 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
1490 bus_message_type_to_string(m->header->type),
1491 strna(sd_bus_message_get_sender(m)),
1492 strna(sd_bus_message_get_destination(m)),
1493 strna(sd_bus_message_get_path(m)),
1494 strna(sd_bus_message_get_interface(m)),
1495 strna(sd_bus_message_get_member(m)),
1496 (unsigned long) BUS_MESSAGE_COOKIE(m),
1497 (unsigned long) m->reply_cookie,
1498 strna(m->error.message));
1503 static int dispatch_wqueue(sd_bus *bus) {
1507 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1509 while (bus->wqueue_size > 0) {
1511 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1515 /* Didn't do anything this time */
1517 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1518 /* Fully written. Let's drop the entry from
1521 * This isn't particularly optimized, but
1522 * well, this is supposed to be our worst-case
1523 * buffer only, and the socket buffer is
1524 * supposed to be our primary buffer, and if
1525 * it got full, then all bets are off
1528 bus->wqueue_size --;
1529 sd_bus_message_unref(bus->wqueue[0]);
1530 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1540 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1544 return bus_kernel_read_message(bus, hint_priority, priority);
1546 return bus_socket_read_message(bus);
1549 int bus_rqueue_make_room(sd_bus *bus) {
1552 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1555 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1561 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1566 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1568 /* Note that the priority logic is only available on kdbus,
1569 * where the rqueue is unused. We check the rqueue here
1570 * anyway, because it's simple... */
1573 if (bus->rqueue_size > 0) {
1574 /* Dispatch a queued message */
1576 *m = bus->rqueue[0];
1577 bus->rqueue_size --;
1578 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1582 /* Try to read a new message */
1583 r = bus_read_message(bus, hint_priority, priority);
1593 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1594 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1597 assert_return(bus, -EINVAL);
1598 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1599 assert_return(m, -EINVAL);
1600 assert_return(!bus_pid_changed(bus), -ECHILD);
1603 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1610 /* If the cookie number isn't kept, then we know that no reply
1612 if (!cookie && !m->sealed)
1613 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1615 r = bus_seal_message(bus, m, 0);
1619 /* Remarshall if we have to. This will possibly unref the
1620 * message and place a replacement in m */
1621 r = bus_remarshal_message(bus, &m);
1625 /* If this is a reply and no reply was requested, then let's
1626 * suppress this, if we can */
1627 if (m->dont_send && !cookie)
1630 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1633 r = bus_write_message(bus, m, hint_sync_call, &idx);
1635 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1636 bus_enter_closing(bus);
1641 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1642 /* Wasn't fully written. So let's remember how
1643 * much was written. Note that the first entry
1644 * of the wqueue array is always allocated so
1645 * that we always can remember how much was
1647 bus->wqueue[0] = sd_bus_message_ref(m);
1648 bus->wqueue_size = 1;
1652 /* Just append it to the queue. */
1654 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1657 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1660 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1664 *cookie = BUS_MESSAGE_COOKIE(m);
1669 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1670 return bus_send_internal(bus, m, cookie, false);
1673 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1676 assert_return(bus, -EINVAL);
1677 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1678 assert_return(m, -EINVAL);
1679 assert_return(!bus_pid_changed(bus), -ECHILD);
1681 if (!streq_ptr(m->destination, destination)) {
1686 r = sd_bus_message_set_destination(m, destination);
1691 return sd_bus_send(bus, m, cookie);
1694 static usec_t calc_elapse(uint64_t usec) {
1695 if (usec == (uint64_t) -1)
1698 return now(CLOCK_MONOTONIC) + usec;
1701 static int timeout_compare(const void *a, const void *b) {
1702 const struct reply_callback *x = a, *y = b;
1704 if (x->timeout != 0 && y->timeout == 0)
1707 if (x->timeout == 0 && y->timeout != 0)
1710 if (x->timeout < y->timeout)
1713 if (x->timeout > y->timeout)
1719 _public_ int sd_bus_call_async(
1722 sd_bus_message_handler_t callback,
1727 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1728 struct reply_callback *c;
1731 assert_return(bus, -EINVAL);
1732 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1733 assert_return(m, -EINVAL);
1734 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1735 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1736 assert_return(callback, -EINVAL);
1737 assert_return(!bus_pid_changed(bus), -ECHILD);
1739 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1743 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1747 r = bus_seal_message(bus, m, usec);
1751 r = bus_remarshal_message(bus, &m);
1755 c = new0(struct reply_callback, 1);
1759 c->callback = callback;
1760 c->userdata = userdata;
1761 c->cookie = BUS_MESSAGE_COOKIE(m);
1762 c->timeout = calc_elapse(m->timeout);
1764 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1770 if (c->timeout != 0) {
1771 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1774 sd_bus_call_async_cancel(bus, c->cookie);
1779 r = sd_bus_send(bus, m, cookie);
1781 sd_bus_call_async_cancel(bus, c->cookie);
1788 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1789 struct reply_callback *c;
1791 assert_return(bus, -EINVAL);
1792 assert_return(cookie != 0, -EINVAL);
1793 assert_return(!bus_pid_changed(bus), -ECHILD);
1795 c = hashmap_remove(bus->reply_callbacks, &cookie);
1799 if (c->timeout != 0)
1800 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1806 int bus_ensure_running(sd_bus *bus) {
1811 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1813 if (bus->state == BUS_RUNNING)
1817 r = sd_bus_process(bus, NULL);
1820 if (bus->state == BUS_RUNNING)
1825 r = sd_bus_wait(bus, (uint64_t) -1);
1831 _public_ int sd_bus_call(
1835 sd_bus_error *error,
1836 sd_bus_message **reply) {
1838 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1844 assert_return(bus, -EINVAL);
1845 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1846 assert_return(m, -EINVAL);
1847 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1848 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1849 assert_return(!bus_error_is_dirty(error), -EINVAL);
1850 assert_return(!bus_pid_changed(bus), -ECHILD);
1852 r = bus_ensure_running(bus);
1856 i = bus->rqueue_size;
1858 r = bus_seal_message(bus, m, usec);
1862 r = bus_remarshal_message(bus, &m);
1866 r = bus_send_internal(bus, m, &cookie, true);
1870 timeout = calc_elapse(m->timeout);
1875 while (i < bus->rqueue_size) {
1876 sd_bus_message *incoming = NULL;
1878 incoming = bus->rqueue[i];
1880 if (incoming->reply_cookie == cookie) {
1881 /* Found a match! */
1883 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1886 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1891 sd_bus_message_unref(incoming);
1894 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1895 r = sd_bus_error_copy(error, &incoming->error);
1899 sd_bus_message_unref(incoming);
1902 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1905 streq(bus->unique_name, incoming->sender)) {
1907 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1910 /* Our own message? Somebody is trying
1911 * to send its own client a message,
1912 * let's not dead-lock, let's fail
1915 sd_bus_message_unref(incoming);
1919 /* Try to read more, right-away */
1923 r = bus_read_message(bus, false, 0);
1925 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1926 bus_enter_closing(bus);
1938 n = now(CLOCK_MONOTONIC);
1944 left = (uint64_t) -1;
1946 r = bus_poll(bus, true, left);
1952 r = dispatch_wqueue(bus);
1954 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1955 bus_enter_closing(bus);
1964 _public_ int sd_bus_get_fd(sd_bus *bus) {
1966 assert_return(bus, -EINVAL);
1967 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1968 assert_return(!bus_pid_changed(bus), -ECHILD);
1970 return bus->input_fd;
1973 _public_ int sd_bus_get_events(sd_bus *bus) {
1976 assert_return(bus, -EINVAL);
1977 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1978 assert_return(!bus_pid_changed(bus), -ECHILD);
1980 if (bus->state == BUS_OPENING)
1982 else if (bus->state == BUS_AUTHENTICATING) {
1984 if (bus_socket_auth_needs_write(bus))
1989 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1990 if (bus->rqueue_size <= 0)
1992 if (bus->wqueue_size > 0)
1999 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2000 struct reply_callback *c;
2002 assert_return(bus, -EINVAL);
2003 assert_return(timeout_usec, -EINVAL);
2004 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
2005 assert_return(!bus_pid_changed(bus), -ECHILD);
2007 if (bus->track_queue) {
2012 if (bus->state == BUS_CLOSING) {
2017 if (bus->state == BUS_AUTHENTICATING) {
2018 *timeout_usec = bus->auth_timeout;
2022 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2023 *timeout_usec = (uint64_t) -1;
2027 if (bus->rqueue_size > 0) {
2032 c = prioq_peek(bus->reply_callbacks_prioq);
2034 *timeout_usec = (uint64_t) -1;
2038 *timeout_usec = c->timeout;
2042 static int process_timeout(sd_bus *bus) {
2043 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2044 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2045 struct reply_callback *c;
2051 c = prioq_peek(bus->reply_callbacks_prioq);
2055 n = now(CLOCK_MONOTONIC);
2059 r = bus_message_new_synthetic_error(
2062 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2067 m->sender = "org.freedesktop.DBus";
2069 r = bus_seal_synthetic_message(bus, m);
2073 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2074 hashmap_remove(bus->reply_callbacks, &c->cookie);
2077 bus->iteration_counter ++;
2079 r = c->callback(bus, m, c->userdata, &error_buffer);
2080 r = bus_maybe_reply_error(m, r, &error_buffer);
2083 bus->current = NULL;
2088 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2092 if (bus->state != BUS_HELLO)
2095 /* Let's make sure the first message on the bus is the HELLO
2096 * reply. But note that we don't actually parse the message
2097 * here (we leave that to the usual handling), we just verify
2098 * we don't let any earlier msg through. */
2100 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2101 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2104 if (m->reply_cookie != bus->hello_cookie)
2110 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2111 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2112 struct reply_callback *c;
2118 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2119 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2122 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2126 if (c->timeout != 0)
2127 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2129 r = sd_bus_message_rewind(m, true);
2133 r = c->callback(bus, m, c->userdata, &error_buffer);
2134 r = bus_maybe_reply_error(m, r, &error_buffer);
2140 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2141 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2142 struct filter_callback *l;
2149 bus->filter_callbacks_modified = false;
2151 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2153 if (bus->filter_callbacks_modified)
2156 /* Don't run this more than once per iteration */
2157 if (l->last_iteration == bus->iteration_counter)
2160 l->last_iteration = bus->iteration_counter;
2162 r = sd_bus_message_rewind(m, true);
2166 r = l->callback(bus, m, l->userdata, &error_buffer);
2167 r = bus_maybe_reply_error(m, r, &error_buffer);
2173 } while (bus->filter_callbacks_modified);
2178 static int process_match(sd_bus *bus, sd_bus_message *m) {
2185 bus->match_callbacks_modified = false;
2187 r = bus_match_run(bus, &bus->match_callbacks, m);
2191 } while (bus->match_callbacks_modified);
2196 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2197 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2203 if (bus->manual_peer_interface)
2206 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2209 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2212 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2215 if (streq_ptr(m->member, "Ping"))
2216 r = sd_bus_message_new_method_return(m, &reply);
2217 else if (streq_ptr(m->member, "GetMachineId")) {
2221 r = sd_id128_get_machine(&id);
2225 r = sd_bus_message_new_method_return(m, &reply);
2229 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2231 r = sd_bus_message_new_method_errorf(
2233 SD_BUS_ERROR_UNKNOWN_METHOD,
2234 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2240 r = sd_bus_send(bus, reply, NULL);
2247 static int process_message(sd_bus *bus, sd_bus_message *m) {
2254 bus->iteration_counter++;
2256 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2257 bus_message_type_to_string(m->header->type),
2258 strna(sd_bus_message_get_sender(m)),
2259 strna(sd_bus_message_get_destination(m)),
2260 strna(sd_bus_message_get_path(m)),
2261 strna(sd_bus_message_get_interface(m)),
2262 strna(sd_bus_message_get_member(m)),
2263 (unsigned long) BUS_MESSAGE_COOKIE(m),
2264 (unsigned long) m->reply_cookie,
2265 strna(m->error.message));
2267 r = process_hello(bus, m);
2271 r = process_reply(bus, m);
2275 r = process_filter(bus, m);
2279 r = process_match(bus, m);
2283 r = process_builtin(bus, m);
2287 r = bus_process_object(bus, m);
2290 bus->current = NULL;
2294 static int dispatch_track(sd_bus *bus) {
2297 if (!bus->track_queue)
2300 bus_track_dispatch(bus->track_queue);
2304 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2305 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2309 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2311 r = process_timeout(bus);
2315 r = dispatch_wqueue(bus);
2319 r = dispatch_track(bus);
2323 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2329 r = process_message(bus, m);
2334 r = sd_bus_message_rewind(m, true);
2343 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2345 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2346 strna(sd_bus_message_get_sender(m)),
2347 strna(sd_bus_message_get_path(m)),
2348 strna(sd_bus_message_get_interface(m)),
2349 strna(sd_bus_message_get_member(m)));
2351 r = sd_bus_reply_method_errorf(
2353 SD_BUS_ERROR_UNKNOWN_OBJECT,
2354 "Unknown object '%s'.", m->path);
2368 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2369 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2370 struct reply_callback *c;
2374 assert(bus->state == BUS_CLOSING);
2376 c = hashmap_first(bus->reply_callbacks);
2378 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2380 /* First, fail all outstanding method calls */
2381 r = bus_message_new_synthetic_error(
2384 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2389 r = bus_seal_synthetic_message(bus, m);
2393 if (c->timeout != 0)
2394 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2396 hashmap_remove(bus->reply_callbacks, &c->cookie);
2399 bus->iteration_counter++;
2401 r = c->callback(bus, m, c->userdata, &error_buffer);
2402 r = bus_maybe_reply_error(m, r, &error_buffer);
2408 /* Then, synthesize a Disconnected message */
2409 r = sd_bus_message_new_signal(
2412 "/org/freedesktop/DBus/Local",
2413 "org.freedesktop.DBus.Local",
2418 m->sender = "org.freedesktop.DBus.Local";
2420 r = bus_seal_synthetic_message(bus, m);
2427 bus->iteration_counter++;
2429 r = process_filter(bus, m);
2433 r = process_match(bus, m);
2445 bus->current = NULL;
2449 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2450 BUS_DONT_DESTROY(bus);
2453 /* Returns 0 when we didn't do anything. This should cause the
2454 * caller to invoke sd_bus_wait() before returning the next
2455 * time. Returns > 0 when we did something, which possibly
2456 * means *ret is filled in with an unprocessed message. */
2458 assert_return(bus, -EINVAL);
2459 assert_return(!bus_pid_changed(bus), -ECHILD);
2461 /* We don't allow recursively invoking sd_bus_process(). */
2462 assert_return(!bus->current, -EBUSY);
2464 switch (bus->state) {
2473 r = bus_socket_process_opening(bus);
2474 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2475 bus_enter_closing(bus);
2483 case BUS_AUTHENTICATING:
2484 r = bus_socket_process_authenticating(bus);
2485 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2486 bus_enter_closing(bus);
2498 r = process_running(bus, hint_priority, priority, ret);
2499 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2500 bus_enter_closing(bus);
2510 return process_closing(bus, ret);
2513 assert_not_reached("Unknown state");
2516 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2517 return bus_process_internal(bus, false, 0, ret);
2520 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2521 return bus_process_internal(bus, true, priority, ret);
2524 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2525 struct pollfd p[2] = {};
2528 usec_t m = (usec_t) -1;
2532 if (bus->state == BUS_CLOSING)
2535 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2537 e = sd_bus_get_events(bus);
2542 /* The caller really needs some more data, he doesn't
2543 * care about what's already read, or any timeouts
2548 /* The caller wants to process if there's something to
2549 * process, but doesn't care otherwise */
2551 r = sd_bus_get_timeout(bus, &until);
2556 nw = now(CLOCK_MONOTONIC);
2557 m = until > nw ? until - nw : 0;
2561 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2564 p[0].fd = bus->input_fd;
2565 if (bus->output_fd == bus->input_fd) {
2569 p[0].events = e & POLLIN;
2570 p[1].fd = bus->output_fd;
2571 p[1].events = e & POLLOUT;
2575 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2579 return r > 0 ? 1 : 0;
2582 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2584 assert_return(bus, -EINVAL);
2585 assert_return(!bus_pid_changed(bus), -ECHILD);
2587 if (bus->state == BUS_CLOSING)
2590 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2592 if (bus->rqueue_size > 0)
2595 return bus_poll(bus, false, timeout_usec);
2598 _public_ int sd_bus_flush(sd_bus *bus) {
2601 assert_return(bus, -EINVAL);
2602 assert_return(!bus_pid_changed(bus), -ECHILD);
2604 if (bus->state == BUS_CLOSING)
2607 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2609 r = bus_ensure_running(bus);
2613 if (bus->wqueue_size <= 0)
2617 r = dispatch_wqueue(bus);
2619 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2620 bus_enter_closing(bus);
2627 if (bus->wqueue_size <= 0)
2630 r = bus_poll(bus, false, (uint64_t) -1);
2636 _public_ int sd_bus_add_filter(sd_bus *bus,
2637 sd_bus_message_handler_t callback,
2640 struct filter_callback *f;
2642 assert_return(bus, -EINVAL);
2643 assert_return(callback, -EINVAL);
2644 assert_return(!bus_pid_changed(bus), -ECHILD);
2646 f = new0(struct filter_callback, 1);
2649 f->callback = callback;
2650 f->userdata = userdata;
2652 bus->filter_callbacks_modified = true;
2653 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2657 _public_ int sd_bus_remove_filter(sd_bus *bus,
2658 sd_bus_message_handler_t callback,
2661 struct filter_callback *f;
2663 assert_return(bus, -EINVAL);
2664 assert_return(callback, -EINVAL);
2665 assert_return(!bus_pid_changed(bus), -ECHILD);
2667 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2668 if (f->callback == callback && f->userdata == userdata) {
2669 bus->filter_callbacks_modified = true;
2670 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2679 _public_ int sd_bus_add_match(sd_bus *bus,
2681 sd_bus_message_handler_t callback,
2684 struct bus_match_component *components = NULL;
2685 unsigned n_components = 0;
2686 uint64_t cookie = 0;
2689 assert_return(bus, -EINVAL);
2690 assert_return(match, -EINVAL);
2691 assert_return(!bus_pid_changed(bus), -ECHILD);
2693 r = bus_match_parse(match, &components, &n_components);
2697 if (bus->bus_client) {
2698 cookie = ++bus->match_cookie;
2700 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2705 bus->match_callbacks_modified = true;
2706 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2708 if (bus->bus_client)
2709 bus_remove_match_internal(bus, match, cookie);
2713 bus_match_parse_free(components, n_components);
2717 _public_ int sd_bus_remove_match(sd_bus *bus,
2719 sd_bus_message_handler_t callback,
2722 struct bus_match_component *components = NULL;
2723 unsigned n_components = 0;
2725 uint64_t cookie = 0;
2727 assert_return(bus, -EINVAL);
2728 assert_return(match, -EINVAL);
2729 assert_return(!bus_pid_changed(bus), -ECHILD);
2731 r = bus_match_parse(match, &components, &n_components);
2735 bus->match_callbacks_modified = true;
2736 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2738 if (bus->bus_client)
2739 q = bus_remove_match_internal(bus, match, cookie);
2741 bus_match_parse_free(components, n_components);
2743 return r < 0 ? r : q;
2746 bool bus_pid_changed(sd_bus *bus) {
2749 /* We don't support people creating a bus connection and
2750 * keeping it around over a fork(). Let's complain. */
2752 return bus->original_pid != getpid();
2755 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2756 sd_bus *bus = userdata;
2761 r = sd_bus_process(bus, NULL);
2768 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2769 sd_bus *bus = userdata;
2774 r = sd_bus_process(bus, NULL);
2781 static int prepare_callback(sd_event_source *s, void *userdata) {
2782 sd_bus *bus = userdata;
2789 e = sd_bus_get_events(bus);
2793 if (bus->output_fd != bus->input_fd) {
2795 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2799 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2803 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2808 r = sd_bus_get_timeout(bus, &until);
2814 j = sd_event_source_set_time(bus->time_event_source, until);
2819 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2826 static int quit_callback(sd_event_source *event, void *userdata) {
2827 sd_bus *bus = userdata;
2836 static int attach_io_events(sd_bus *bus) {
2841 if (bus->input_fd < 0)
2847 if (!bus->input_io_event_source) {
2848 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2852 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2856 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2858 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2863 if (bus->output_fd != bus->input_fd) {
2864 assert(bus->output_fd >= 0);
2866 if (!bus->output_io_event_source) {
2867 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
2871 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2873 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2882 static void detach_io_events(sd_bus *bus) {
2885 if (bus->input_io_event_source) {
2886 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2887 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2890 if (bus->output_io_event_source) {
2891 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2892 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2896 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2899 assert_return(bus, -EINVAL);
2900 assert_return(!bus->event, -EBUSY);
2902 assert(!bus->input_io_event_source);
2903 assert(!bus->output_io_event_source);
2904 assert(!bus->time_event_source);
2907 bus->event = sd_event_ref(event);
2909 r = sd_event_default(&bus->event);
2914 bus->event_priority = priority;
2916 r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus);
2920 r = sd_event_source_set_priority(bus->time_event_source, priority);
2924 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
2928 r = attach_io_events(bus);
2935 sd_bus_detach_event(bus);
2939 _public_ int sd_bus_detach_event(sd_bus *bus) {
2940 assert_return(bus, -EINVAL);
2945 detach_io_events(bus);
2947 if (bus->time_event_source) {
2948 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2949 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2952 if (bus->quit_event_source) {
2953 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2954 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2958 bus->event = sd_event_unref(bus->event);
2963 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2964 assert_return(bus, NULL);
2969 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2970 assert_return(bus, NULL);
2972 return bus->current;
2975 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2980 assert(default_bus);
2983 return !!*default_bus;
2986 *ret = sd_bus_ref(*default_bus);
2994 b->default_bus_ptr = default_bus;
3002 _public_ int sd_bus_default_system(sd_bus **ret) {
3003 static thread_local sd_bus *default_system_bus = NULL;
3005 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3008 _public_ int sd_bus_default_user(sd_bus **ret) {
3009 static thread_local sd_bus *default_user_bus = NULL;
3011 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3014 _public_ int sd_bus_default(sd_bus **ret) {
3018 /* Let's try our best to reuse another cached connection. If
3019 * the starter bus type is set, connect via our normal
3020 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3021 * we can share the connection with the user/system default
3024 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3026 if (streq(e, "system"))
3027 return sd_bus_default_system(ret);
3028 else if (streq(e, "user") || streq(e, "session"))
3029 return sd_bus_default_user(ret);
3032 /* No type is specified, so we have not other option than to
3033 * use the starter address if it is set. */
3035 e = secure_getenv("DBUS_STARTER_ADDRESS");
3037 static thread_local sd_bus *default_starter_bus = NULL;
3039 return bus_default(sd_bus_open, &default_starter_bus, ret);
3042 /* Finally, if nothing is set use the cached connection for
3043 * the right scope */
3045 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3046 return sd_bus_default_user(ret);
3048 return sd_bus_default_system(ret);
3051 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3052 assert_return(b, -EINVAL);
3053 assert_return(tid, -EINVAL);
3054 assert_return(!bus_pid_changed(b), -ECHILD);
3062 return sd_event_get_tid(b->event, tid);
3067 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3068 _cleanup_free_ char *e = NULL;
3071 assert_return(object_path_is_valid(prefix), -EINVAL);
3072 assert_return(external_id, -EINVAL);
3073 assert_return(ret_path, -EINVAL);
3075 e = bus_label_escape(external_id);
3079 ret = strjoin(prefix, "/", e, NULL);
3087 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3091 assert_return(object_path_is_valid(path), -EINVAL);
3092 assert_return(object_path_is_valid(prefix), -EINVAL);
3093 assert_return(external_id, -EINVAL);
3095 e = object_path_startswith(path, prefix);
3097 *external_id = NULL;
3101 ret = bus_label_unescape(e);
3109 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3114 assert_return(bus, -EINVAL);
3115 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3116 assert_return(ret, -EINVAL);
3117 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3118 assert_return(!bus_pid_changed(bus), -ECHILD);
3119 assert_return(!bus->is_kernel, -ENOTSUP);
3121 if (!bus->ucred_valid && !isempty(bus->label))
3124 c = bus_creds_new();
3128 if (bus->ucred_valid) {
3129 pid = c->pid = bus->ucred.pid;
3130 c->uid = bus->ucred.uid;
3131 c->gid = bus->ucred.gid;
3133 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3136 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3137 c->label = strdup(bus->label);
3139 sd_bus_creds_unref(c);
3143 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3146 r = bus_creds_add_more(c, mask, pid, 0);
3154 _public_ int sd_bus_try_close(sd_bus *bus) {
3157 assert_return(bus, -EINVAL);
3158 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3159 assert_return(!bus_pid_changed(bus), -ECHILD);
3160 assert_return(bus->is_kernel, -ENOTSUP);
3162 if (bus->rqueue_size > 0)
3165 if (bus->wqueue_size > 0)
3168 r = bus_kernel_try_close(bus);
3176 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3177 assert_return(bus, -EINVAL);
3178 assert_return(name, -EINVAL);
3179 assert_return(!bus_pid_changed(bus), -ECHILD);
3181 *name = bus->connection_name;