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 safe_close(b->input_fd);
68 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
69 safe_close(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 /* NOTE: We _must_ decrement b->Xqueue_size before calling
115 * sd_bus_message_unref() for _each_ message. Otherwise the
116 * self-reference checks in sd_bus_unref() will fire for each message.
117 * We would thus recurse into sd_bus_message_unref() and trigger the
118 * assert(m->n_ref > 0) */
120 while (b->rqueue_size > 0)
121 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
125 b->rqueue_allocated = 0;
127 while (b->wqueue_size > 0)
128 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
132 b->wqueue_allocated = 0;
135 static void bus_free(sd_bus *b) {
136 struct filter_callback *f;
141 assert(!b->track_queue);
143 sd_bus_detach_event(b);
145 if (b->default_bus_ptr)
146 *b->default_bus_ptr = NULL;
151 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
154 free(b->unique_name);
155 free(b->auth_buffer);
160 free(b->cgroup_root);
161 free(b->connection_name);
164 strv_free(b->exec_argv);
166 close_many(b->fds, b->n_fds);
171 hashmap_free_free(b->reply_callbacks);
172 prioq_free(b->reply_callbacks_prioq);
174 while ((f = b->filter_callbacks)) {
175 LIST_REMOVE(callbacks, b->filter_callbacks, f);
179 bus_match_free(&b->match_callbacks);
181 hashmap_free_free(b->vtable_methods);
182 hashmap_free_free(b->vtable_properties);
184 while ((n = hashmap_first(b->nodes)))
185 bus_node_destroy(b, n);
187 hashmap_free(b->nodes);
189 bus_kernel_flush_memfd(b);
191 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
196 _public_ int sd_bus_new(sd_bus **ret) {
199 assert_return(ret, -EINVAL);
205 r->n_ref = REFCNT_INIT;
206 r->input_fd = r->output_fd = -1;
207 r->message_version = 1;
208 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
209 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
210 r->attach_flags |= KDBUS_ATTACH_NAMES;
211 r->original_pid = getpid();
213 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
215 /* We guarantee that wqueue always has space for at least one
217 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
226 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
229 assert_return(bus, -EINVAL);
230 assert_return(bus->state == BUS_UNSET, -EPERM);
231 assert_return(address, -EINVAL);
232 assert_return(!bus_pid_changed(bus), -ECHILD);
244 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
245 assert_return(bus, -EINVAL);
246 assert_return(bus->state == BUS_UNSET, -EPERM);
247 assert_return(input_fd >= 0, -EINVAL);
248 assert_return(output_fd >= 0, -EINVAL);
249 assert_return(!bus_pid_changed(bus), -ECHILD);
251 bus->input_fd = input_fd;
252 bus->output_fd = output_fd;
256 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
259 assert_return(bus, -EINVAL);
260 assert_return(bus->state == BUS_UNSET, -EPERM);
261 assert_return(path, -EINVAL);
262 assert_return(!strv_isempty(argv), -EINVAL);
263 assert_return(!bus_pid_changed(bus), -ECHILD);
275 free(bus->exec_path);
276 strv_free(bus->exec_argv);
284 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
285 assert_return(bus, -EINVAL);
286 assert_return(bus->state == BUS_UNSET, -EPERM);
287 assert_return(!bus_pid_changed(bus), -ECHILD);
289 bus->bus_client = !!b;
293 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
294 assert_return(bus, -EINVAL);
295 assert_return(bus->state == BUS_UNSET, -EPERM);
296 assert_return(!bus_pid_changed(bus), -ECHILD);
298 SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
302 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
303 assert_return(bus, -EINVAL);
304 assert_return(bus->state == BUS_UNSET, -EPERM);
305 assert_return(!bus_pid_changed(bus), -ECHILD);
307 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
311 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
312 assert_return(bus, -EINVAL);
313 assert_return(bus->state == BUS_UNSET, -EPERM);
314 assert_return(!bus_pid_changed(bus), -ECHILD);
316 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
320 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
321 assert_return(bus, -EINVAL);
322 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
323 assert_return(bus->state == BUS_UNSET, -EPERM);
324 assert_return(!bus_pid_changed(bus), -ECHILD);
326 /* The well knowns we need unconditionally, so that matches can work */
327 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
329 return kdbus_translate_attach_flags(bus->creds_mask, &bus->attach_flags);
332 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
333 assert_return(bus, -EINVAL);
334 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
335 assert_return(bus->state == BUS_UNSET, -EPERM);
336 assert_return(!bus_pid_changed(bus), -ECHILD);
338 bus->is_server = !!b;
339 bus->server_id = server_id;
343 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
344 assert_return(bus, -EINVAL);
345 assert_return(bus->state == BUS_UNSET, -EPERM);
346 assert_return(!bus_pid_changed(bus), -ECHILD);
348 bus->anonymous_auth = !!b;
352 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
353 assert_return(bus, -EINVAL);
354 assert_return(bus->state == BUS_UNSET, -EPERM);
355 assert_return(!bus_pid_changed(bus), -ECHILD);
361 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
364 assert_return(bus, -EINVAL);
365 assert_return(name, -EINVAL);
366 assert_return(bus->state == BUS_UNSET, -EPERM);
367 assert_return(!bus_pid_changed(bus), -ECHILD);
373 free(bus->connection_name);
374 bus->connection_name = n;
379 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
384 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
387 r = sd_bus_message_get_errno(reply);
393 r = sd_bus_message_read(reply, "s", &s);
397 if (!service_name_is_valid(s) || s[0] != ':')
400 bus->unique_name = strdup(s);
401 if (!bus->unique_name)
404 if (bus->state == BUS_HELLO)
405 bus->state = BUS_RUNNING;
410 static int bus_send_hello(sd_bus *bus) {
411 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
416 if (!bus->bus_client || bus->is_kernel)
419 r = sd_bus_message_new_method_call(
422 "org.freedesktop.DBus",
423 "/org/freedesktop/DBus",
424 "org.freedesktop.DBus",
429 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie);
432 int bus_start_running(sd_bus *bus) {
435 if (bus->bus_client && !bus->is_kernel) {
436 bus->state = BUS_HELLO;
440 bus->state = BUS_RUNNING;
444 static int parse_address_key(const char **p, const char *key, char **value) {
445 size_t l, n = 0, allocated = 0;
455 if (strncmp(*p, key, l) != 0)
468 while (*a != ';' && *a != ',' && *a != 0) {
486 c = (char) ((x << 4) | y);
493 if (!GREEDY_REALLOC(r, allocated, n + 2))
517 static void skip_address_key(const char **p) {
521 *p += strcspn(*p, ",");
527 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
528 _cleanup_free_ char *path = NULL, *abstract = NULL;
537 while (**p != 0 && **p != ';') {
538 r = parse_address_key(p, "guid", guid);
544 r = parse_address_key(p, "path", &path);
550 r = parse_address_key(p, "abstract", &abstract);
559 if (!path && !abstract)
562 if (path && abstract)
567 if (l > sizeof(b->sockaddr.un.sun_path))
570 b->sockaddr.un.sun_family = AF_UNIX;
571 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
572 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
573 } else if (abstract) {
574 l = strlen(abstract);
575 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
578 b->sockaddr.un.sun_family = AF_UNIX;
579 b->sockaddr.un.sun_path[0] = 0;
580 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
581 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
587 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
588 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
590 struct addrinfo *result, hints = {
591 .ai_socktype = SOCK_STREAM,
592 .ai_flags = AI_ADDRCONFIG,
600 while (**p != 0 && **p != ';') {
601 r = parse_address_key(p, "guid", guid);
607 r = parse_address_key(p, "host", &host);
613 r = parse_address_key(p, "port", &port);
619 r = parse_address_key(p, "family", &family);
632 if (streq(family, "ipv4"))
633 hints.ai_family = AF_INET;
634 else if (streq(family, "ipv6"))
635 hints.ai_family = AF_INET6;
640 r = getaddrinfo(host, port, &hints, &result);
644 return -EADDRNOTAVAIL;
646 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
647 b->sockaddr_size = result->ai_addrlen;
649 freeaddrinfo(result);
654 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
656 unsigned n_argv = 0, j;
658 size_t allocated = 0;
666 while (**p != 0 && **p != ';') {
667 r = parse_address_key(p, "guid", guid);
673 r = parse_address_key(p, "path", &path);
679 if (startswith(*p, "argv")) {
683 ul = strtoul(*p + 4, (char**) p, 10);
684 if (errno > 0 || **p != '=' || ul > 256) {
692 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
700 r = parse_address_key(p, NULL, argv + ul);
715 /* Make sure there are no holes in the array, with the
716 * exception of argv[0] */
717 for (j = 1; j < n_argv; j++)
723 if (argv && argv[0] == NULL) {
724 argv[0] = strdup(path);
736 for (j = 0; j < n_argv; j++)
744 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
745 _cleanup_free_ char *path = NULL;
753 while (**p != 0 && **p != ';') {
754 r = parse_address_key(p, "guid", guid);
760 r = parse_address_key(p, "path", &path);
779 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
780 _cleanup_free_ char *machine = NULL;
788 while (**p != 0 && **p != ';') {
789 r = parse_address_key(p, "guid", guid);
795 r = parse_address_key(p, "machine", &machine);
807 if (!filename_is_safe(machine))
811 b->machine = machine;
814 b->sockaddr.un.sun_family = AF_UNIX;
815 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
816 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
821 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
822 _cleanup_free_ char *machine = NULL;
830 while (**p != 0 && **p != ';') {
831 r = parse_address_key(p, "guid", guid);
837 r = parse_address_key(p, "machine", &machine);
849 if (!filename_is_safe(machine))
853 b->machine = machine;
857 b->kernel = strdup("/dev/kdbus/0-system/bus");
864 static void bus_reset_parsed_address(sd_bus *b) {
868 b->sockaddr_size = 0;
869 strv_free(b->exec_argv);
873 b->server_id = SD_ID128_NULL;
880 static int bus_parse_next_address(sd_bus *b) {
881 _cleanup_free_ char *guid = NULL;
889 if (b->address[b->address_index] == 0)
892 bus_reset_parsed_address(b);
894 a = b->address + b->address_index;
903 if (startswith(a, "unix:")) {
906 r = parse_unix_address(b, &a, &guid);
911 } else if (startswith(a, "tcp:")) {
914 r = parse_tcp_address(b, &a, &guid);
920 } else if (startswith(a, "unixexec:")) {
923 r = parse_exec_address(b, &a, &guid);
929 } else if (startswith(a, "kernel:")) {
932 r = parse_kernel_address(b, &a, &guid);
937 } else if (startswith(a, "x-container-unix:")) {
940 r = parse_container_unix_address(b, &a, &guid);
945 } else if (startswith(a, "x-container-kernel:")) {
948 r = parse_container_kernel_address(b, &a, &guid);
961 r = sd_id128_from_string(guid, &b->server_id);
966 b->address_index = a - b->address;
970 static int bus_start_address(sd_bus *b) {
976 bool skipped = false;
981 r = bus_socket_exec(b);
982 else if (b->machine && b->kernel)
983 r = bus_container_connect_kernel(b);
984 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
985 r = bus_container_connect_socket(b);
987 r = bus_kernel_connect(b);
988 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
989 r = bus_socket_connect(b);
995 r = attach_io_events(b);
1000 b->last_connect_error = -r;
1003 r = bus_parse_next_address(b);
1007 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1011 int bus_next_address(sd_bus *b) {
1014 bus_reset_parsed_address(b);
1015 return bus_start_address(b);
1018 static int bus_start_fd(sd_bus *b) {
1023 assert(b->input_fd >= 0);
1024 assert(b->output_fd >= 0);
1026 r = fd_nonblock(b->input_fd, true);
1030 r = fd_cloexec(b->input_fd, true);
1034 if (b->input_fd != b->output_fd) {
1035 r = fd_nonblock(b->output_fd, true);
1039 r = fd_cloexec(b->output_fd, true);
1044 if (fstat(b->input_fd, &st) < 0)
1047 if (S_ISCHR(b->input_fd))
1048 return bus_kernel_take_fd(b);
1050 return bus_socket_take_fd(b);
1053 _public_ int sd_bus_start(sd_bus *bus) {
1056 assert_return(bus, -EINVAL);
1057 assert_return(bus->state == BUS_UNSET, -EPERM);
1058 assert_return(!bus_pid_changed(bus), -ECHILD);
1060 bus->state = BUS_OPENING;
1062 if (bus->is_server && bus->bus_client)
1065 if (bus->input_fd >= 0)
1066 r = bus_start_fd(bus);
1067 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1068 r = bus_start_address(bus);
1075 return bus_send_hello(bus);
1078 _public_ int sd_bus_open(sd_bus **ret) {
1083 assert_return(ret, -EINVAL);
1085 /* Let's connect to the starter bus if it is set, and
1086 * otherwise to the bus that is appropropriate for the scope
1087 * we are running in */
1089 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1091 if (streq(e, "system"))
1092 return sd_bus_open_system(ret);
1093 else if (STR_IN_SET(e, "session", "user"))
1094 return sd_bus_open_user(ret);
1097 e = secure_getenv("DBUS_STARTER_ADDRESS");
1099 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1100 return sd_bus_open_user(ret);
1102 return sd_bus_open_system(ret);
1109 r = sd_bus_set_address(b, e);
1113 b->bus_client = true;
1115 /* We don't know whether the bus is trusted or not, so better
1116 * be safe, and authenticate everything */
1118 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1120 r = sd_bus_start(b);
1132 int bus_set_address_system(sd_bus *b) {
1136 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1138 return sd_bus_set_address(b, e);
1140 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1143 _public_ int sd_bus_open_system(sd_bus **ret) {
1147 assert_return(ret, -EINVAL);
1153 r = bus_set_address_system(b);
1157 b->bus_client = true;
1158 b->is_system = true;
1160 /* Let's do per-method access control on the system bus. We
1161 * need the caller's UID and capability set for that. */
1163 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1165 r = sd_bus_start(b);
1177 int bus_set_address_user(sd_bus *b) {
1182 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1184 return sd_bus_set_address(b, e);
1186 e = secure_getenv("XDG_RUNTIME_DIR");
1188 _cleanup_free_ char *ee = NULL;
1190 ee = bus_address_escape(e);
1195 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee);
1197 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1201 asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
1203 return -ECONNREFUSED;
1213 _public_ int sd_bus_open_user(sd_bus **ret) {
1217 assert_return(ret, -EINVAL);
1223 r = bus_set_address_user(b);
1227 b->bus_client = true;
1230 /* We don't do any per-method access control on the user
1234 r = sd_bus_start(b);
1246 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1247 _cleanup_free_ char *e = NULL;
1252 e = bus_address_escape(host);
1256 b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1263 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1267 assert_return(host, -EINVAL);
1268 assert_return(ret, -EINVAL);
1270 r = sd_bus_new(&bus);
1274 r = bus_set_address_system_remote(bus, host);
1278 bus->bus_client = true;
1279 bus->trusted = false;
1281 r = sd_bus_start(bus);
1293 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1294 _cleanup_free_ char *e = NULL;
1299 e = bus_address_escape(machine);
1304 b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1306 b->address = strjoin("x-container-unix:machine=", e, NULL);
1314 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1318 assert_return(machine, -EINVAL);
1319 assert_return(ret, -EINVAL);
1320 assert_return(filename_is_safe(machine), -EINVAL);
1322 r = sd_bus_new(&bus);
1326 r = bus_set_address_system_container(bus, machine);
1330 bus->bus_client = true;
1331 bus->trusted = false;
1333 r = sd_bus_start(bus);
1345 _public_ void sd_bus_close(sd_bus *bus) {
1349 if (bus->state == BUS_CLOSED)
1351 if (bus_pid_changed(bus))
1354 bus->state = BUS_CLOSED;
1356 sd_bus_detach_event(bus);
1358 /* Drop all queued messages so that they drop references to
1359 * the bus object and the bus may be freed */
1360 bus_reset_queues(bus);
1362 if (!bus->is_kernel)
1365 /* We'll leave the fd open in case this is a kernel bus, since
1366 * there might still be memblocks around that reference this
1367 * bus, and they might need to invoke the KDBUS_CMD_FREE
1368 * ioctl on the fd when they are freed. */
1371 static void bus_enter_closing(sd_bus *bus) {
1374 if (bus->state != BUS_OPENING &&
1375 bus->state != BUS_AUTHENTICATING &&
1376 bus->state != BUS_HELLO &&
1377 bus->state != BUS_RUNNING)
1380 bus->state = BUS_CLOSING;
1383 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1384 assert_return(bus, NULL);
1386 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1391 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1397 if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
1400 for (i = 0; i < bus->rqueue_size; i++)
1401 if (bus->rqueue[i]->n_ref > 1) {
1407 for (i = 0; i < bus->wqueue_size; i++)
1408 if (bus->wqueue[i]->n_ref > 1) {
1414 /* We are the only holders on the messages, and the
1415 * messages are the only holders on us, so let's drop
1416 * the messages and thus implicitly also kill our own
1418 * bus_reset_queues() decrements the queue-size before
1419 * calling into sd_bus_message_unref(). Thus, it
1420 * protects us from recursion. */
1423 bus_reset_queues(bus);
1426 i = REFCNT_DEC(bus->n_ref);
1434 _public_ int sd_bus_is_open(sd_bus *bus) {
1436 assert_return(bus, -EINVAL);
1437 assert_return(!bus_pid_changed(bus), -ECHILD);
1439 return BUS_IS_OPEN(bus->state);
1442 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1445 assert_return(bus, -EINVAL);
1446 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1447 assert_return(!bus_pid_changed(bus), -ECHILD);
1449 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1452 if (type == SD_BUS_TYPE_UNIX_FD) {
1453 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1456 r = bus_ensure_running(bus);
1460 return bus->can_fds;
1463 return bus_type_is_valid(type);
1466 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1469 assert_return(bus, -EINVAL);
1470 assert_return(server_id, -EINVAL);
1471 assert_return(!bus_pid_changed(bus), -ECHILD);
1473 r = bus_ensure_running(bus);
1477 *server_id = bus->server_id;
1481 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1486 /* If we copy the same message to multiple
1487 * destinations, avoid using the same cookie
1489 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1494 timeout = BUS_DEFAULT_TIMEOUT;
1496 return bus_message_seal(m, ++b->cookie, timeout);
1499 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1502 /* Do packet version and endianness already match? */
1503 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1504 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1507 /* No? Then remarshal! */
1508 return bus_message_remarshal(b, m);
1511 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1515 /* The bus specification says the serial number cannot be 0,
1516 * hence let's fill something in for synthetic messages. Since
1517 * synthetic messages might have a fake sender and we don't
1518 * want to interfere with the real sender's serial numbers we
1519 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1520 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1521 * even though kdbus can do 64bit. */
1523 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1526 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1533 r = bus_kernel_write_message(bus, m, hint_sync_call);
1535 r = bus_socket_write_message(bus, m, idx);
1540 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1541 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1542 bus_message_type_to_string(m->header->type),
1543 strna(sd_bus_message_get_sender(m)),
1544 strna(sd_bus_message_get_destination(m)),
1545 strna(sd_bus_message_get_path(m)),
1546 strna(sd_bus_message_get_interface(m)),
1547 strna(sd_bus_message_get_member(m)),
1548 BUS_MESSAGE_COOKIE(m),
1550 strna(m->error.message));
1555 static int dispatch_wqueue(sd_bus *bus) {
1559 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1561 while (bus->wqueue_size > 0) {
1563 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1567 /* Didn't do anything this time */
1569 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1570 /* Fully written. Let's drop the entry from
1573 * This isn't particularly optimized, but
1574 * well, this is supposed to be our worst-case
1575 * buffer only, and the socket buffer is
1576 * supposed to be our primary buffer, and if
1577 * it got full, then all bets are off
1580 bus->wqueue_size --;
1581 sd_bus_message_unref(bus->wqueue[0]);
1582 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1592 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1596 return bus_kernel_read_message(bus, hint_priority, priority);
1598 return bus_socket_read_message(bus);
1601 int bus_rqueue_make_room(sd_bus *bus) {
1604 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1607 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1613 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1618 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1620 /* Note that the priority logic is only available on kdbus,
1621 * where the rqueue is unused. We check the rqueue here
1622 * anyway, because it's simple... */
1625 if (bus->rqueue_size > 0) {
1626 /* Dispatch a queued message */
1628 *m = bus->rqueue[0];
1629 bus->rqueue_size --;
1630 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1634 /* Try to read a new message */
1635 r = bus_read_message(bus, hint_priority, priority);
1645 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1646 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1649 assert_return(bus, -EINVAL);
1650 assert_return(m, -EINVAL);
1651 assert_return(!bus_pid_changed(bus), -ECHILD);
1652 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1654 if (!BUS_IS_OPEN(bus->state))
1658 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1665 /* If the cookie number isn't kept, then we know that no reply
1667 if (!cookie && !m->sealed)
1668 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1670 r = bus_seal_message(bus, m, 0);
1674 /* Remarshall if we have to. This will possibly unref the
1675 * message and place a replacement in m */
1676 r = bus_remarshal_message(bus, &m);
1680 /* If this is a reply and no reply was requested, then let's
1681 * suppress this, if we can */
1682 if (m->dont_send && !cookie)
1685 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1688 r = bus_write_message(bus, m, hint_sync_call, &idx);
1690 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1691 bus_enter_closing(bus);
1696 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1697 /* Wasn't fully written. So let's remember how
1698 * much was written. Note that the first entry
1699 * of the wqueue array is always allocated so
1700 * that we always can remember how much was
1702 bus->wqueue[0] = sd_bus_message_ref(m);
1703 bus->wqueue_size = 1;
1707 /* Just append it to the queue. */
1709 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1712 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1715 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1719 *cookie = BUS_MESSAGE_COOKIE(m);
1724 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1725 return bus_send_internal(bus, m, cookie, false);
1728 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1731 assert_return(bus, -EINVAL);
1732 assert_return(m, -EINVAL);
1733 assert_return(!bus_pid_changed(bus), -ECHILD);
1735 if (!BUS_IS_OPEN(bus->state))
1738 if (!streq_ptr(m->destination, destination)) {
1743 r = sd_bus_message_set_destination(m, destination);
1748 return sd_bus_send(bus, m, cookie);
1751 static usec_t calc_elapse(uint64_t usec) {
1752 if (usec == (uint64_t) -1)
1755 return now(CLOCK_MONOTONIC) + usec;
1758 static int timeout_compare(const void *a, const void *b) {
1759 const struct reply_callback *x = a, *y = b;
1761 if (x->timeout != 0 && y->timeout == 0)
1764 if (x->timeout == 0 && y->timeout != 0)
1767 if (x->timeout < y->timeout)
1770 if (x->timeout > y->timeout)
1776 _public_ int sd_bus_call_async(
1779 sd_bus_message_handler_t callback,
1784 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1785 struct reply_callback *c;
1788 assert_return(bus, -EINVAL);
1789 assert_return(m, -EINVAL);
1790 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1791 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1792 assert_return(callback, -EINVAL);
1793 assert_return(!bus_pid_changed(bus), -ECHILD);
1794 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1796 if (!BUS_IS_OPEN(bus->state))
1799 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1803 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1807 r = bus_seal_message(bus, m, usec);
1811 r = bus_remarshal_message(bus, &m);
1815 c = new0(struct reply_callback, 1);
1819 c->callback = callback;
1820 c->userdata = userdata;
1821 c->cookie = BUS_MESSAGE_COOKIE(m);
1822 c->timeout = calc_elapse(m->timeout);
1824 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1830 if (c->timeout != 0) {
1831 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1834 sd_bus_call_async_cancel(bus, c->cookie);
1839 r = sd_bus_send(bus, m, cookie);
1841 sd_bus_call_async_cancel(bus, c->cookie);
1848 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1849 struct reply_callback *c;
1851 assert_return(bus, -EINVAL);
1852 assert_return(cookie != 0, -EINVAL);
1853 assert_return(!bus_pid_changed(bus), -ECHILD);
1855 c = hashmap_remove(bus->reply_callbacks, &cookie);
1859 if (c->timeout != 0)
1860 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1866 int bus_ensure_running(sd_bus *bus) {
1871 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1873 if (bus->state == BUS_RUNNING)
1877 r = sd_bus_process(bus, NULL);
1880 if (bus->state == BUS_RUNNING)
1885 r = sd_bus_wait(bus, (uint64_t) -1);
1891 _public_ int sd_bus_call(
1895 sd_bus_error *error,
1896 sd_bus_message **reply) {
1898 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1904 assert_return(bus, -EINVAL);
1905 assert_return(m, -EINVAL);
1906 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1907 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1908 assert_return(!bus_error_is_dirty(error), -EINVAL);
1909 assert_return(!bus_pid_changed(bus), -ECHILD);
1910 assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1912 if (!BUS_IS_OPEN(bus->state))
1915 r = bus_ensure_running(bus);
1919 i = bus->rqueue_size;
1921 r = bus_seal_message(bus, m, usec);
1925 r = bus_remarshal_message(bus, &m);
1929 r = bus_send_internal(bus, m, &cookie, true);
1933 timeout = calc_elapse(m->timeout);
1938 while (i < bus->rqueue_size) {
1939 sd_bus_message *incoming = NULL;
1941 incoming = bus->rqueue[i];
1943 if (incoming->reply_cookie == cookie) {
1944 /* Found a match! */
1946 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1949 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1951 if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1955 sd_bus_message_unref(incoming);
1960 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1962 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1963 r = sd_bus_error_copy(error, &incoming->error);
1967 sd_bus_message_unref(incoming);
1970 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1973 streq(bus->unique_name, incoming->sender)) {
1975 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1978 /* Our own message? Somebody is trying
1979 * to send its own client a message,
1980 * let's not dead-lock, let's fail
1983 sd_bus_message_unref(incoming);
1987 /* Try to read more, right-away */
1991 r = bus_read_message(bus, false, 0);
1993 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1994 bus_enter_closing(bus);
2006 n = now(CLOCK_MONOTONIC);
2012 left = (uint64_t) -1;
2014 r = bus_poll(bus, true, left);
2020 r = dispatch_wqueue(bus);
2022 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2023 bus_enter_closing(bus);
2032 _public_ int sd_bus_get_fd(sd_bus *bus) {
2034 assert_return(bus, -EINVAL);
2035 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2036 assert_return(!bus_pid_changed(bus), -ECHILD);
2038 return bus->input_fd;
2041 _public_ int sd_bus_get_events(sd_bus *bus) {
2044 assert_return(bus, -EINVAL);
2045 assert_return(!bus_pid_changed(bus), -ECHILD);
2047 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2050 if (bus->state == BUS_OPENING)
2052 else if (bus->state == BUS_AUTHENTICATING) {
2054 if (bus_socket_auth_needs_write(bus))
2059 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2060 if (bus->rqueue_size <= 0)
2062 if (bus->wqueue_size > 0)
2069 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2070 struct reply_callback *c;
2072 assert_return(bus, -EINVAL);
2073 assert_return(timeout_usec, -EINVAL);
2074 assert_return(!bus_pid_changed(bus), -ECHILD);
2076 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2079 if (bus->track_queue) {
2084 if (bus->state == BUS_CLOSING) {
2089 if (bus->state == BUS_AUTHENTICATING) {
2090 *timeout_usec = bus->auth_timeout;
2094 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2095 *timeout_usec = (uint64_t) -1;
2099 if (bus->rqueue_size > 0) {
2104 c = prioq_peek(bus->reply_callbacks_prioq);
2106 *timeout_usec = (uint64_t) -1;
2110 *timeout_usec = c->timeout;
2114 static int process_timeout(sd_bus *bus) {
2115 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2116 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2117 struct reply_callback *c;
2123 c = prioq_peek(bus->reply_callbacks_prioq);
2127 n = now(CLOCK_MONOTONIC);
2131 r = bus_message_new_synthetic_error(
2134 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2139 m->sender = "org.freedesktop.DBus";
2141 r = bus_seal_synthetic_message(bus, m);
2145 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2146 hashmap_remove(bus->reply_callbacks, &c->cookie);
2149 bus->iteration_counter ++;
2151 r = c->callback(bus, m, c->userdata, &error_buffer);
2152 r = bus_maybe_reply_error(m, r, &error_buffer);
2155 bus->current = NULL;
2160 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2164 if (bus->state != BUS_HELLO)
2167 /* Let's make sure the first message on the bus is the HELLO
2168 * reply. But note that we don't actually parse the message
2169 * here (we leave that to the usual handling), we just verify
2170 * we don't let any earlier msg through. */
2172 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2173 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2176 if (m->reply_cookie != bus->hello_cookie)
2182 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2183 _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2184 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2185 _cleanup_free_ struct reply_callback *c = NULL;
2191 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2192 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2195 if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2198 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2201 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2205 if (c->timeout != 0)
2206 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2208 if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2210 /* If the reply contained a file descriptor which we
2211 * didn't want we pass an error instead. */
2213 r = bus_message_new_synthetic_error(
2216 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2221 r = bus_seal_synthetic_message(bus, synthetic_reply);
2225 m = synthetic_reply;
2227 r = sd_bus_message_rewind(m, true);
2232 r = c->callback(bus, m, c->userdata, &error_buffer);
2233 r = bus_maybe_reply_error(m, r, &error_buffer);
2238 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2239 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2240 struct filter_callback *l;
2247 bus->filter_callbacks_modified = false;
2249 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2251 if (bus->filter_callbacks_modified)
2254 /* Don't run this more than once per iteration */
2255 if (l->last_iteration == bus->iteration_counter)
2258 l->last_iteration = bus->iteration_counter;
2260 r = sd_bus_message_rewind(m, true);
2264 r = l->callback(bus, m, l->userdata, &error_buffer);
2265 r = bus_maybe_reply_error(m, r, &error_buffer);
2271 } while (bus->filter_callbacks_modified);
2276 static int process_match(sd_bus *bus, sd_bus_message *m) {
2283 bus->match_callbacks_modified = false;
2285 r = bus_match_run(bus, &bus->match_callbacks, m);
2289 } while (bus->match_callbacks_modified);
2294 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2295 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2301 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2304 if (bus->manual_peer_interface)
2307 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2310 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2313 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2316 if (streq_ptr(m->member, "Ping"))
2317 r = sd_bus_message_new_method_return(m, &reply);
2318 else if (streq_ptr(m->member, "GetMachineId")) {
2322 r = sd_id128_get_machine(&id);
2326 r = sd_bus_message_new_method_return(m, &reply);
2330 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2332 r = sd_bus_message_new_method_errorf(
2334 SD_BUS_ERROR_UNKNOWN_METHOD,
2335 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2341 r = sd_bus_send(bus, reply, NULL);
2348 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2352 /* If we got a message with a file descriptor which we didn't
2353 * want to accept, then let's drop it. How can this even
2354 * happen? For example, when the kernel queues a message into
2355 * an activatable names's queue which allows fds, and then is
2356 * delivered to us later even though we ourselves did not
2359 if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2365 if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2368 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2369 return 1; /* just eat it up */
2371 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2374 static int process_message(sd_bus *bus, sd_bus_message *m) {
2381 bus->iteration_counter++;
2383 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2384 bus_message_type_to_string(m->header->type),
2385 strna(sd_bus_message_get_sender(m)),
2386 strna(sd_bus_message_get_destination(m)),
2387 strna(sd_bus_message_get_path(m)),
2388 strna(sd_bus_message_get_interface(m)),
2389 strna(sd_bus_message_get_member(m)),
2390 BUS_MESSAGE_COOKIE(m),
2392 strna(m->error.message));
2394 r = process_hello(bus, m);
2398 r = process_reply(bus, m);
2402 r = process_fd_check(bus, m);
2406 r = process_filter(bus, m);
2410 r = process_match(bus, m);
2414 r = process_builtin(bus, m);
2418 r = bus_process_object(bus, m);
2421 bus->current = NULL;
2425 static int dispatch_track(sd_bus *bus) {
2428 if (!bus->track_queue)
2431 bus_track_dispatch(bus->track_queue);
2435 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2436 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2440 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2442 r = process_timeout(bus);
2446 r = dispatch_wqueue(bus);
2450 r = dispatch_track(bus);
2454 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2460 r = process_message(bus, m);
2465 r = sd_bus_message_rewind(m, true);
2474 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2476 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2477 strna(sd_bus_message_get_sender(m)),
2478 strna(sd_bus_message_get_path(m)),
2479 strna(sd_bus_message_get_interface(m)),
2480 strna(sd_bus_message_get_member(m)));
2482 r = sd_bus_reply_method_errorf(
2484 SD_BUS_ERROR_UNKNOWN_OBJECT,
2485 "Unknown object '%s'.", m->path);
2499 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2500 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2501 struct reply_callback *c;
2505 assert(bus->state == BUS_CLOSING);
2507 c = hashmap_first(bus->reply_callbacks);
2509 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2511 /* First, fail all outstanding method calls */
2512 r = bus_message_new_synthetic_error(
2515 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2520 r = bus_seal_synthetic_message(bus, m);
2524 if (c->timeout != 0)
2525 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2527 hashmap_remove(bus->reply_callbacks, &c->cookie);
2530 bus->iteration_counter++;
2532 r = c->callback(bus, m, c->userdata, &error_buffer);
2533 r = bus_maybe_reply_error(m, r, &error_buffer);
2539 /* Then, synthesize a Disconnected message */
2540 r = sd_bus_message_new_signal(
2543 "/org/freedesktop/DBus/Local",
2544 "org.freedesktop.DBus.Local",
2549 m->sender = "org.freedesktop.DBus.Local";
2551 r = bus_seal_synthetic_message(bus, m);
2558 bus->iteration_counter++;
2560 r = process_filter(bus, m);
2564 r = process_match(bus, m);
2576 bus->current = NULL;
2580 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2581 BUS_DONT_DESTROY(bus);
2584 /* Returns 0 when we didn't do anything. This should cause the
2585 * caller to invoke sd_bus_wait() before returning the next
2586 * time. Returns > 0 when we did something, which possibly
2587 * means *ret is filled in with an unprocessed message. */
2589 assert_return(bus, -EINVAL);
2590 assert_return(!bus_pid_changed(bus), -ECHILD);
2592 /* We don't allow recursively invoking sd_bus_process(). */
2593 assert_return(!bus->current, -EBUSY);
2595 switch (bus->state) {
2604 r = bus_socket_process_opening(bus);
2605 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2606 bus_enter_closing(bus);
2614 case BUS_AUTHENTICATING:
2615 r = bus_socket_process_authenticating(bus);
2616 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2617 bus_enter_closing(bus);
2629 r = process_running(bus, hint_priority, priority, ret);
2630 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2631 bus_enter_closing(bus);
2641 return process_closing(bus, ret);
2644 assert_not_reached("Unknown state");
2647 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2648 return bus_process_internal(bus, false, 0, ret);
2651 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2652 return bus_process_internal(bus, true, priority, ret);
2655 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2656 struct pollfd p[2] = {};
2659 usec_t m = (usec_t) -1;
2663 if (bus->state == BUS_CLOSING)
2666 if (!BUS_IS_OPEN(bus->state))
2669 e = sd_bus_get_events(bus);
2674 /* The caller really needs some more data, he doesn't
2675 * care about what's already read, or any timeouts
2680 /* The caller wants to process if there's something to
2681 * process, but doesn't care otherwise */
2683 r = sd_bus_get_timeout(bus, &until);
2688 nw = now(CLOCK_MONOTONIC);
2689 m = until > nw ? until - nw : 0;
2693 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2696 p[0].fd = bus->input_fd;
2697 if (bus->output_fd == bus->input_fd) {
2701 p[0].events = e & POLLIN;
2702 p[1].fd = bus->output_fd;
2703 p[1].events = e & POLLOUT;
2707 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2711 return r > 0 ? 1 : 0;
2714 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2716 assert_return(bus, -EINVAL);
2717 assert_return(!bus_pid_changed(bus), -ECHILD);
2719 if (bus->state == BUS_CLOSING)
2722 if (!BUS_IS_OPEN(bus->state))
2725 if (bus->rqueue_size > 0)
2728 return bus_poll(bus, false, timeout_usec);
2731 _public_ int sd_bus_flush(sd_bus *bus) {
2734 assert_return(bus, -EINVAL);
2735 assert_return(!bus_pid_changed(bus), -ECHILD);
2737 if (bus->state == BUS_CLOSING)
2740 if (!BUS_IS_OPEN(bus->state))
2743 r = bus_ensure_running(bus);
2747 if (bus->wqueue_size <= 0)
2751 r = dispatch_wqueue(bus);
2753 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2754 bus_enter_closing(bus);
2761 if (bus->wqueue_size <= 0)
2764 r = bus_poll(bus, false, (uint64_t) -1);
2770 _public_ int sd_bus_add_filter(sd_bus *bus,
2771 sd_bus_message_handler_t callback,
2774 struct filter_callback *f;
2776 assert_return(bus, -EINVAL);
2777 assert_return(callback, -EINVAL);
2778 assert_return(!bus_pid_changed(bus), -ECHILD);
2780 f = new0(struct filter_callback, 1);
2783 f->callback = callback;
2784 f->userdata = userdata;
2786 bus->filter_callbacks_modified = true;
2787 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2791 _public_ int sd_bus_remove_filter(sd_bus *bus,
2792 sd_bus_message_handler_t callback,
2795 struct filter_callback *f;
2797 assert_return(bus, -EINVAL);
2798 assert_return(callback, -EINVAL);
2799 assert_return(!bus_pid_changed(bus), -ECHILD);
2801 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2802 if (f->callback == callback && f->userdata == userdata) {
2803 bus->filter_callbacks_modified = true;
2804 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2813 _public_ int sd_bus_add_match(sd_bus *bus,
2815 sd_bus_message_handler_t callback,
2818 struct bus_match_component *components = NULL;
2819 unsigned n_components = 0;
2820 uint64_t cookie = 0;
2823 assert_return(bus, -EINVAL);
2824 assert_return(match, -EINVAL);
2825 assert_return(!bus_pid_changed(bus), -ECHILD);
2827 r = bus_match_parse(match, &components, &n_components);
2831 if (bus->bus_client) {
2832 cookie = ++bus->match_cookie;
2834 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2839 bus->match_callbacks_modified = true;
2840 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2842 if (bus->bus_client)
2843 bus_remove_match_internal(bus, match, cookie);
2847 bus_match_parse_free(components, n_components);
2851 _public_ int sd_bus_remove_match(sd_bus *bus,
2853 sd_bus_message_handler_t callback,
2856 struct bus_match_component *components = NULL;
2857 unsigned n_components = 0;
2859 uint64_t cookie = 0;
2861 assert_return(bus, -EINVAL);
2862 assert_return(match, -EINVAL);
2863 assert_return(!bus_pid_changed(bus), -ECHILD);
2865 r = bus_match_parse(match, &components, &n_components);
2869 bus->match_callbacks_modified = true;
2870 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2872 if (bus->bus_client)
2873 q = bus_remove_match_internal(bus, match, cookie);
2875 bus_match_parse_free(components, n_components);
2877 return r < 0 ? r : q;
2880 bool bus_pid_changed(sd_bus *bus) {
2883 /* We don't support people creating a bus connection and
2884 * keeping it around over a fork(). Let's complain. */
2886 return bus->original_pid != getpid();
2889 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2890 sd_bus *bus = userdata;
2895 r = sd_bus_process(bus, NULL);
2902 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2903 sd_bus *bus = userdata;
2908 r = sd_bus_process(bus, NULL);
2915 static int prepare_callback(sd_event_source *s, void *userdata) {
2916 sd_bus *bus = userdata;
2923 e = sd_bus_get_events(bus);
2927 if (bus->output_fd != bus->input_fd) {
2929 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2933 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2937 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2942 r = sd_bus_get_timeout(bus, &until);
2948 j = sd_event_source_set_time(bus->time_event_source, until);
2953 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2960 static int quit_callback(sd_event_source *event, void *userdata) {
2961 sd_bus *bus = userdata;
2970 static int attach_io_events(sd_bus *bus) {
2975 if (bus->input_fd < 0)
2981 if (!bus->input_io_event_source) {
2982 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2986 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2990 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2992 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2997 if (bus->output_fd != bus->input_fd) {
2998 assert(bus->output_fd >= 0);
3000 if (!bus->output_io_event_source) {
3001 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3005 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3007 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3016 static void detach_io_events(sd_bus *bus) {
3019 if (bus->input_io_event_source) {
3020 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3021 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3024 if (bus->output_io_event_source) {
3025 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3026 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3030 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3033 assert_return(bus, -EINVAL);
3034 assert_return(!bus->event, -EBUSY);
3036 assert(!bus->input_io_event_source);
3037 assert(!bus->output_io_event_source);
3038 assert(!bus->time_event_source);
3041 bus->event = sd_event_ref(event);
3043 r = sd_event_default(&bus->event);
3048 bus->event_priority = priority;
3050 r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus);
3054 r = sd_event_source_set_priority(bus->time_event_source, priority);
3058 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3062 r = attach_io_events(bus);
3069 sd_bus_detach_event(bus);
3073 _public_ int sd_bus_detach_event(sd_bus *bus) {
3074 assert_return(bus, -EINVAL);
3079 detach_io_events(bus);
3081 if (bus->time_event_source) {
3082 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3083 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3086 if (bus->quit_event_source) {
3087 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3088 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3092 bus->event = sd_event_unref(bus->event);
3097 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3098 assert_return(bus, NULL);
3103 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
3104 assert_return(bus, NULL);
3106 return bus->current;
3109 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3114 assert(default_bus);
3117 return !!*default_bus;
3120 *ret = sd_bus_ref(*default_bus);
3128 b->default_bus_ptr = default_bus;
3136 _public_ int sd_bus_default_system(sd_bus **ret) {
3137 static thread_local sd_bus *default_system_bus = NULL;
3139 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3142 _public_ int sd_bus_default_user(sd_bus **ret) {
3143 static thread_local sd_bus *default_user_bus = NULL;
3145 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3148 _public_ int sd_bus_default(sd_bus **ret) {
3152 /* Let's try our best to reuse another cached connection. If
3153 * the starter bus type is set, connect via our normal
3154 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3155 * we can share the connection with the user/system default
3158 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3160 if (streq(e, "system"))
3161 return sd_bus_default_system(ret);
3162 else if (STR_IN_SET(e, "user", "session"))
3163 return sd_bus_default_user(ret);
3166 /* No type is specified, so we have not other option than to
3167 * use the starter address if it is set. */
3169 e = secure_getenv("DBUS_STARTER_ADDRESS");
3171 static thread_local sd_bus *default_starter_bus = NULL;
3173 return bus_default(sd_bus_open, &default_starter_bus, ret);
3176 /* Finally, if nothing is set use the cached connection for
3177 * the right scope */
3179 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3180 return sd_bus_default_user(ret);
3182 return sd_bus_default_system(ret);
3185 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3186 assert_return(b, -EINVAL);
3187 assert_return(tid, -EINVAL);
3188 assert_return(!bus_pid_changed(b), -ECHILD);
3196 return sd_event_get_tid(b->event, tid);
3201 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3202 _cleanup_free_ char *e = NULL;
3205 assert_return(object_path_is_valid(prefix), -EINVAL);
3206 assert_return(external_id, -EINVAL);
3207 assert_return(ret_path, -EINVAL);
3209 e = bus_label_escape(external_id);
3213 ret = strjoin(prefix, "/", e, NULL);
3221 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3225 assert_return(object_path_is_valid(path), -EINVAL);
3226 assert_return(object_path_is_valid(prefix), -EINVAL);
3227 assert_return(external_id, -EINVAL);
3229 e = object_path_startswith(path, prefix);
3231 *external_id = NULL;
3235 ret = bus_label_unescape(e);
3243 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3248 assert_return(bus, -EINVAL);
3249 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3250 assert_return(ret, -EINVAL);
3251 assert_return(!bus_pid_changed(bus), -ECHILD);
3253 if (!bus->is_kernel)
3256 if (!BUS_IS_OPEN(bus->state))
3259 if (!bus->ucred_valid && !isempty(bus->label))
3262 c = bus_creds_new();
3266 if (bus->ucred_valid) {
3267 pid = c->pid = bus->ucred.pid;
3268 c->uid = bus->ucred.uid;
3269 c->gid = bus->ucred.gid;
3271 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3274 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3275 c->label = strdup(bus->label);
3277 sd_bus_creds_unref(c);
3281 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3284 r = bus_creds_add_more(c, mask, pid, 0);
3292 _public_ int sd_bus_try_close(sd_bus *bus) {
3295 assert_return(bus, -EINVAL);
3296 assert_return(!bus_pid_changed(bus), -ECHILD);
3298 if (!bus->is_kernel)
3301 if (!BUS_IS_OPEN(bus->state))
3304 if (bus->rqueue_size > 0)
3307 if (bus->wqueue_size > 0)
3310 r = bus_kernel_try_close(bus);
3318 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3319 assert_return(bus, -EINVAL);
3320 assert_return(name, -EINVAL);
3321 assert_return(!bus_pid_changed(bus), -ECHILD);
3323 *name = bus->connection_name;