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());
1192 return -ECONNREFUSED;
1202 b->bus_client = true;
1205 /* We don't do any per-method access control on the user
1209 r = sd_bus_start(b);
1221 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1222 _cleanup_free_ char *e = NULL;
1227 assert_return(host, -EINVAL);
1228 assert_return(ret, -EINVAL);
1230 e = bus_address_escape(host);
1234 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1238 r = sd_bus_new(&bus);
1245 bus->bus_client = true;
1247 r = sd_bus_start(bus);
1257 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1258 _cleanup_free_ char *e = NULL;
1263 assert_return(machine, -EINVAL);
1264 assert_return(ret, -EINVAL);
1265 assert_return(filename_is_safe(machine), -EINVAL);
1267 e = bus_address_escape(machine);
1272 p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1274 p = strjoin("x-container-unix:machine=", e, NULL);
1279 r = sd_bus_new(&bus);
1286 bus->bus_client = true;
1288 r = sd_bus_start(bus);
1298 _public_ void sd_bus_close(sd_bus *bus) {
1302 if (bus->state == BUS_CLOSED)
1304 if (bus_pid_changed(bus))
1307 bus->state = BUS_CLOSED;
1309 sd_bus_detach_event(bus);
1311 /* Drop all queued messages so that they drop references to
1312 * the bus object and the bus may be freed */
1313 bus_reset_queues(bus);
1315 if (!bus->is_kernel)
1318 /* We'll leave the fd open in case this is a kernel bus, since
1319 * there might still be memblocks around that reference this
1320 * bus, and they might need to invoke the KDBUS_CMD_FREE
1321 * ioctl on the fd when they are freed. */
1324 static void bus_enter_closing(sd_bus *bus) {
1327 if (bus->state != BUS_OPENING &&
1328 bus->state != BUS_AUTHENTICATING &&
1329 bus->state != BUS_HELLO &&
1330 bus->state != BUS_RUNNING)
1333 bus->state = BUS_CLOSING;
1336 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1337 assert_return(bus, NULL);
1339 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1344 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1350 if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
1353 for (i = 0; i < bus->rqueue_size; i++)
1354 if (bus->rqueue[i]->n_ref > 1) {
1360 for (i = 0; i < bus->wqueue_size; i++)
1361 if (bus->wqueue[i]->n_ref > 1) {
1367 /* We are the only holders on the messages, and the
1368 * messages are the only holders on us, so let's drop
1369 * the messages and thus implicitly also kill our own
1370 * last references */
1373 bus_reset_queues(bus);
1376 i = REFCNT_DEC(bus->n_ref);
1384 _public_ int sd_bus_is_open(sd_bus *bus) {
1386 assert_return(bus, -EINVAL);
1387 assert_return(!bus_pid_changed(bus), -ECHILD);
1389 return BUS_IS_OPEN(bus->state);
1392 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1395 assert_return(bus, -EINVAL);
1396 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1397 assert_return(!bus_pid_changed(bus), -ECHILD);
1399 if (type == SD_BUS_TYPE_UNIX_FD) {
1400 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1403 r = bus_ensure_running(bus);
1407 return bus->can_fds;
1410 return bus_type_is_valid(type);
1413 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1416 assert_return(bus, -EINVAL);
1417 assert_return(server_id, -EINVAL);
1418 assert_return(!bus_pid_changed(bus), -ECHILD);
1420 r = bus_ensure_running(bus);
1424 *server_id = bus->server_id;
1428 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1433 /* If we copy the same message to multiple
1434 * destinations, avoid using the same cookie
1436 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1441 timeout = BUS_DEFAULT_TIMEOUT;
1443 return bus_message_seal(m, ++b->cookie, timeout);
1446 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1449 /* Do packet version and endianess already match? */
1450 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1451 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1454 /* No? Then remarshal! */
1455 return bus_message_remarshal(b, m);
1458 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1462 /* The bus specification says the serial number cannot be 0,
1463 * hence let's fill something in for synthetic messages. Since
1464 * synthetic messages might have a fake sender and we don't
1465 * want to interfere with the real sender's serial numbers we
1466 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1467 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1468 * even though kdbus can do 64bit. */
1470 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1473 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1480 r = bus_kernel_write_message(bus, m, hint_sync_call);
1482 r = bus_socket_write_message(bus, m, idx);
1487 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1488 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
1489 bus_message_type_to_string(m->header->type),
1490 strna(sd_bus_message_get_sender(m)),
1491 strna(sd_bus_message_get_destination(m)),
1492 strna(sd_bus_message_get_path(m)),
1493 strna(sd_bus_message_get_interface(m)),
1494 strna(sd_bus_message_get_member(m)),
1495 (unsigned long) BUS_MESSAGE_COOKIE(m),
1496 (unsigned long) m->reply_cookie,
1497 strna(m->error.message));
1502 static int dispatch_wqueue(sd_bus *bus) {
1506 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1508 while (bus->wqueue_size > 0) {
1510 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1514 /* Didn't do anything this time */
1516 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1517 /* Fully written. Let's drop the entry from
1520 * This isn't particularly optimized, but
1521 * well, this is supposed to be our worst-case
1522 * buffer only, and the socket buffer is
1523 * supposed to be our primary buffer, and if
1524 * it got full, then all bets are off
1527 bus->wqueue_size --;
1528 sd_bus_message_unref(bus->wqueue[0]);
1529 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1539 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1543 return bus_kernel_read_message(bus, hint_priority, priority);
1545 return bus_socket_read_message(bus);
1548 int bus_rqueue_make_room(sd_bus *bus) {
1551 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1554 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1560 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1565 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1567 /* Note that the priority logic is only available on kdbus,
1568 * where the rqueue is unused. We check the rqueue here
1569 * anyway, because it's simple... */
1572 if (bus->rqueue_size > 0) {
1573 /* Dispatch a queued message */
1575 *m = bus->rqueue[0];
1576 bus->rqueue_size --;
1577 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1581 /* Try to read a new message */
1582 r = bus_read_message(bus, hint_priority, priority);
1592 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1593 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1596 assert_return(bus, -EINVAL);
1597 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1598 assert_return(m, -EINVAL);
1599 assert_return(!bus_pid_changed(bus), -ECHILD);
1602 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1609 /* If the cookie number isn't kept, then we know that no reply
1611 if (!cookie && !m->sealed)
1612 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1614 r = bus_seal_message(bus, m, 0);
1618 /* Remarshall if we have to. This will possibly unref the
1619 * message and place a replacement in m */
1620 r = bus_remarshal_message(bus, &m);
1624 /* If this is a reply and no reply was requested, then let's
1625 * suppress this, if we can */
1626 if (m->dont_send && !cookie)
1629 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1632 r = bus_write_message(bus, m, hint_sync_call, &idx);
1634 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1635 bus_enter_closing(bus);
1640 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1641 /* Wasn't fully written. So let's remember how
1642 * much was written. Note that the first entry
1643 * of the wqueue array is always allocated so
1644 * that we always can remember how much was
1646 bus->wqueue[0] = sd_bus_message_ref(m);
1647 bus->wqueue_size = 1;
1651 /* Just append it to the queue. */
1653 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1656 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1659 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1663 *cookie = BUS_MESSAGE_COOKIE(m);
1668 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1669 return bus_send_internal(bus, m, cookie, false);
1672 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1675 assert_return(bus, -EINVAL);
1676 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1677 assert_return(m, -EINVAL);
1678 assert_return(!bus_pid_changed(bus), -ECHILD);
1680 if (!streq_ptr(m->destination, destination)) {
1685 r = sd_bus_message_set_destination(m, destination);
1690 return sd_bus_send(bus, m, cookie);
1693 static usec_t calc_elapse(uint64_t usec) {
1694 if (usec == (uint64_t) -1)
1697 return now(CLOCK_MONOTONIC) + usec;
1700 static int timeout_compare(const void *a, const void *b) {
1701 const struct reply_callback *x = a, *y = b;
1703 if (x->timeout != 0 && y->timeout == 0)
1706 if (x->timeout == 0 && y->timeout != 0)
1709 if (x->timeout < y->timeout)
1712 if (x->timeout > y->timeout)
1718 _public_ int sd_bus_call_async(
1721 sd_bus_message_handler_t callback,
1726 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1727 struct reply_callback *c;
1730 assert_return(bus, -EINVAL);
1731 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1732 assert_return(m, -EINVAL);
1733 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1734 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1735 assert_return(callback, -EINVAL);
1736 assert_return(!bus_pid_changed(bus), -ECHILD);
1738 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1742 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1746 r = bus_seal_message(bus, m, usec);
1750 r = bus_remarshal_message(bus, &m);
1754 c = new0(struct reply_callback, 1);
1758 c->callback = callback;
1759 c->userdata = userdata;
1760 c->cookie = BUS_MESSAGE_COOKIE(m);
1761 c->timeout = calc_elapse(m->timeout);
1763 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1769 if (c->timeout != 0) {
1770 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1773 sd_bus_call_async_cancel(bus, c->cookie);
1778 r = sd_bus_send(bus, m, cookie);
1780 sd_bus_call_async_cancel(bus, c->cookie);
1787 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1788 struct reply_callback *c;
1790 assert_return(bus, -EINVAL);
1791 assert_return(cookie != 0, -EINVAL);
1792 assert_return(!bus_pid_changed(bus), -ECHILD);
1794 c = hashmap_remove(bus->reply_callbacks, &cookie);
1798 if (c->timeout != 0)
1799 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1805 int bus_ensure_running(sd_bus *bus) {
1810 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1812 if (bus->state == BUS_RUNNING)
1816 r = sd_bus_process(bus, NULL);
1819 if (bus->state == BUS_RUNNING)
1824 r = sd_bus_wait(bus, (uint64_t) -1);
1830 _public_ int sd_bus_call(
1834 sd_bus_error *error,
1835 sd_bus_message **reply) {
1837 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1843 assert_return(bus, -EINVAL);
1844 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1845 assert_return(m, -EINVAL);
1846 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1847 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1848 assert_return(!bus_error_is_dirty(error), -EINVAL);
1849 assert_return(!bus_pid_changed(bus), -ECHILD);
1851 r = bus_ensure_running(bus);
1855 i = bus->rqueue_size;
1857 r = bus_seal_message(bus, m, usec);
1861 r = bus_remarshal_message(bus, &m);
1865 r = bus_send_internal(bus, m, &cookie, true);
1869 timeout = calc_elapse(m->timeout);
1874 while (i < bus->rqueue_size) {
1875 sd_bus_message *incoming = NULL;
1877 incoming = bus->rqueue[i];
1879 if (incoming->reply_cookie == cookie) {
1880 /* Found a match! */
1882 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1885 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1890 sd_bus_message_unref(incoming);
1893 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1894 r = sd_bus_error_copy(error, &incoming->error);
1898 sd_bus_message_unref(incoming);
1901 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1904 streq(bus->unique_name, incoming->sender)) {
1906 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1909 /* Our own message? Somebody is trying
1910 * to send its own client a message,
1911 * let's not dead-lock, let's fail
1914 sd_bus_message_unref(incoming);
1918 /* Try to read more, right-away */
1922 r = bus_read_message(bus, false, 0);
1924 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1925 bus_enter_closing(bus);
1937 n = now(CLOCK_MONOTONIC);
1943 left = (uint64_t) -1;
1945 r = bus_poll(bus, true, left);
1951 r = dispatch_wqueue(bus);
1953 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1954 bus_enter_closing(bus);
1963 _public_ int sd_bus_get_fd(sd_bus *bus) {
1965 assert_return(bus, -EINVAL);
1966 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1967 assert_return(!bus_pid_changed(bus), -ECHILD);
1969 return bus->input_fd;
1972 _public_ int sd_bus_get_events(sd_bus *bus) {
1975 assert_return(bus, -EINVAL);
1976 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1977 assert_return(!bus_pid_changed(bus), -ECHILD);
1979 if (bus->state == BUS_OPENING)
1981 else if (bus->state == BUS_AUTHENTICATING) {
1983 if (bus_socket_auth_needs_write(bus))
1988 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1989 if (bus->rqueue_size <= 0)
1991 if (bus->wqueue_size > 0)
1998 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1999 struct reply_callback *c;
2001 assert_return(bus, -EINVAL);
2002 assert_return(timeout_usec, -EINVAL);
2003 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
2004 assert_return(!bus_pid_changed(bus), -ECHILD);
2006 if (bus->track_queue) {
2011 if (bus->state == BUS_CLOSING) {
2016 if (bus->state == BUS_AUTHENTICATING) {
2017 *timeout_usec = bus->auth_timeout;
2021 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2022 *timeout_usec = (uint64_t) -1;
2026 if (bus->rqueue_size > 0) {
2031 c = prioq_peek(bus->reply_callbacks_prioq);
2033 *timeout_usec = (uint64_t) -1;
2037 *timeout_usec = c->timeout;
2041 static int process_timeout(sd_bus *bus) {
2042 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2043 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2044 struct reply_callback *c;
2050 c = prioq_peek(bus->reply_callbacks_prioq);
2054 n = now(CLOCK_MONOTONIC);
2058 r = bus_message_new_synthetic_error(
2061 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2066 m->sender = "org.freedesktop.DBus";
2068 r = bus_seal_synthetic_message(bus, m);
2072 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2073 hashmap_remove(bus->reply_callbacks, &c->cookie);
2076 bus->iteration_counter ++;
2078 r = c->callback(bus, m, c->userdata, &error_buffer);
2079 r = bus_maybe_reply_error(m, r, &error_buffer);
2082 bus->current = NULL;
2087 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2091 if (bus->state != BUS_HELLO)
2094 /* Let's make sure the first message on the bus is the HELLO
2095 * reply. But note that we don't actually parse the message
2096 * here (we leave that to the usual handling), we just verify
2097 * we don't let any earlier msg through. */
2099 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2100 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2103 if (m->reply_cookie != bus->hello_cookie)
2109 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2110 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2111 struct reply_callback *c;
2117 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2118 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2121 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2125 if (c->timeout != 0)
2126 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2128 r = sd_bus_message_rewind(m, true);
2132 r = c->callback(bus, m, c->userdata, &error_buffer);
2133 r = bus_maybe_reply_error(m, r, &error_buffer);
2139 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2140 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2141 struct filter_callback *l;
2148 bus->filter_callbacks_modified = false;
2150 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2152 if (bus->filter_callbacks_modified)
2155 /* Don't run this more than once per iteration */
2156 if (l->last_iteration == bus->iteration_counter)
2159 l->last_iteration = bus->iteration_counter;
2161 r = sd_bus_message_rewind(m, true);
2165 r = l->callback(bus, m, l->userdata, &error_buffer);
2166 r = bus_maybe_reply_error(m, r, &error_buffer);
2172 } while (bus->filter_callbacks_modified);
2177 static int process_match(sd_bus *bus, sd_bus_message *m) {
2184 bus->match_callbacks_modified = false;
2186 r = bus_match_run(bus, &bus->match_callbacks, m);
2190 } while (bus->match_callbacks_modified);
2195 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2196 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2202 if (bus->manual_peer_interface)
2205 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2208 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2211 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2214 if (streq_ptr(m->member, "Ping"))
2215 r = sd_bus_message_new_method_return(m, &reply);
2216 else if (streq_ptr(m->member, "GetMachineId")) {
2220 r = sd_id128_get_machine(&id);
2224 r = sd_bus_message_new_method_return(m, &reply);
2228 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2230 r = sd_bus_message_new_method_errorf(
2232 SD_BUS_ERROR_UNKNOWN_METHOD,
2233 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2239 r = sd_bus_send(bus, reply, NULL);
2246 static int process_message(sd_bus *bus, sd_bus_message *m) {
2253 bus->iteration_counter++;
2255 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2256 bus_message_type_to_string(m->header->type),
2257 strna(sd_bus_message_get_sender(m)),
2258 strna(sd_bus_message_get_destination(m)),
2259 strna(sd_bus_message_get_path(m)),
2260 strna(sd_bus_message_get_interface(m)),
2261 strna(sd_bus_message_get_member(m)),
2262 (unsigned long) BUS_MESSAGE_COOKIE(m),
2263 (unsigned long) m->reply_cookie,
2264 strna(m->error.message));
2266 r = process_hello(bus, m);
2270 r = process_reply(bus, m);
2274 r = process_filter(bus, m);
2278 r = process_match(bus, m);
2282 r = process_builtin(bus, m);
2286 r = bus_process_object(bus, m);
2289 bus->current = NULL;
2293 static int dispatch_track(sd_bus *bus) {
2296 if (!bus->track_queue)
2299 bus_track_dispatch(bus->track_queue);
2303 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2304 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2308 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2310 r = process_timeout(bus);
2314 r = dispatch_wqueue(bus);
2318 r = dispatch_track(bus);
2322 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2328 r = process_message(bus, m);
2333 r = sd_bus_message_rewind(m, true);
2342 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2344 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2345 strna(sd_bus_message_get_sender(m)),
2346 strna(sd_bus_message_get_path(m)),
2347 strna(sd_bus_message_get_interface(m)),
2348 strna(sd_bus_message_get_member(m)));
2350 r = sd_bus_reply_method_errorf(
2352 SD_BUS_ERROR_UNKNOWN_OBJECT,
2353 "Unknown object '%s'.", m->path);
2367 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2368 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2369 struct reply_callback *c;
2373 assert(bus->state == BUS_CLOSING);
2375 c = hashmap_first(bus->reply_callbacks);
2377 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2379 /* First, fail all outstanding method calls */
2380 r = bus_message_new_synthetic_error(
2383 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2388 r = bus_seal_synthetic_message(bus, m);
2392 if (c->timeout != 0)
2393 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2395 hashmap_remove(bus->reply_callbacks, &c->cookie);
2398 bus->iteration_counter++;
2400 r = c->callback(bus, m, c->userdata, &error_buffer);
2401 r = bus_maybe_reply_error(m, r, &error_buffer);
2407 /* Then, synthesize a Disconnected message */
2408 r = sd_bus_message_new_signal(
2411 "/org/freedesktop/DBus/Local",
2412 "org.freedesktop.DBus.Local",
2417 m->sender = "org.freedesktop.DBus.Local";
2419 r = bus_seal_synthetic_message(bus, m);
2426 bus->iteration_counter++;
2428 r = process_filter(bus, m);
2432 r = process_match(bus, m);
2444 bus->current = NULL;
2448 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2449 BUS_DONT_DESTROY(bus);
2452 /* Returns 0 when we didn't do anything. This should cause the
2453 * caller to invoke sd_bus_wait() before returning the next
2454 * time. Returns > 0 when we did something, which possibly
2455 * means *ret is filled in with an unprocessed message. */
2457 assert_return(bus, -EINVAL);
2458 assert_return(!bus_pid_changed(bus), -ECHILD);
2460 /* We don't allow recursively invoking sd_bus_process(). */
2461 assert_return(!bus->current, -EBUSY);
2463 switch (bus->state) {
2472 r = bus_socket_process_opening(bus);
2473 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2474 bus_enter_closing(bus);
2482 case BUS_AUTHENTICATING:
2483 r = bus_socket_process_authenticating(bus);
2484 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2485 bus_enter_closing(bus);
2497 r = process_running(bus, hint_priority, priority, ret);
2498 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2499 bus_enter_closing(bus);
2509 return process_closing(bus, ret);
2512 assert_not_reached("Unknown state");
2515 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2516 return bus_process_internal(bus, false, 0, ret);
2519 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2520 return bus_process_internal(bus, true, priority, ret);
2523 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2524 struct pollfd p[2] = {};
2527 usec_t m = (usec_t) -1;
2531 if (bus->state == BUS_CLOSING)
2534 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2536 e = sd_bus_get_events(bus);
2541 /* The caller really needs some more data, he doesn't
2542 * care about what's already read, or any timeouts
2547 /* The caller wants to process if there's something to
2548 * process, but doesn't care otherwise */
2550 r = sd_bus_get_timeout(bus, &until);
2555 nw = now(CLOCK_MONOTONIC);
2556 m = until > nw ? until - nw : 0;
2560 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2563 p[0].fd = bus->input_fd;
2564 if (bus->output_fd == bus->input_fd) {
2568 p[0].events = e & POLLIN;
2569 p[1].fd = bus->output_fd;
2570 p[1].events = e & POLLOUT;
2574 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2578 return r > 0 ? 1 : 0;
2581 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2583 assert_return(bus, -EINVAL);
2584 assert_return(!bus_pid_changed(bus), -ECHILD);
2586 if (bus->state == BUS_CLOSING)
2589 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2591 if (bus->rqueue_size > 0)
2594 return bus_poll(bus, false, timeout_usec);
2597 _public_ int sd_bus_flush(sd_bus *bus) {
2600 assert_return(bus, -EINVAL);
2601 assert_return(!bus_pid_changed(bus), -ECHILD);
2603 if (bus->state == BUS_CLOSING)
2606 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2608 r = bus_ensure_running(bus);
2612 if (bus->wqueue_size <= 0)
2616 r = dispatch_wqueue(bus);
2618 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2619 bus_enter_closing(bus);
2626 if (bus->wqueue_size <= 0)
2629 r = bus_poll(bus, false, (uint64_t) -1);
2635 _public_ int sd_bus_add_filter(sd_bus *bus,
2636 sd_bus_message_handler_t callback,
2639 struct filter_callback *f;
2641 assert_return(bus, -EINVAL);
2642 assert_return(callback, -EINVAL);
2643 assert_return(!bus_pid_changed(bus), -ECHILD);
2645 f = new0(struct filter_callback, 1);
2648 f->callback = callback;
2649 f->userdata = userdata;
2651 bus->filter_callbacks_modified = true;
2652 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2656 _public_ int sd_bus_remove_filter(sd_bus *bus,
2657 sd_bus_message_handler_t callback,
2660 struct filter_callback *f;
2662 assert_return(bus, -EINVAL);
2663 assert_return(callback, -EINVAL);
2664 assert_return(!bus_pid_changed(bus), -ECHILD);
2666 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2667 if (f->callback == callback && f->userdata == userdata) {
2668 bus->filter_callbacks_modified = true;
2669 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2678 _public_ int sd_bus_add_match(sd_bus *bus,
2680 sd_bus_message_handler_t callback,
2683 struct bus_match_component *components = NULL;
2684 unsigned n_components = 0;
2685 uint64_t cookie = 0;
2688 assert_return(bus, -EINVAL);
2689 assert_return(match, -EINVAL);
2690 assert_return(!bus_pid_changed(bus), -ECHILD);
2692 r = bus_match_parse(match, &components, &n_components);
2696 if (bus->bus_client) {
2697 cookie = ++bus->match_cookie;
2699 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2704 bus->match_callbacks_modified = true;
2705 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2707 if (bus->bus_client)
2708 bus_remove_match_internal(bus, match, cookie);
2712 bus_match_parse_free(components, n_components);
2716 _public_ int sd_bus_remove_match(sd_bus *bus,
2718 sd_bus_message_handler_t callback,
2721 struct bus_match_component *components = NULL;
2722 unsigned n_components = 0;
2724 uint64_t cookie = 0;
2726 assert_return(bus, -EINVAL);
2727 assert_return(match, -EINVAL);
2728 assert_return(!bus_pid_changed(bus), -ECHILD);
2730 r = bus_match_parse(match, &components, &n_components);
2734 bus->match_callbacks_modified = true;
2735 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2737 if (bus->bus_client)
2738 q = bus_remove_match_internal(bus, match, cookie);
2740 bus_match_parse_free(components, n_components);
2742 return r < 0 ? r : q;
2745 bool bus_pid_changed(sd_bus *bus) {
2748 /* We don't support people creating a bus connection and
2749 * keeping it around over a fork(). Let's complain. */
2751 return bus->original_pid != getpid();
2754 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2755 sd_bus *bus = userdata;
2760 r = sd_bus_process(bus, NULL);
2767 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2768 sd_bus *bus = userdata;
2773 r = sd_bus_process(bus, NULL);
2780 static int prepare_callback(sd_event_source *s, void *userdata) {
2781 sd_bus *bus = userdata;
2788 e = sd_bus_get_events(bus);
2792 if (bus->output_fd != bus->input_fd) {
2794 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2798 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2802 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2807 r = sd_bus_get_timeout(bus, &until);
2813 j = sd_event_source_set_time(bus->time_event_source, until);
2818 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2825 static int quit_callback(sd_event_source *event, void *userdata) {
2826 sd_bus *bus = userdata;
2835 static int attach_io_events(sd_bus *bus) {
2840 if (bus->input_fd < 0)
2846 if (!bus->input_io_event_source) {
2847 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2851 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2855 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2857 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2862 if (bus->output_fd != bus->input_fd) {
2863 assert(bus->output_fd >= 0);
2865 if (!bus->output_io_event_source) {
2866 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
2870 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2872 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2881 static void detach_io_events(sd_bus *bus) {
2884 if (bus->input_io_event_source) {
2885 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2886 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2889 if (bus->output_io_event_source) {
2890 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2891 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2895 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2898 assert_return(bus, -EINVAL);
2899 assert_return(!bus->event, -EBUSY);
2901 assert(!bus->input_io_event_source);
2902 assert(!bus->output_io_event_source);
2903 assert(!bus->time_event_source);
2906 bus->event = sd_event_ref(event);
2908 r = sd_event_default(&bus->event);
2913 bus->event_priority = priority;
2915 r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus);
2919 r = sd_event_source_set_priority(bus->time_event_source, priority);
2923 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
2927 r = attach_io_events(bus);
2934 sd_bus_detach_event(bus);
2938 _public_ int sd_bus_detach_event(sd_bus *bus) {
2939 assert_return(bus, -EINVAL);
2944 detach_io_events(bus);
2946 if (bus->time_event_source) {
2947 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2948 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2951 if (bus->quit_event_source) {
2952 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2953 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2957 bus->event = sd_event_unref(bus->event);
2962 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2963 assert_return(bus, NULL);
2968 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2969 assert_return(bus, NULL);
2971 return bus->current;
2974 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2979 assert(default_bus);
2982 return !!*default_bus;
2985 *ret = sd_bus_ref(*default_bus);
2993 b->default_bus_ptr = default_bus;
3001 _public_ int sd_bus_default_system(sd_bus **ret) {
3002 static thread_local sd_bus *default_system_bus = NULL;
3004 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3007 _public_ int sd_bus_default_user(sd_bus **ret) {
3008 static thread_local sd_bus *default_user_bus = NULL;
3010 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3013 _public_ int sd_bus_default(sd_bus **ret) {
3017 /* Let's try our best to reuse another cached connection. If
3018 * the starter bus type is set, connect via our normal
3019 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3020 * we can share the connection with the user/system default
3023 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3025 if (streq(e, "system"))
3026 return sd_bus_default_system(ret);
3027 else if (streq(e, "user") || streq(e, "session"))
3028 return sd_bus_default_user(ret);
3031 /* No type is specified, so we have not other option than to
3032 * use the starter address if it is set. */
3034 e = secure_getenv("DBUS_STARTER_ADDRESS");
3036 static thread_local sd_bus *default_starter_bus = NULL;
3038 return bus_default(sd_bus_open, &default_starter_bus, ret);
3041 /* Finally, if nothing is set use the cached connection for
3042 * the right scope */
3044 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3045 return sd_bus_default_user(ret);
3047 return sd_bus_default_system(ret);
3050 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3051 assert_return(b, -EINVAL);
3052 assert_return(tid, -EINVAL);
3053 assert_return(!bus_pid_changed(b), -ECHILD);
3061 return sd_event_get_tid(b->event, tid);
3066 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3067 _cleanup_free_ char *e = NULL;
3070 assert_return(object_path_is_valid(prefix), -EINVAL);
3071 assert_return(external_id, -EINVAL);
3072 assert_return(ret_path, -EINVAL);
3074 e = bus_label_escape(external_id);
3078 ret = strjoin(prefix, "/", e, NULL);
3086 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3090 assert_return(object_path_is_valid(path), -EINVAL);
3091 assert_return(object_path_is_valid(prefix), -EINVAL);
3092 assert_return(external_id, -EINVAL);
3094 e = object_path_startswith(path, prefix);
3096 *external_id = NULL;
3100 ret = bus_label_unescape(e);
3108 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3113 assert_return(bus, -EINVAL);
3114 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3115 assert_return(ret, -EINVAL);
3116 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3117 assert_return(!bus_pid_changed(bus), -ECHILD);
3118 assert_return(!bus->is_kernel, -ENOTSUP);
3120 if (!bus->ucred_valid && !isempty(bus->label))
3123 c = bus_creds_new();
3127 if (bus->ucred_valid) {
3128 pid = c->pid = bus->ucred.pid;
3129 c->uid = bus->ucred.uid;
3130 c->gid = bus->ucred.gid;
3132 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3135 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3136 c->label = strdup(bus->label);
3138 sd_bus_creds_unref(c);
3142 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3145 r = bus_creds_add_more(c, mask, pid, 0);
3153 _public_ int sd_bus_try_close(sd_bus *bus) {
3156 assert_return(bus, -EINVAL);
3157 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3158 assert_return(!bus_pid_changed(bus), -ECHILD);
3159 assert_return(bus->is_kernel, -ENOTSUP);
3161 if (bus->rqueue_size > 0)
3164 if (bus->wqueue_size > 0)
3167 r = bus_kernel_try_close(bus);
3175 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3176 assert_return(bus, -EINVAL);
3177 assert_return(name, -EINVAL);
3178 assert_return(!bus_pid_changed(bus), -ECHILD);
3180 *name = bus->connection_name;