]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd/sd-bus/sd-bus.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
macro: introduce TAKE_PTR() macro
[thirdparty/systemd.git] / src / libsystemd / sd-bus / sd-bus.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2013 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19 ***/
20
21 #include <endian.h>
22 #include <netdb.h>
23 #include <poll.h>
24 #include <pthread.h>
25 #include <signal.h>
26 #include <stdlib.h>
27 #include <sys/mman.h>
28 #include <sys/wait.h>
29 #include <unistd.h>
30
31 #include "sd-bus.h"
32
33 #include "alloc-util.h"
34 #include "bus-container.h"
35 #include "bus-control.h"
36 #include "bus-internal.h"
37 #include "bus-kernel.h"
38 #include "bus-label.h"
39 #include "bus-message.h"
40 #include "bus-objects.h"
41 #include "bus-protocol.h"
42 #include "bus-slot.h"
43 #include "bus-socket.h"
44 #include "bus-track.h"
45 #include "bus-type.h"
46 #include "bus-util.h"
47 #include "cgroup-util.h"
48 #include "def.h"
49 #include "fd-util.h"
50 #include "hexdecoct.h"
51 #include "hostname-util.h"
52 #include "macro.h"
53 #include "missing.h"
54 #include "parse-util.h"
55 #include "process-util.h"
56 #include "string-util.h"
57 #include "strv.h"
58 #include "util.h"
59
60 #define log_debug_bus_message(m) \
61 do { \
62 sd_bus_message *_mm = (m); \
63 log_debug("Got message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " signature=%s error-name=%s error-message=%s", \
64 bus_message_type_to_string(_mm->header->type), \
65 strna(sd_bus_message_get_sender(_mm)), \
66 strna(sd_bus_message_get_destination(_mm)), \
67 strna(sd_bus_message_get_path(_mm)), \
68 strna(sd_bus_message_get_interface(_mm)), \
69 strna(sd_bus_message_get_member(_mm)), \
70 BUS_MESSAGE_COOKIE(_mm), \
71 _mm->reply_cookie, \
72 strna(_mm->root_container.signature), \
73 strna(_mm->error.name), \
74 strna(_mm->error.message)); \
75 } while (false)
76
77 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
78 static void bus_detach_io_events(sd_bus *b);
79 static void bus_detach_inotify_event(sd_bus *b);
80
81 static thread_local sd_bus *default_system_bus = NULL;
82 static thread_local sd_bus *default_user_bus = NULL;
83 static thread_local sd_bus *default_starter_bus = NULL;
84
85 static sd_bus **bus_choose_default(int (**bus_open)(sd_bus **)) {
86 const char *e;
87
88 /* Let's try our best to reuse another cached connection. If
89 * the starter bus type is set, connect via our normal
90 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
91 * we can share the connection with the user/system default
92 * bus. */
93
94 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
95 if (e) {
96 if (streq(e, "system")) {
97 if (bus_open)
98 *bus_open = sd_bus_open_system;
99 return &default_system_bus;
100 } else if (STR_IN_SET(e, "user", "session")) {
101 if (bus_open)
102 *bus_open = sd_bus_open_user;
103 return &default_user_bus;
104 }
105 }
106
107 /* No type is specified, so we have not other option than to
108 * use the starter address if it is set. */
109 e = secure_getenv("DBUS_STARTER_ADDRESS");
110 if (e) {
111 if (bus_open)
112 *bus_open = sd_bus_open;
113 return &default_starter_bus;
114 }
115
116 /* Finally, if nothing is set use the cached connection for
117 * the right scope */
118
119 if (cg_pid_get_owner_uid(0, NULL) >= 0) {
120 if (bus_open)
121 *bus_open = sd_bus_open_user;
122 return &default_user_bus;
123 } else {
124 if (bus_open)
125 *bus_open = sd_bus_open_system;
126 return &default_system_bus;
127 }
128 }
129
130 sd_bus *bus_resolve(sd_bus *bus) {
131 switch ((uintptr_t) bus) {
132 case (uintptr_t) SD_BUS_DEFAULT:
133 return *(bus_choose_default(NULL));
134 case (uintptr_t) SD_BUS_DEFAULT_USER:
135 return default_user_bus;
136 case (uintptr_t) SD_BUS_DEFAULT_SYSTEM:
137 return default_system_bus;
138 default:
139 return bus;
140 }
141 }
142
143 void bus_close_io_fds(sd_bus *b) {
144 assert(b);
145
146 bus_detach_io_events(b);
147
148 if (b->input_fd != b->output_fd)
149 safe_close(b->output_fd);
150 b->output_fd = b->input_fd = safe_close(b->input_fd);
151 }
152
153 void bus_close_inotify_fd(sd_bus *b) {
154 assert(b);
155
156 bus_detach_inotify_event(b);
157
158 b->inotify_fd = safe_close(b->inotify_fd);
159 b->inotify_watches = mfree(b->inotify_watches);
160 b->n_inotify_watches = 0;
161 }
162
163 static void bus_reset_queues(sd_bus *b) {
164 assert(b);
165
166 while (b->rqueue_size > 0)
167 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
168
169 b->rqueue = mfree(b->rqueue);
170 b->rqueue_allocated = 0;
171
172 while (b->wqueue_size > 0)
173 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
174
175 b->wqueue = mfree(b->wqueue);
176 b->wqueue_allocated = 0;
177 }
178
179 static void bus_free(sd_bus *b) {
180 sd_bus_slot *s;
181
182 assert(b);
183 assert(!b->track_queue);
184 assert(!b->tracks);
185
186 b->state = BUS_CLOSED;
187
188 sd_bus_detach_event(b);
189
190 while ((s = b->slots)) {
191 /* At this point only floating slots can still be
192 * around, because the non-floating ones keep a
193 * reference to the bus, and we thus couldn't be
194 * destructing right now... We forcibly disconnect the
195 * slots here, so that they still can be referenced by
196 * apps, but are dead. */
197
198 assert(s->floating);
199 bus_slot_disconnect(s);
200 sd_bus_slot_unref(s);
201 }
202
203 if (b->default_bus_ptr)
204 *b->default_bus_ptr = NULL;
205
206 bus_close_io_fds(b);
207 bus_close_inotify_fd(b);
208
209 free(b->label);
210 free(b->groups);
211 free(b->rbuffer);
212 free(b->unique_name);
213 free(b->auth_buffer);
214 free(b->address);
215 free(b->machine);
216 free(b->cgroup_root);
217 free(b->description);
218 free(b->patch_sender);
219
220 free(b->exec_path);
221 strv_free(b->exec_argv);
222
223 close_many(b->fds, b->n_fds);
224 free(b->fds);
225
226 bus_reset_queues(b);
227
228 ordered_hashmap_free_free(b->reply_callbacks);
229 prioq_free(b->reply_callbacks_prioq);
230
231 assert(b->match_callbacks.type == BUS_MATCH_ROOT);
232 bus_match_free(&b->match_callbacks);
233
234 hashmap_free_free(b->vtable_methods);
235 hashmap_free_free(b->vtable_properties);
236
237 assert(hashmap_isempty(b->nodes));
238 hashmap_free(b->nodes);
239
240 bus_flush_memfd(b);
241
242 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
243
244 free(b);
245 }
246
247 _public_ int sd_bus_new(sd_bus **ret) {
248 sd_bus *r;
249
250 assert_return(ret, -EINVAL);
251
252 r = new0(sd_bus, 1);
253 if (!r)
254 return -ENOMEM;
255
256 r->n_ref = REFCNT_INIT;
257 r->input_fd = r->output_fd = -1;
258 r->inotify_fd = -1;
259 r->message_version = 1;
260 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
261 r->accept_fd = true;
262 r->original_pid = getpid_cached();
263 r->n_groups = (size_t) -1;
264
265 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
266
267 /* We guarantee that wqueue always has space for at least one
268 * entry */
269 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
270 free(r);
271 return -ENOMEM;
272 }
273
274 *ret = r;
275 return 0;
276 }
277
278 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
279 char *a;
280
281 assert_return(bus, -EINVAL);
282 assert_return(bus = bus_resolve(bus), -ENOPKG);
283 assert_return(bus->state == BUS_UNSET, -EPERM);
284 assert_return(address, -EINVAL);
285 assert_return(!bus_pid_changed(bus), -ECHILD);
286
287 a = strdup(address);
288 if (!a)
289 return -ENOMEM;
290
291 free_and_replace(bus->address, a);
292
293 return 0;
294 }
295
296 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
297 assert_return(bus, -EINVAL);
298 assert_return(bus = bus_resolve(bus), -ENOPKG);
299 assert_return(bus->state == BUS_UNSET, -EPERM);
300 assert_return(input_fd >= 0, -EBADF);
301 assert_return(output_fd >= 0, -EBADF);
302 assert_return(!bus_pid_changed(bus), -ECHILD);
303
304 bus->input_fd = input_fd;
305 bus->output_fd = output_fd;
306 return 0;
307 }
308
309 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
310 char *p, **a;
311
312 assert_return(bus, -EINVAL);
313 assert_return(bus = bus_resolve(bus), -ENOPKG);
314 assert_return(bus->state == BUS_UNSET, -EPERM);
315 assert_return(path, -EINVAL);
316 assert_return(!strv_isempty(argv), -EINVAL);
317 assert_return(!bus_pid_changed(bus), -ECHILD);
318
319 p = strdup(path);
320 if (!p)
321 return -ENOMEM;
322
323 a = strv_copy(argv);
324 if (!a) {
325 free(p);
326 return -ENOMEM;
327 }
328
329 free_and_replace(bus->exec_path, p);
330
331 strv_free(bus->exec_argv);
332 bus->exec_argv = a;
333
334 return 0;
335 }
336
337 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
338 assert_return(bus, -EINVAL);
339 assert_return(bus = bus_resolve(bus), -ENOPKG);
340 assert_return(bus->state == BUS_UNSET, -EPERM);
341 assert_return(!bus->patch_sender, -EPERM);
342 assert_return(!bus_pid_changed(bus), -ECHILD);
343
344 bus->bus_client = !!b;
345 return 0;
346 }
347
348 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
349 assert_return(bus, -EINVAL);
350 assert_return(bus = bus_resolve(bus), -ENOPKG);
351 assert_return(bus->state == BUS_UNSET, -EPERM);
352 assert_return(!bus_pid_changed(bus), -ECHILD);
353
354 bus->is_monitor = !!b;
355 return 0;
356 }
357
358 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
359 assert_return(bus, -EINVAL);
360 assert_return(bus = bus_resolve(bus), -ENOPKG);
361 assert_return(bus->state == BUS_UNSET, -EPERM);
362 assert_return(!bus_pid_changed(bus), -ECHILD);
363
364 bus->accept_fd = !!b;
365 return 0;
366 }
367
368 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
369 assert_return(bus, -EINVAL);
370 assert_return(bus = bus_resolve(bus), -ENOPKG);
371 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
372 assert_return(!bus_pid_changed(bus), -ECHILD);
373
374 /* This is not actually supported by any of our transports these days, but we do honour it for synthetic
375 * replies, and maybe one day classic D-Bus learns this too */
376 bus->attach_timestamp = !!b;
377
378 return 0;
379 }
380
381 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
382 assert_return(bus, -EINVAL);
383 assert_return(bus = bus_resolve(bus), -ENOPKG);
384 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
385 assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
386 assert_return(!bus_pid_changed(bus), -ECHILD);
387
388 SET_FLAG(bus->creds_mask, mask, b);
389
390 /* The well knowns we need unconditionally, so that matches can work */
391 bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
392
393 return 0;
394 }
395
396 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
397 assert_return(bus, -EINVAL);
398 assert_return(bus = bus_resolve(bus), -ENOPKG);
399 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
400 assert_return(bus->state == BUS_UNSET, -EPERM);
401 assert_return(!bus_pid_changed(bus), -ECHILD);
402
403 bus->is_server = !!b;
404 bus->server_id = server_id;
405 return 0;
406 }
407
408 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
409 assert_return(bus, -EINVAL);
410 assert_return(bus = bus_resolve(bus), -ENOPKG);
411 assert_return(bus->state == BUS_UNSET, -EPERM);
412 assert_return(!bus_pid_changed(bus), -ECHILD);
413
414 bus->anonymous_auth = !!b;
415 return 0;
416 }
417
418 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
419 assert_return(bus, -EINVAL);
420 assert_return(bus = bus_resolve(bus), -ENOPKG);
421 assert_return(bus->state == BUS_UNSET, -EPERM);
422 assert_return(!bus_pid_changed(bus), -ECHILD);
423
424 bus->trusted = !!b;
425 return 0;
426 }
427
428 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
429 assert_return(bus, -EINVAL);
430 assert_return(bus = bus_resolve(bus), -ENOPKG);
431 assert_return(bus->state == BUS_UNSET, -EPERM);
432 assert_return(!bus_pid_changed(bus), -ECHILD);
433
434 return free_and_strdup(&bus->description, description);
435 }
436
437 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
438 assert_return(bus, -EINVAL);
439 assert_return(bus = bus_resolve(bus), -ENOPKG);
440 assert_return(!bus_pid_changed(bus), -ECHILD);
441
442 bus->allow_interactive_authorization = !!b;
443 return 0;
444 }
445
446 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
447 assert_return(bus, -EINVAL);
448 assert_return(bus = bus_resolve(bus), -ENOPKG);
449 assert_return(!bus_pid_changed(bus), -ECHILD);
450
451 return bus->allow_interactive_authorization;
452 }
453
454 _public_ int sd_bus_set_watch_bind(sd_bus *bus, int b) {
455 assert_return(bus, -EINVAL);
456 assert_return(bus = bus_resolve(bus), -ENOPKG);
457 assert_return(bus->state == BUS_UNSET, -EPERM);
458 assert_return(!bus_pid_changed(bus), -ECHILD);
459
460 bus->watch_bind = !!b;
461 return 0;
462 }
463
464 _public_ int sd_bus_get_watch_bind(sd_bus *bus) {
465 assert_return(bus, -EINVAL);
466 assert_return(bus = bus_resolve(bus), -ENOPKG);
467 assert_return(!bus_pid_changed(bus), -ECHILD);
468
469 return bus->watch_bind;
470 }
471
472 _public_ int sd_bus_set_connected_signal(sd_bus *bus, int b) {
473 assert_return(bus, -EINVAL);
474 assert_return(bus = bus_resolve(bus), -ENOPKG);
475 assert_return(bus->state == BUS_UNSET, -EPERM);
476 assert_return(!bus_pid_changed(bus), -ECHILD);
477
478 bus->connected_signal = !!b;
479 return 0;
480 }
481
482 _public_ int sd_bus_get_connected_signal(sd_bus *bus) {
483 assert_return(bus, -EINVAL);
484 assert_return(bus = bus_resolve(bus), -ENOPKG);
485 assert_return(!bus_pid_changed(bus), -ECHILD);
486
487 return bus->connected_signal;
488 }
489
490 static int synthesize_connected_signal(sd_bus *bus) {
491 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
492 int r;
493
494 assert(bus);
495
496 /* If enabled, synthesizes a local "Connected" signal mirroring the local "Disconnected" signal. This is called
497 * whenever we fully established a connection, i.e. after the authorization phase, and after receiving the
498 * Hello() reply. Or in other words, whenver we enter BUS_RUNNING state.
499 *
500 * This is useful so that clients can start doing stuff whenver the connection is fully established in a way
501 * that works independently from whether we connected to a full bus or just a direct connection. */
502
503 if (!bus->connected_signal)
504 return 0;
505
506 r = sd_bus_message_new_signal(
507 bus,
508 &m,
509 "/org/freedesktop/DBus/Local",
510 "org.freedesktop.DBus.Local",
511 "Connected");
512 if (r < 0)
513 return r;
514
515 bus_message_set_sender_local(bus, m);
516
517 r = bus_seal_synthetic_message(bus, m);
518 if (r < 0)
519 return r;
520
521 r = bus_rqueue_make_room(bus);
522 if (r < 0)
523 return r;
524
525 /* Insert at the very front */
526 memmove(bus->rqueue + 1, bus->rqueue, sizeof(sd_bus_message*) * bus->rqueue_size);
527 bus->rqueue[0] = m;
528 m = NULL;
529 bus->rqueue_size++;
530
531 return 0;
532 }
533
534 void bus_set_state(sd_bus *bus, enum bus_state state) {
535
536 static const char * const table[_BUS_STATE_MAX] = {
537 [BUS_UNSET] = "UNSET",
538 [BUS_WATCH_BIND] = "WATCH_BIND",
539 [BUS_OPENING] = "OPENING",
540 [BUS_AUTHENTICATING] = "AUTHENTICATING",
541 [BUS_HELLO] = "HELLO",
542 [BUS_RUNNING] = "RUNNING",
543 [BUS_CLOSING] = "CLOSING",
544 [BUS_CLOSED] = "CLOSED",
545 };
546
547 assert(bus);
548 assert(state < _BUS_STATE_MAX);
549
550 if (state == bus->state)
551 return;
552
553 log_debug("Bus %s: changing state %s → %s", strna(bus->description), table[bus->state], table[state]);
554 bus->state = state;
555 }
556
557 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
558 const char *s;
559 char *t;
560 sd_bus *bus;
561 int r;
562
563 assert(reply);
564 bus = reply->bus;
565 assert(bus);
566 assert(IN_SET(bus->state, BUS_HELLO, BUS_CLOSING));
567
568 r = sd_bus_message_get_errno(reply);
569 if (r > 0)
570 return -r;
571
572 r = sd_bus_message_read(reply, "s", &s);
573 if (r < 0)
574 return r;
575
576 if (!service_name_is_valid(s) || s[0] != ':')
577 return -EBADMSG;
578
579 t = strdup(s);
580 if (!t)
581 return -ENOMEM;
582
583 free_and_replace(bus->unique_name, t);
584
585 if (bus->state == BUS_HELLO) {
586 bus_set_state(bus, BUS_RUNNING);
587
588 r = synthesize_connected_signal(bus);
589 if (r < 0)
590 return r;
591 }
592
593 return 1;
594 }
595
596 static int bus_send_hello(sd_bus *bus) {
597 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
598 int r;
599
600 assert(bus);
601
602 if (!bus->bus_client)
603 return 0;
604
605 r = sd_bus_message_new_method_call(
606 bus,
607 &m,
608 "org.freedesktop.DBus",
609 "/org/freedesktop/DBus",
610 "org.freedesktop.DBus",
611 "Hello");
612 if (r < 0)
613 return r;
614
615 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
616 }
617
618 int bus_start_running(sd_bus *bus) {
619 struct reply_callback *c;
620 Iterator i;
621 usec_t n;
622 int r;
623
624 assert(bus);
625 assert(bus->state < BUS_HELLO);
626
627 /* We start all method call timeouts when we enter BUS_HELLO or BUS_RUNNING mode. At this point let's convert
628 * all relative to absolute timestamps. Note that we do not reshuffle the reply callback priority queue since
629 * adding a fixed value to all entries should not alter the internal order. */
630
631 n = now(CLOCK_MONOTONIC);
632 ORDERED_HASHMAP_FOREACH(c, bus->reply_callbacks, i) {
633 if (c->timeout_usec == 0)
634 continue;
635
636 c->timeout_usec = usec_add(n, c->timeout_usec);
637 }
638
639 if (bus->bus_client) {
640 bus_set_state(bus, BUS_HELLO);
641 return 1;
642 }
643
644 bus_set_state(bus, BUS_RUNNING);
645
646 r = synthesize_connected_signal(bus);
647 if (r < 0)
648 return r;
649
650 return 1;
651 }
652
653 static int parse_address_key(const char **p, const char *key, char **value) {
654 size_t l, n = 0, allocated = 0;
655 _cleanup_free_ char *r = NULL;
656 const char *a;
657
658 assert(p);
659 assert(*p);
660 assert(value);
661
662 if (key) {
663 l = strlen(key);
664 if (strncmp(*p, key, l) != 0)
665 return 0;
666
667 if ((*p)[l] != '=')
668 return 0;
669
670 if (*value)
671 return -EINVAL;
672
673 a = *p + l + 1;
674 } else
675 a = *p;
676
677 while (!IN_SET(*a, ';', ',', 0)) {
678 char c;
679
680 if (*a == '%') {
681 int x, y;
682
683 x = unhexchar(a[1]);
684 if (x < 0)
685 return x;
686
687 y = unhexchar(a[2]);
688 if (y < 0)
689 return y;
690
691 c = (char) ((x << 4) | y);
692 a += 3;
693 } else {
694 c = *a;
695 a++;
696 }
697
698 if (!GREEDY_REALLOC(r, allocated, n + 2))
699 return -ENOMEM;
700
701 r[n++] = c;
702 }
703
704 if (!r) {
705 r = strdup("");
706 if (!r)
707 return -ENOMEM;
708 } else
709 r[n] = 0;
710
711 if (*a == ',')
712 a++;
713
714 *p = a;
715
716 free_and_replace(*value, r);
717
718 return 1;
719 }
720
721 static void skip_address_key(const char **p) {
722 assert(p);
723 assert(*p);
724
725 *p += strcspn(*p, ",");
726
727 if (**p == ',')
728 (*p)++;
729 }
730
731 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
732 _cleanup_free_ char *path = NULL, *abstract = NULL;
733 size_t l;
734 int r;
735
736 assert(b);
737 assert(p);
738 assert(*p);
739 assert(guid);
740
741 while (!IN_SET(**p, 0, ';')) {
742 r = parse_address_key(p, "guid", guid);
743 if (r < 0)
744 return r;
745 else if (r > 0)
746 continue;
747
748 r = parse_address_key(p, "path", &path);
749 if (r < 0)
750 return r;
751 else if (r > 0)
752 continue;
753
754 r = parse_address_key(p, "abstract", &abstract);
755 if (r < 0)
756 return r;
757 else if (r > 0)
758 continue;
759
760 skip_address_key(p);
761 }
762
763 if (!path && !abstract)
764 return -EINVAL;
765
766 if (path && abstract)
767 return -EINVAL;
768
769 if (path) {
770 l = strlen(path);
771 if (l > sizeof(b->sockaddr.un.sun_path))
772 return -E2BIG;
773
774 b->sockaddr.un.sun_family = AF_UNIX;
775 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
776 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
777 } else if (abstract) {
778 l = strlen(abstract);
779 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
780 return -E2BIG;
781
782 b->sockaddr.un.sun_family = AF_UNIX;
783 b->sockaddr.un.sun_path[0] = 0;
784 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
785 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
786 }
787
788 b->is_local = true;
789
790 return 0;
791 }
792
793 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
794 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
795 int r;
796 struct addrinfo *result, hints = {
797 .ai_socktype = SOCK_STREAM,
798 .ai_flags = AI_ADDRCONFIG,
799 };
800
801 assert(b);
802 assert(p);
803 assert(*p);
804 assert(guid);
805
806 while (!IN_SET(**p, 0, ';')) {
807 r = parse_address_key(p, "guid", guid);
808 if (r < 0)
809 return r;
810 else if (r > 0)
811 continue;
812
813 r = parse_address_key(p, "host", &host);
814 if (r < 0)
815 return r;
816 else if (r > 0)
817 continue;
818
819 r = parse_address_key(p, "port", &port);
820 if (r < 0)
821 return r;
822 else if (r > 0)
823 continue;
824
825 r = parse_address_key(p, "family", &family);
826 if (r < 0)
827 return r;
828 else if (r > 0)
829 continue;
830
831 skip_address_key(p);
832 }
833
834 if (!host || !port)
835 return -EINVAL;
836
837 if (family) {
838 if (streq(family, "ipv4"))
839 hints.ai_family = AF_INET;
840 else if (streq(family, "ipv6"))
841 hints.ai_family = AF_INET6;
842 else
843 return -EINVAL;
844 }
845
846 r = getaddrinfo(host, port, &hints, &result);
847 if (r == EAI_SYSTEM)
848 return -errno;
849 else if (r != 0)
850 return -EADDRNOTAVAIL;
851
852 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
853 b->sockaddr_size = result->ai_addrlen;
854
855 freeaddrinfo(result);
856
857 b->is_local = false;
858
859 return 0;
860 }
861
862 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
863 char *path = NULL;
864 unsigned n_argv = 0, j;
865 char **argv = NULL;
866 size_t allocated = 0;
867 int r;
868
869 assert(b);
870 assert(p);
871 assert(*p);
872 assert(guid);
873
874 while (!IN_SET(**p, 0, ';')) {
875 r = parse_address_key(p, "guid", guid);
876 if (r < 0)
877 goto fail;
878 else if (r > 0)
879 continue;
880
881 r = parse_address_key(p, "path", &path);
882 if (r < 0)
883 goto fail;
884 else if (r > 0)
885 continue;
886
887 if (startswith(*p, "argv")) {
888 unsigned ul;
889
890 errno = 0;
891 ul = strtoul(*p + 4, (char**) p, 10);
892 if (errno > 0 || **p != '=' || ul > 256) {
893 r = -EINVAL;
894 goto fail;
895 }
896
897 (*p)++;
898
899 if (ul >= n_argv) {
900 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
901 r = -ENOMEM;
902 goto fail;
903 }
904
905 n_argv = ul + 1;
906 }
907
908 r = parse_address_key(p, NULL, argv + ul);
909 if (r < 0)
910 goto fail;
911
912 continue;
913 }
914
915 skip_address_key(p);
916 }
917
918 if (!path) {
919 r = -EINVAL;
920 goto fail;
921 }
922
923 /* Make sure there are no holes in the array, with the
924 * exception of argv[0] */
925 for (j = 1; j < n_argv; j++)
926 if (!argv[j]) {
927 r = -EINVAL;
928 goto fail;
929 }
930
931 if (argv && argv[0] == NULL) {
932 argv[0] = strdup(path);
933 if (!argv[0]) {
934 r = -ENOMEM;
935 goto fail;
936 }
937 }
938
939 b->exec_path = path;
940 b->exec_argv = argv;
941
942 b->is_local = false;
943
944 return 0;
945
946 fail:
947 for (j = 0; j < n_argv; j++)
948 free(argv[j]);
949
950 free(argv);
951 free(path);
952 return r;
953 }
954
955 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
956 _cleanup_free_ char *machine = NULL, *pid = NULL;
957 int r;
958
959 assert(b);
960 assert(p);
961 assert(*p);
962 assert(guid);
963
964 while (!IN_SET(**p, 0, ';')) {
965 r = parse_address_key(p, "guid", guid);
966 if (r < 0)
967 return r;
968 else if (r > 0)
969 continue;
970
971 r = parse_address_key(p, "machine", &machine);
972 if (r < 0)
973 return r;
974 else if (r > 0)
975 continue;
976
977 r = parse_address_key(p, "pid", &pid);
978 if (r < 0)
979 return r;
980 else if (r > 0)
981 continue;
982
983 skip_address_key(p);
984 }
985
986 if (!machine == !pid)
987 return -EINVAL;
988
989 if (machine) {
990 if (!machine_name_is_valid(machine))
991 return -EINVAL;
992
993 free_and_replace(b->machine, machine);
994 } else {
995 b->machine = mfree(b->machine);
996 }
997
998 if (pid) {
999 r = parse_pid(pid, &b->nspid);
1000 if (r < 0)
1001 return r;
1002 } else
1003 b->nspid = 0;
1004
1005 b->sockaddr.un.sun_family = AF_UNIX;
1006 /* Note that we use the old /var/run prefix here, to increase compatibility with really old containers */
1007 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
1008 b->sockaddr_size = SOCKADDR_UN_LEN(b->sockaddr.un);
1009 b->is_local = false;
1010
1011 return 0;
1012 }
1013
1014 static void bus_reset_parsed_address(sd_bus *b) {
1015 assert(b);
1016
1017 zero(b->sockaddr);
1018 b->sockaddr_size = 0;
1019 b->exec_argv = strv_free(b->exec_argv);
1020 b->exec_path = mfree(b->exec_path);
1021 b->server_id = SD_ID128_NULL;
1022 b->machine = mfree(b->machine);
1023 b->nspid = 0;
1024 }
1025
1026 static int bus_parse_next_address(sd_bus *b) {
1027 _cleanup_free_ char *guid = NULL;
1028 const char *a;
1029 int r;
1030
1031 assert(b);
1032
1033 if (!b->address)
1034 return 0;
1035 if (b->address[b->address_index] == 0)
1036 return 0;
1037
1038 bus_reset_parsed_address(b);
1039
1040 a = b->address + b->address_index;
1041
1042 while (*a != 0) {
1043
1044 if (*a == ';') {
1045 a++;
1046 continue;
1047 }
1048
1049 if (startswith(a, "unix:")) {
1050 a += 5;
1051
1052 r = parse_unix_address(b, &a, &guid);
1053 if (r < 0)
1054 return r;
1055 break;
1056
1057 } else if (startswith(a, "tcp:")) {
1058
1059 a += 4;
1060 r = parse_tcp_address(b, &a, &guid);
1061 if (r < 0)
1062 return r;
1063
1064 break;
1065
1066 } else if (startswith(a, "unixexec:")) {
1067
1068 a += 9;
1069 r = parse_exec_address(b, &a, &guid);
1070 if (r < 0)
1071 return r;
1072
1073 break;
1074
1075 } else if (startswith(a, "x-machine-unix:")) {
1076
1077 a += 15;
1078 r = parse_container_unix_address(b, &a, &guid);
1079 if (r < 0)
1080 return r;
1081
1082 break;
1083 }
1084
1085 a = strchr(a, ';');
1086 if (!a)
1087 return 0;
1088 }
1089
1090 if (guid) {
1091 r = sd_id128_from_string(guid, &b->server_id);
1092 if (r < 0)
1093 return r;
1094 }
1095
1096 b->address_index = a - b->address;
1097 return 1;
1098 }
1099
1100 static void bus_kill_exec(sd_bus *bus) {
1101 if (pid_is_valid(bus->busexec_pid) > 0) {
1102 sigterm_wait(bus->busexec_pid);
1103 bus->busexec_pid = 0;
1104 }
1105 }
1106
1107 static int bus_start_address(sd_bus *b) {
1108 int r;
1109
1110 assert(b);
1111
1112 for (;;) {
1113 bus_close_io_fds(b);
1114 bus_close_inotify_fd(b);
1115
1116 bus_kill_exec(b);
1117
1118 /* If you provide multiple different bus-addresses, we
1119 * try all of them in order and use the first one that
1120 * succeeds. */
1121
1122 if (b->exec_path)
1123 r = bus_socket_exec(b);
1124 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1125 r = bus_container_connect_socket(b);
1126 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1127 r = bus_socket_connect(b);
1128 else
1129 goto next;
1130
1131 if (r >= 0) {
1132 int q;
1133
1134 q = bus_attach_io_events(b);
1135 if (q < 0)
1136 return q;
1137
1138 q = bus_attach_inotify_event(b);
1139 if (q < 0)
1140 return q;
1141
1142 return r;
1143 }
1144
1145 b->last_connect_error = -r;
1146
1147 next:
1148 r = bus_parse_next_address(b);
1149 if (r < 0)
1150 return r;
1151 if (r == 0)
1152 return b->last_connect_error > 0 ? -b->last_connect_error : -ECONNREFUSED;
1153 }
1154 }
1155
1156 int bus_next_address(sd_bus *b) {
1157 assert(b);
1158
1159 bus_reset_parsed_address(b);
1160 return bus_start_address(b);
1161 }
1162
1163 static int bus_start_fd(sd_bus *b) {
1164 struct stat st;
1165 int r;
1166
1167 assert(b);
1168 assert(b->input_fd >= 0);
1169 assert(b->output_fd >= 0);
1170
1171 r = fd_nonblock(b->input_fd, true);
1172 if (r < 0)
1173 return r;
1174
1175 r = fd_cloexec(b->input_fd, true);
1176 if (r < 0)
1177 return r;
1178
1179 if (b->input_fd != b->output_fd) {
1180 r = fd_nonblock(b->output_fd, true);
1181 if (r < 0)
1182 return r;
1183
1184 r = fd_cloexec(b->output_fd, true);
1185 if (r < 0)
1186 return r;
1187 }
1188
1189 if (fstat(b->input_fd, &st) < 0)
1190 return -errno;
1191
1192 return bus_socket_take_fd(b);
1193 }
1194
1195 _public_ int sd_bus_start(sd_bus *bus) {
1196 int r;
1197
1198 assert_return(bus, -EINVAL);
1199 assert_return(bus = bus_resolve(bus), -ENOPKG);
1200 assert_return(bus->state == BUS_UNSET, -EPERM);
1201 assert_return(!bus_pid_changed(bus), -ECHILD);
1202
1203 bus_set_state(bus, BUS_OPENING);
1204
1205 if (bus->is_server && bus->bus_client)
1206 return -EINVAL;
1207
1208 if (bus->input_fd >= 0)
1209 r = bus_start_fd(bus);
1210 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->machine)
1211 r = bus_start_address(bus);
1212 else
1213 return -EINVAL;
1214
1215 if (r < 0) {
1216 sd_bus_close(bus);
1217 return r;
1218 }
1219
1220 return bus_send_hello(bus);
1221 }
1222
1223 _public_ int sd_bus_open(sd_bus **ret) {
1224 const char *e;
1225 sd_bus *b;
1226 int r;
1227
1228 assert_return(ret, -EINVAL);
1229
1230 /* Let's connect to the starter bus if it is set, and
1231 * otherwise to the bus that is appropropriate for the scope
1232 * we are running in */
1233
1234 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1235 if (e) {
1236 if (streq(e, "system"))
1237 return sd_bus_open_system(ret);
1238 else if (STR_IN_SET(e, "session", "user"))
1239 return sd_bus_open_user(ret);
1240 }
1241
1242 e = secure_getenv("DBUS_STARTER_ADDRESS");
1243 if (!e) {
1244 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1245 return sd_bus_open_user(ret);
1246 else
1247 return sd_bus_open_system(ret);
1248 }
1249
1250 r = sd_bus_new(&b);
1251 if (r < 0)
1252 return r;
1253
1254 r = sd_bus_set_address(b, e);
1255 if (r < 0)
1256 goto fail;
1257
1258 b->bus_client = true;
1259
1260 /* We don't know whether the bus is trusted or not, so better
1261 * be safe, and authenticate everything */
1262 b->trusted = false;
1263 b->is_local = false;
1264 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1265
1266 r = sd_bus_start(b);
1267 if (r < 0)
1268 goto fail;
1269
1270 *ret = b;
1271 return 0;
1272
1273 fail:
1274 bus_free(b);
1275 return r;
1276 }
1277
1278 int bus_set_address_system(sd_bus *b) {
1279 const char *e;
1280 assert(b);
1281
1282 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1283 if (e)
1284 return sd_bus_set_address(b, e);
1285
1286 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1287 }
1288
1289 _public_ int sd_bus_open_system(sd_bus **ret) {
1290 sd_bus *b;
1291 int r;
1292
1293 assert_return(ret, -EINVAL);
1294
1295 r = sd_bus_new(&b);
1296 if (r < 0)
1297 return r;
1298
1299 r = bus_set_address_system(b);
1300 if (r < 0)
1301 goto fail;
1302
1303 b->bus_client = true;
1304 b->is_system = true;
1305
1306 /* Let's do per-method access control on the system bus. We
1307 * need the caller's UID and capability set for that. */
1308 b->trusted = false;
1309 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1310 b->is_local = true;
1311
1312 r = sd_bus_start(b);
1313 if (r < 0)
1314 goto fail;
1315
1316 *ret = b;
1317 return 0;
1318
1319 fail:
1320 bus_free(b);
1321 return r;
1322 }
1323
1324 int bus_set_address_user(sd_bus *b) {
1325 const char *e;
1326 _cleanup_free_ char *ee = NULL, *s = NULL;
1327
1328 assert(b);
1329
1330 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1331 if (e)
1332 return sd_bus_set_address(b, e);
1333
1334 e = secure_getenv("XDG_RUNTIME_DIR");
1335 if (!e)
1336 return -ENOENT;
1337
1338 ee = bus_address_escape(e);
1339 if (!ee)
1340 return -ENOMEM;
1341
1342 if (asprintf(&s, DEFAULT_USER_BUS_ADDRESS_FMT, ee) < 0)
1343 return -ENOMEM;
1344
1345 b->address = TAKE_PTR(s);
1346
1347 return 0;
1348 }
1349
1350 _public_ int sd_bus_open_user(sd_bus **ret) {
1351 sd_bus *b;
1352 int r;
1353
1354 assert_return(ret, -EINVAL);
1355
1356 r = sd_bus_new(&b);
1357 if (r < 0)
1358 return r;
1359
1360 r = bus_set_address_user(b);
1361 if (r < 0)
1362 goto fail;
1363
1364 b->bus_client = true;
1365 b->is_user = true;
1366
1367 /* We don't do any per-method access control on the user
1368 * bus. */
1369 b->trusted = true;
1370 b->is_local = true;
1371
1372 r = sd_bus_start(b);
1373 if (r < 0)
1374 goto fail;
1375
1376 *ret = b;
1377 return 0;
1378
1379 fail:
1380 bus_free(b);
1381 return r;
1382 }
1383
1384 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1385 _cleanup_free_ char *e = NULL;
1386 char *m = NULL, *c = NULL, *a;
1387
1388 assert(b);
1389 assert(host);
1390
1391 /* Let's see if we shall enter some container */
1392 m = strchr(host, ':');
1393 if (m) {
1394 m++;
1395
1396 /* Let's make sure this is not a port of some kind,
1397 * and is a valid machine name. */
1398 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1399 char *t;
1400
1401 /* Cut out the host part */
1402 t = strndupa(host, m - host - 1);
1403 e = bus_address_escape(t);
1404 if (!e)
1405 return -ENOMEM;
1406
1407 c = strjoina(",argv5=--machine=", m);
1408 }
1409 }
1410
1411 if (!e) {
1412 e = bus_address_escape(host);
1413 if (!e)
1414 return -ENOMEM;
1415 }
1416
1417 a = strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e, ",argv4=systemd-stdio-bridge", c);
1418 if (!a)
1419 return -ENOMEM;
1420
1421 free_and_replace(b->address, a);
1422
1423 return 0;
1424 }
1425
1426 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1427 sd_bus *bus;
1428 int r;
1429
1430 assert_return(host, -EINVAL);
1431 assert_return(ret, -EINVAL);
1432
1433 r = sd_bus_new(&bus);
1434 if (r < 0)
1435 return r;
1436
1437 r = bus_set_address_system_remote(bus, host);
1438 if (r < 0)
1439 goto fail;
1440
1441 bus->bus_client = true;
1442 bus->trusted = false;
1443 bus->is_system = true;
1444 bus->is_local = false;
1445
1446 r = sd_bus_start(bus);
1447 if (r < 0)
1448 goto fail;
1449
1450 *ret = bus;
1451 return 0;
1452
1453 fail:
1454 bus_free(bus);
1455 return r;
1456 }
1457
1458 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1459 _cleanup_free_ char *e = NULL;
1460 char *a;
1461
1462 assert(b);
1463 assert(machine);
1464
1465 e = bus_address_escape(machine);
1466 if (!e)
1467 return -ENOMEM;
1468
1469 a = strjoin("x-machine-unix:machine=", e);
1470 if (!a)
1471 return -ENOMEM;
1472
1473 free_and_replace(b->address, a);
1474
1475 return 0;
1476 }
1477
1478 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1479 sd_bus *bus;
1480 int r;
1481
1482 assert_return(machine, -EINVAL);
1483 assert_return(ret, -EINVAL);
1484 assert_return(machine_name_is_valid(machine), -EINVAL);
1485
1486 r = sd_bus_new(&bus);
1487 if (r < 0)
1488 return r;
1489
1490 r = bus_set_address_system_machine(bus, machine);
1491 if (r < 0)
1492 goto fail;
1493
1494 bus->bus_client = true;
1495 bus->trusted = false;
1496 bus->is_system = true;
1497 bus->is_local = false;
1498
1499 r = sd_bus_start(bus);
1500 if (r < 0)
1501 goto fail;
1502
1503 *ret = bus;
1504 return 0;
1505
1506 fail:
1507 bus_free(bus);
1508 return r;
1509 }
1510
1511 _public_ void sd_bus_close(sd_bus *bus) {
1512
1513 if (!bus)
1514 return;
1515 if (bus->state == BUS_CLOSED)
1516 return;
1517 if (bus_pid_changed(bus))
1518 return;
1519
1520 /* Don't leave ssh hanging around */
1521 bus_kill_exec(bus);
1522
1523 bus_set_state(bus, BUS_CLOSED);
1524
1525 sd_bus_detach_event(bus);
1526
1527 /* Drop all queued messages so that they drop references to
1528 * the bus object and the bus may be freed */
1529 bus_reset_queues(bus);
1530
1531 bus_close_io_fds(bus);
1532 bus_close_inotify_fd(bus);
1533 }
1534
1535 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1536
1537 if (!bus)
1538 return NULL;
1539
1540 /* Have to do this before flush() to prevent hang */
1541 bus_kill_exec(bus);
1542
1543 sd_bus_flush(bus);
1544 sd_bus_close(bus);
1545
1546 return sd_bus_unref(bus);
1547 }
1548
1549 void bus_enter_closing(sd_bus *bus) {
1550 assert(bus);
1551
1552 if (!IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING))
1553 return;
1554
1555 bus_set_state(bus, BUS_CLOSING);
1556 }
1557
1558 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1559
1560 if (!bus)
1561 return NULL;
1562
1563 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1564
1565 return bus;
1566 }
1567
1568 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1569 unsigned i;
1570
1571 if (!bus)
1572 return NULL;
1573
1574 i = REFCNT_DEC(bus->n_ref);
1575 if (i > 0)
1576 return NULL;
1577
1578 bus_free(bus);
1579 return NULL;
1580 }
1581
1582 _public_ int sd_bus_is_open(sd_bus *bus) {
1583
1584 assert_return(bus, -EINVAL);
1585 assert_return(bus = bus_resolve(bus), -ENOPKG);
1586 assert_return(!bus_pid_changed(bus), -ECHILD);
1587
1588 return BUS_IS_OPEN(bus->state);
1589 }
1590
1591 _public_ int sd_bus_is_ready(sd_bus *bus) {
1592 assert_return(bus, -EINVAL);
1593 assert_return(bus = bus_resolve(bus), -ENOPKG);
1594 assert_return(!bus_pid_changed(bus), -ECHILD);
1595
1596 return bus->state == BUS_RUNNING;
1597 }
1598
1599 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1600 int r;
1601
1602 assert_return(bus, -EINVAL);
1603 assert_return(bus = bus_resolve(bus), -ENOPKG);
1604 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1605 assert_return(!bus_pid_changed(bus), -ECHILD);
1606
1607 if (bus->is_monitor)
1608 return 0;
1609
1610 if (type == SD_BUS_TYPE_UNIX_FD) {
1611 if (!bus->accept_fd)
1612 return 0;
1613
1614 r = bus_ensure_running(bus);
1615 if (r < 0)
1616 return r;
1617
1618 return bus->can_fds;
1619 }
1620
1621 return bus_type_is_valid(type);
1622 }
1623
1624 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1625 int r;
1626
1627 assert_return(bus, -EINVAL);
1628 assert_return(bus = bus_resolve(bus), -ENOPKG);
1629 assert_return(id, -EINVAL);
1630 assert_return(!bus_pid_changed(bus), -ECHILD);
1631
1632 r = bus_ensure_running(bus);
1633 if (r < 0)
1634 return r;
1635
1636 *id = bus->server_id;
1637 return 0;
1638 }
1639
1640 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1641 int r;
1642
1643 assert(b);
1644 assert(m);
1645
1646 if (m->sealed) {
1647 /* If we copy the same message to multiple
1648 * destinations, avoid using the same cookie
1649 * numbers. */
1650 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1651 return 0;
1652 }
1653
1654 if (timeout == 0)
1655 timeout = BUS_DEFAULT_TIMEOUT;
1656
1657 if (!m->sender && b->patch_sender) {
1658 r = sd_bus_message_set_sender(m, b->patch_sender);
1659 if (r < 0)
1660 return r;
1661 }
1662
1663 return sd_bus_message_seal(m, ++b->cookie, timeout);
1664 }
1665
1666 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1667 bool remarshal = false;
1668
1669 assert(b);
1670
1671 /* wrong packet version */
1672 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1673 remarshal = true;
1674
1675 /* wrong packet endianness */
1676 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1677 remarshal = true;
1678
1679 return remarshal ? bus_message_remarshal(b, m) : 0;
1680 }
1681
1682 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1683 assert(b);
1684 assert(m);
1685
1686 /* Fake some timestamps, if they were requested, and not
1687 * already initialized */
1688 if (b->attach_timestamp) {
1689 if (m->realtime <= 0)
1690 m->realtime = now(CLOCK_REALTIME);
1691
1692 if (m->monotonic <= 0)
1693 m->monotonic = now(CLOCK_MONOTONIC);
1694 }
1695
1696 /* The bus specification says the serial number cannot be 0,
1697 * hence let's fill something in for synthetic messages. Since
1698 * synthetic messages might have a fake sender and we don't
1699 * want to interfere with the real sender's serial numbers we
1700 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1701 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1702 * even though kdbus can do 64bit. */
1703 return sd_bus_message_seal(m, 0xFFFFFFFFULL, 0);
1704 }
1705
1706 static int bus_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
1707 int r;
1708
1709 assert(bus);
1710 assert(m);
1711
1712 r = bus_socket_write_message(bus, m, idx);
1713 if (r <= 0)
1714 return r;
1715
1716 if (*idx >= BUS_MESSAGE_SIZE(m))
1717 log_debug("Sent message type=%s sender=%s destination=%s path=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " signature=%s error-name=%s error-message=%s",
1718 bus_message_type_to_string(m->header->type),
1719 strna(sd_bus_message_get_sender(m)),
1720 strna(sd_bus_message_get_destination(m)),
1721 strna(sd_bus_message_get_path(m)),
1722 strna(sd_bus_message_get_interface(m)),
1723 strna(sd_bus_message_get_member(m)),
1724 BUS_MESSAGE_COOKIE(m),
1725 m->reply_cookie,
1726 strna(m->root_container.signature),
1727 strna(m->error.name),
1728 strna(m->error.message));
1729
1730 return r;
1731 }
1732
1733 static int dispatch_wqueue(sd_bus *bus) {
1734 int r, ret = 0;
1735
1736 assert(bus);
1737 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1738
1739 while (bus->wqueue_size > 0) {
1740
1741 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1742 if (r < 0)
1743 return r;
1744 else if (r == 0)
1745 /* Didn't do anything this time */
1746 return ret;
1747 else if (bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1748 /* Fully written. Let's drop the entry from
1749 * the queue.
1750 *
1751 * This isn't particularly optimized, but
1752 * well, this is supposed to be our worst-case
1753 * buffer only, and the socket buffer is
1754 * supposed to be our primary buffer, and if
1755 * it got full, then all bets are off
1756 * anyway. */
1757
1758 bus->wqueue_size--;
1759 sd_bus_message_unref(bus->wqueue[0]);
1760 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1761 bus->windex = 0;
1762
1763 ret = 1;
1764 }
1765 }
1766
1767 return ret;
1768 }
1769
1770 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1771 assert(bus);
1772
1773 return bus_socket_read_message(bus);
1774 }
1775
1776 int bus_rqueue_make_room(sd_bus *bus) {
1777 assert(bus);
1778
1779 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1780 return -ENOBUFS;
1781
1782 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1783 return -ENOMEM;
1784
1785 return 0;
1786 }
1787
1788 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1789 int r, ret = 0;
1790
1791 assert(bus);
1792 assert(m);
1793 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1794
1795 /* Note that the priority logic is only available on kdbus,
1796 * where the rqueue is unused. We check the rqueue here
1797 * anyway, because it's simple... */
1798
1799 for (;;) {
1800 if (bus->rqueue_size > 0) {
1801 /* Dispatch a queued message */
1802
1803 *m = bus->rqueue[0];
1804 bus->rqueue_size--;
1805 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1806 return 1;
1807 }
1808
1809 /* Try to read a new message */
1810 r = bus_read_message(bus, hint_priority, priority);
1811 if (r < 0)
1812 return r;
1813 if (r == 0)
1814 return ret;
1815
1816 ret = 1;
1817 }
1818 }
1819
1820 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie) {
1821 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1822 int r;
1823
1824 assert_return(m, -EINVAL);
1825
1826 if (!bus)
1827 bus = m->bus;
1828
1829 assert_return(!bus_pid_changed(bus), -ECHILD);
1830
1831 if (!BUS_IS_OPEN(bus->state))
1832 return -ENOTCONN;
1833
1834 if (m->n_fds > 0) {
1835 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1836 if (r < 0)
1837 return r;
1838 if (r == 0)
1839 return -EOPNOTSUPP;
1840 }
1841
1842 /* If the cookie number isn't kept, then we know that no reply
1843 * is expected */
1844 if (!cookie && !m->sealed)
1845 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1846
1847 r = bus_seal_message(bus, m, 0);
1848 if (r < 0)
1849 return r;
1850
1851 /* Remarshall if we have to. This will possibly unref the
1852 * message and place a replacement in m */
1853 r = bus_remarshal_message(bus, &m);
1854 if (r < 0)
1855 return r;
1856
1857 /* If this is a reply and no reply was requested, then let's
1858 * suppress this, if we can */
1859 if (m->dont_send)
1860 goto finish;
1861
1862 if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO) && bus->wqueue_size <= 0) {
1863 size_t idx = 0;
1864
1865 r = bus_write_message(bus, m, &idx);
1866 if (r < 0) {
1867 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1868 bus_enter_closing(bus);
1869 return -ECONNRESET;
1870 }
1871
1872 return r;
1873 }
1874
1875 if (idx < BUS_MESSAGE_SIZE(m)) {
1876 /* Wasn't fully written. So let's remember how
1877 * much was written. Note that the first entry
1878 * of the wqueue array is always allocated so
1879 * that we always can remember how much was
1880 * written. */
1881 bus->wqueue[0] = sd_bus_message_ref(m);
1882 bus->wqueue_size = 1;
1883 bus->windex = idx;
1884 }
1885
1886 } else {
1887 /* Just append it to the queue. */
1888
1889 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1890 return -ENOBUFS;
1891
1892 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1893 return -ENOMEM;
1894
1895 bus->wqueue[bus->wqueue_size++] = sd_bus_message_ref(m);
1896 }
1897
1898 finish:
1899 if (cookie)
1900 *cookie = BUS_MESSAGE_COOKIE(m);
1901
1902 return 1;
1903 }
1904
1905 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1906 int r;
1907
1908 assert_return(m, -EINVAL);
1909
1910 if (!bus)
1911 bus = m->bus;
1912
1913 assert_return(!bus_pid_changed(bus), -ECHILD);
1914
1915 if (!BUS_IS_OPEN(bus->state))
1916 return -ENOTCONN;
1917
1918 if (!streq_ptr(m->destination, destination)) {
1919
1920 if (!destination)
1921 return -EEXIST;
1922
1923 r = sd_bus_message_set_destination(m, destination);
1924 if (r < 0)
1925 return r;
1926 }
1927
1928 return sd_bus_send(bus, m, cookie);
1929 }
1930
1931 static usec_t calc_elapse(sd_bus *bus, uint64_t usec) {
1932 assert(bus);
1933
1934 if (usec == (uint64_t) -1)
1935 return 0;
1936
1937 /* We start all timeouts the instant we enter BUS_HELLO/BUS_RUNNING state, so that the don't run in parallel
1938 * with any connection setup states. Hence, if a method callback is started earlier than that we just store the
1939 * relative timestamp, and afterwards the absolute one. */
1940
1941 if (IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING))
1942 return usec;
1943 else
1944 return now(CLOCK_MONOTONIC) + usec;
1945 }
1946
1947 static int timeout_compare(const void *a, const void *b) {
1948 const struct reply_callback *x = a, *y = b;
1949
1950 if (x->timeout_usec != 0 && y->timeout_usec == 0)
1951 return -1;
1952
1953 if (x->timeout_usec == 0 && y->timeout_usec != 0)
1954 return 1;
1955
1956 if (x->timeout_usec < y->timeout_usec)
1957 return -1;
1958
1959 if (x->timeout_usec > y->timeout_usec)
1960 return 1;
1961
1962 return 0;
1963 }
1964
1965 _public_ int sd_bus_call_async(
1966 sd_bus *bus,
1967 sd_bus_slot **slot,
1968 sd_bus_message *_m,
1969 sd_bus_message_handler_t callback,
1970 void *userdata,
1971 uint64_t usec) {
1972
1973 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1974 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
1975 int r;
1976
1977 assert_return(m, -EINVAL);
1978 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1979 assert_return(!m->sealed || (!!callback == !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)), -EINVAL);
1980
1981 if (!bus)
1982 bus = m->bus;
1983
1984 assert_return(!bus_pid_changed(bus), -ECHILD);
1985
1986 if (!BUS_IS_OPEN(bus->state))
1987 return -ENOTCONN;
1988
1989 /* If no callback is specified and there's no interest in a slot, then there's no reason to ask for a reply */
1990 if (!callback && !slot && !m->sealed)
1991 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1992
1993 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1994 if (r < 0)
1995 return r;
1996
1997 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1998 if (r < 0)
1999 return r;
2000
2001 r = bus_seal_message(bus, m, usec);
2002 if (r < 0)
2003 return r;
2004
2005 r = bus_remarshal_message(bus, &m);
2006 if (r < 0)
2007 return r;
2008
2009 if (slot || callback) {
2010 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
2011 if (!s)
2012 return -ENOMEM;
2013
2014 s->reply_callback.callback = callback;
2015
2016 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
2017 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
2018 if (r < 0) {
2019 s->reply_callback.cookie = 0;
2020 return r;
2021 }
2022
2023 s->reply_callback.timeout_usec = calc_elapse(bus, m->timeout);
2024 if (s->reply_callback.timeout_usec != 0) {
2025 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
2026 if (r < 0) {
2027 s->reply_callback.timeout_usec = 0;
2028 return r;
2029 }
2030 }
2031 }
2032
2033 r = sd_bus_send(bus, m, s ? &s->reply_callback.cookie : NULL);
2034 if (r < 0)
2035 return r;
2036
2037 if (slot)
2038 *slot = s;
2039 s = NULL;
2040
2041 return r;
2042 }
2043
2044 int bus_ensure_running(sd_bus *bus) {
2045 int r;
2046
2047 assert(bus);
2048
2049 if (IN_SET(bus->state, BUS_UNSET, BUS_CLOSED, BUS_CLOSING))
2050 return -ENOTCONN;
2051 if (bus->state == BUS_RUNNING)
2052 return 1;
2053
2054 for (;;) {
2055 r = sd_bus_process(bus, NULL);
2056 if (r < 0)
2057 return r;
2058 if (bus->state == BUS_RUNNING)
2059 return 1;
2060 if (r > 0)
2061 continue;
2062
2063 r = sd_bus_wait(bus, (uint64_t) -1);
2064 if (r < 0)
2065 return r;
2066 }
2067 }
2068
2069 _public_ int sd_bus_call(
2070 sd_bus *bus,
2071 sd_bus_message *_m,
2072 uint64_t usec,
2073 sd_bus_error *error,
2074 sd_bus_message **reply) {
2075
2076 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
2077 usec_t timeout;
2078 uint64_t cookie;
2079 unsigned i;
2080 int r;
2081
2082 bus_assert_return(m, -EINVAL, error);
2083 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2084 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2085 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2086
2087 if (!bus)
2088 bus = m->bus;
2089
2090 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2091
2092 if (!BUS_IS_OPEN(bus->state)) {
2093 r = -ENOTCONN;
2094 goto fail;
2095 }
2096
2097 r = bus_ensure_running(bus);
2098 if (r < 0)
2099 goto fail;
2100
2101 i = bus->rqueue_size;
2102
2103 r = bus_seal_message(bus, m, usec);
2104 if (r < 0)
2105 goto fail;
2106
2107 r = bus_remarshal_message(bus, &m);
2108 if (r < 0)
2109 goto fail;
2110
2111 r = sd_bus_send(bus, m, &cookie);
2112 if (r < 0)
2113 goto fail;
2114
2115 timeout = calc_elapse(bus, m->timeout);
2116
2117 for (;;) {
2118 usec_t left;
2119
2120 while (i < bus->rqueue_size) {
2121 sd_bus_message *incoming = NULL;
2122
2123 incoming = bus->rqueue[i];
2124
2125 if (incoming->reply_cookie == cookie) {
2126 /* Found a match! */
2127
2128 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2129 bus->rqueue_size--;
2130 log_debug_bus_message(incoming);
2131
2132 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2133
2134 if (incoming->n_fds <= 0 || bus->accept_fd) {
2135 if (reply)
2136 *reply = incoming;
2137 else
2138 sd_bus_message_unref(incoming);
2139
2140 return 1;
2141 }
2142
2143 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2144 sd_bus_message_unref(incoming);
2145 return r;
2146
2147 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2148 r = sd_bus_error_copy(error, &incoming->error);
2149 sd_bus_message_unref(incoming);
2150 return r;
2151 } else {
2152 r = -EIO;
2153 goto fail;
2154 }
2155
2156 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2157 bus->unique_name &&
2158 incoming->sender &&
2159 streq(bus->unique_name, incoming->sender)) {
2160
2161 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2162 bus->rqueue_size--;
2163
2164 /* Our own message? Somebody is trying
2165 * to send its own client a message,
2166 * let's not dead-lock, let's fail
2167 * immediately. */
2168
2169 sd_bus_message_unref(incoming);
2170 r = -ELOOP;
2171 goto fail;
2172 }
2173
2174 /* Try to read more, right-away */
2175 i++;
2176 }
2177
2178 r = bus_read_message(bus, false, 0);
2179 if (r < 0) {
2180 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2181 bus_enter_closing(bus);
2182 r = -ECONNRESET;
2183 }
2184
2185 goto fail;
2186 }
2187 if (r > 0)
2188 continue;
2189
2190 if (timeout > 0) {
2191 usec_t n;
2192
2193 n = now(CLOCK_MONOTONIC);
2194 if (n >= timeout) {
2195 r = -ETIMEDOUT;
2196 goto fail;
2197 }
2198
2199 left = timeout - n;
2200 } else
2201 left = (uint64_t) -1;
2202
2203 r = bus_poll(bus, true, left);
2204 if (r < 0)
2205 goto fail;
2206 if (r == 0) {
2207 r = -ETIMEDOUT;
2208 goto fail;
2209 }
2210
2211 r = dispatch_wqueue(bus);
2212 if (r < 0) {
2213 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2214 bus_enter_closing(bus);
2215 r = -ECONNRESET;
2216 }
2217
2218 goto fail;
2219 }
2220 }
2221
2222 fail:
2223 return sd_bus_error_set_errno(error, r);
2224 }
2225
2226 _public_ int sd_bus_get_fd(sd_bus *bus) {
2227
2228 assert_return(bus, -EINVAL);
2229 assert_return(bus = bus_resolve(bus), -ENOPKG);
2230 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2231 assert_return(!bus_pid_changed(bus), -ECHILD);
2232
2233 if (bus->state == BUS_CLOSED)
2234 return -ENOTCONN;
2235
2236 if (bus->inotify_fd >= 0)
2237 return bus->inotify_fd;
2238
2239 if (bus->input_fd >= 0)
2240 return bus->input_fd;
2241
2242 return -ENOTCONN;
2243 }
2244
2245 _public_ int sd_bus_get_events(sd_bus *bus) {
2246 int flags = 0;
2247
2248 assert_return(bus, -EINVAL);
2249 assert_return(bus = bus_resolve(bus), -ENOPKG);
2250 assert_return(!bus_pid_changed(bus), -ECHILD);
2251
2252 switch (bus->state) {
2253
2254 case BUS_UNSET:
2255 case BUS_CLOSED:
2256 return -ENOTCONN;
2257
2258 case BUS_WATCH_BIND:
2259 flags |= POLLIN;
2260 break;
2261
2262 case BUS_OPENING:
2263 flags |= POLLOUT;
2264 break;
2265
2266 case BUS_AUTHENTICATING:
2267 if (bus_socket_auth_needs_write(bus))
2268 flags |= POLLOUT;
2269
2270 flags |= POLLIN;
2271 break;
2272
2273 case BUS_RUNNING:
2274 case BUS_HELLO:
2275 if (bus->rqueue_size <= 0)
2276 flags |= POLLIN;
2277 if (bus->wqueue_size > 0)
2278 flags |= POLLOUT;
2279 break;
2280
2281 case BUS_CLOSING:
2282 break;
2283
2284 default:
2285 assert_not_reached("Unknown state");
2286 }
2287
2288 return flags;
2289 }
2290
2291 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2292 struct reply_callback *c;
2293
2294 assert_return(bus, -EINVAL);
2295 assert_return(bus = bus_resolve(bus), -ENOPKG);
2296 assert_return(timeout_usec, -EINVAL);
2297 assert_return(!bus_pid_changed(bus), -ECHILD);
2298
2299 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2300 return -ENOTCONN;
2301
2302 if (bus->track_queue) {
2303 *timeout_usec = 0;
2304 return 1;
2305 }
2306
2307 switch (bus->state) {
2308
2309 case BUS_AUTHENTICATING:
2310 *timeout_usec = bus->auth_timeout;
2311 return 1;
2312
2313 case BUS_RUNNING:
2314 case BUS_HELLO:
2315 if (bus->rqueue_size > 0) {
2316 *timeout_usec = 0;
2317 return 1;
2318 }
2319
2320 c = prioq_peek(bus->reply_callbacks_prioq);
2321 if (!c) {
2322 *timeout_usec = (uint64_t) -1;
2323 return 0;
2324 }
2325
2326 if (c->timeout_usec == 0) {
2327 *timeout_usec = (uint64_t) -1;
2328 return 0;
2329 }
2330
2331 *timeout_usec = c->timeout_usec;
2332 return 1;
2333
2334 case BUS_CLOSING:
2335 *timeout_usec = 0;
2336 return 1;
2337
2338 case BUS_WATCH_BIND:
2339 case BUS_OPENING:
2340 *timeout_usec = (uint64_t) -1;
2341 return 0;
2342
2343 default:
2344 assert_not_reached("Unknown or unexpected stat");
2345 }
2346 }
2347
2348 static int process_timeout(sd_bus *bus) {
2349 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2350 _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2351 struct reply_callback *c;
2352 sd_bus_slot *slot;
2353 bool is_hello;
2354 usec_t n;
2355 int r;
2356
2357 assert(bus);
2358 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2359
2360 c = prioq_peek(bus->reply_callbacks_prioq);
2361 if (!c)
2362 return 0;
2363
2364 n = now(CLOCK_MONOTONIC);
2365 if (c->timeout_usec > n)
2366 return 0;
2367
2368 r = bus_message_new_synthetic_error(
2369 bus,
2370 c->cookie,
2371 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2372 &m);
2373 if (r < 0)
2374 return r;
2375
2376 r = bus_seal_synthetic_message(bus, m);
2377 if (r < 0)
2378 return r;
2379
2380 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2381 c->timeout_usec = 0;
2382
2383 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2384 c->cookie = 0;
2385
2386 slot = container_of(c, sd_bus_slot, reply_callback);
2387
2388 bus->iteration_counter++;
2389
2390 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2391
2392 bus->current_message = m;
2393 bus->current_slot = sd_bus_slot_ref(slot);
2394 bus->current_handler = c->callback;
2395 bus->current_userdata = slot->userdata;
2396 r = c->callback(m, slot->userdata, &error_buffer);
2397 bus->current_userdata = NULL;
2398 bus->current_handler = NULL;
2399 bus->current_slot = NULL;
2400 bus->current_message = NULL;
2401
2402 if (slot->floating) {
2403 bus_slot_disconnect(slot);
2404 sd_bus_slot_unref(slot);
2405 }
2406
2407 sd_bus_slot_unref(slot);
2408
2409 /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2410 * and ignore the callback handler's return value. */
2411 if (is_hello)
2412 return r;
2413
2414 return bus_maybe_reply_error(m, r, &error_buffer);
2415 }
2416
2417 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2418 assert(bus);
2419 assert(m);
2420
2421 if (bus->state != BUS_HELLO)
2422 return 0;
2423
2424 /* Let's make sure the first message on the bus is the HELLO
2425 * reply. But note that we don't actually parse the message
2426 * here (we leave that to the usual handling), we just verify
2427 * we don't let any earlier msg through. */
2428
2429 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2430 return -EIO;
2431
2432 if (m->reply_cookie != 1)
2433 return -EIO;
2434
2435 return 0;
2436 }
2437
2438 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2439 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2440 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2441 struct reply_callback *c;
2442 sd_bus_slot *slot;
2443 bool is_hello;
2444 int r;
2445
2446 assert(bus);
2447 assert(m);
2448
2449 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2450 return 0;
2451
2452 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2453 return 0;
2454
2455 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2456 if (!c)
2457 return 0;
2458
2459 c->cookie = 0;
2460
2461 slot = container_of(c, sd_bus_slot, reply_callback);
2462
2463 if (m->n_fds > 0 && !bus->accept_fd) {
2464
2465 /* If the reply contained a file descriptor which we
2466 * didn't want we pass an error instead. */
2467
2468 r = bus_message_new_synthetic_error(
2469 bus,
2470 m->reply_cookie,
2471 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2472 &synthetic_reply);
2473 if (r < 0)
2474 return r;
2475
2476 /* Copy over original timestamp */
2477 synthetic_reply->realtime = m->realtime;
2478 synthetic_reply->monotonic = m->monotonic;
2479 synthetic_reply->seqnum = m->seqnum;
2480
2481 r = bus_seal_synthetic_message(bus, synthetic_reply);
2482 if (r < 0)
2483 return r;
2484
2485 m = synthetic_reply;
2486 } else {
2487 r = sd_bus_message_rewind(m, true);
2488 if (r < 0)
2489 return r;
2490 }
2491
2492 if (c->timeout_usec != 0) {
2493 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2494 c->timeout_usec = 0;
2495 }
2496
2497 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2498
2499 bus->current_slot = sd_bus_slot_ref(slot);
2500 bus->current_handler = c->callback;
2501 bus->current_userdata = slot->userdata;
2502 r = c->callback(m, slot->userdata, &error_buffer);
2503 bus->current_userdata = NULL;
2504 bus->current_handler = NULL;
2505 bus->current_slot = NULL;
2506
2507 if (slot->floating) {
2508 bus_slot_disconnect(slot);
2509 sd_bus_slot_unref(slot);
2510 }
2511
2512 sd_bus_slot_unref(slot);
2513
2514 /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2515 * ignore the callback handler's return value. */
2516 if (is_hello)
2517 return r;
2518
2519 return bus_maybe_reply_error(m, r, &error_buffer);
2520 }
2521
2522 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2523 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2524 struct filter_callback *l;
2525 int r;
2526
2527 assert(bus);
2528 assert(m);
2529
2530 do {
2531 bus->filter_callbacks_modified = false;
2532
2533 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2534 sd_bus_slot *slot;
2535
2536 if (bus->filter_callbacks_modified)
2537 break;
2538
2539 /* Don't run this more than once per iteration */
2540 if (l->last_iteration == bus->iteration_counter)
2541 continue;
2542
2543 l->last_iteration = bus->iteration_counter;
2544
2545 r = sd_bus_message_rewind(m, true);
2546 if (r < 0)
2547 return r;
2548
2549 slot = container_of(l, sd_bus_slot, filter_callback);
2550
2551 bus->current_slot = sd_bus_slot_ref(slot);
2552 bus->current_handler = l->callback;
2553 bus->current_userdata = slot->userdata;
2554 r = l->callback(m, slot->userdata, &error_buffer);
2555 bus->current_userdata = NULL;
2556 bus->current_handler = NULL;
2557 bus->current_slot = sd_bus_slot_unref(slot);
2558
2559 r = bus_maybe_reply_error(m, r, &error_buffer);
2560 if (r != 0)
2561 return r;
2562
2563 }
2564
2565 } while (bus->filter_callbacks_modified);
2566
2567 return 0;
2568 }
2569
2570 static int process_match(sd_bus *bus, sd_bus_message *m) {
2571 int r;
2572
2573 assert(bus);
2574 assert(m);
2575
2576 do {
2577 bus->match_callbacks_modified = false;
2578
2579 r = bus_match_run(bus, &bus->match_callbacks, m);
2580 if (r != 0)
2581 return r;
2582
2583 } while (bus->match_callbacks_modified);
2584
2585 return 0;
2586 }
2587
2588 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2589 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2590 int r;
2591
2592 assert(bus);
2593 assert(m);
2594
2595 if (bus->is_monitor)
2596 return 0;
2597
2598 if (bus->manual_peer_interface)
2599 return 0;
2600
2601 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2602 return 0;
2603
2604 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2605 return 0;
2606
2607 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2608 return 1;
2609
2610 if (streq_ptr(m->member, "Ping"))
2611 r = sd_bus_message_new_method_return(m, &reply);
2612 else if (streq_ptr(m->member, "GetMachineId")) {
2613 sd_id128_t id;
2614 char sid[33];
2615
2616 r = sd_id128_get_machine(&id);
2617 if (r < 0)
2618 return r;
2619
2620 r = sd_bus_message_new_method_return(m, &reply);
2621 if (r < 0)
2622 return r;
2623
2624 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2625 } else {
2626 r = sd_bus_message_new_method_errorf(
2627 m, &reply,
2628 SD_BUS_ERROR_UNKNOWN_METHOD,
2629 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2630 }
2631
2632 if (r < 0)
2633 return r;
2634
2635 r = sd_bus_send(bus, reply, NULL);
2636 if (r < 0)
2637 return r;
2638
2639 return 1;
2640 }
2641
2642 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2643 assert(bus);
2644 assert(m);
2645
2646 /* If we got a message with a file descriptor which we didn't
2647 * want to accept, then let's drop it. How can this even
2648 * happen? For example, when the kernel queues a message into
2649 * an activatable names's queue which allows fds, and then is
2650 * delivered to us later even though we ourselves did not
2651 * negotiate it. */
2652
2653 if (bus->is_monitor)
2654 return 0;
2655
2656 if (m->n_fds <= 0)
2657 return 0;
2658
2659 if (bus->accept_fd)
2660 return 0;
2661
2662 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2663 return 1; /* just eat it up */
2664
2665 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2666 }
2667
2668 static int process_message(sd_bus *bus, sd_bus_message *m) {
2669 int r;
2670
2671 assert(bus);
2672 assert(m);
2673
2674 bus->current_message = m;
2675 bus->iteration_counter++;
2676
2677 log_debug_bus_message(m);
2678
2679 r = process_hello(bus, m);
2680 if (r != 0)
2681 goto finish;
2682
2683 r = process_reply(bus, m);
2684 if (r != 0)
2685 goto finish;
2686
2687 r = process_fd_check(bus, m);
2688 if (r != 0)
2689 goto finish;
2690
2691 r = process_filter(bus, m);
2692 if (r != 0)
2693 goto finish;
2694
2695 r = process_match(bus, m);
2696 if (r != 0)
2697 goto finish;
2698
2699 r = process_builtin(bus, m);
2700 if (r != 0)
2701 goto finish;
2702
2703 r = bus_process_object(bus, m);
2704
2705 finish:
2706 bus->current_message = NULL;
2707 return r;
2708 }
2709
2710 static int dispatch_track(sd_bus *bus) {
2711 assert(bus);
2712
2713 if (!bus->track_queue)
2714 return 0;
2715
2716 bus_track_dispatch(bus->track_queue);
2717 return 1;
2718 }
2719
2720 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2721 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2722 int r;
2723
2724 assert(bus);
2725 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2726
2727 r = process_timeout(bus);
2728 if (r != 0)
2729 goto null_message;
2730
2731 r = dispatch_wqueue(bus);
2732 if (r != 0)
2733 goto null_message;
2734
2735 r = dispatch_track(bus);
2736 if (r != 0)
2737 goto null_message;
2738
2739 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2740 if (r < 0)
2741 return r;
2742 if (!m)
2743 goto null_message;
2744
2745 r = process_message(bus, m);
2746 if (r != 0)
2747 goto null_message;
2748
2749 if (ret) {
2750 r = sd_bus_message_rewind(m, true);
2751 if (r < 0)
2752 return r;
2753
2754 *ret = m;
2755 m = NULL;
2756 return 1;
2757 }
2758
2759 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2760
2761 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2762 strna(sd_bus_message_get_sender(m)),
2763 strna(sd_bus_message_get_path(m)),
2764 strna(sd_bus_message_get_interface(m)),
2765 strna(sd_bus_message_get_member(m)));
2766
2767 r = sd_bus_reply_method_errorf(
2768 m,
2769 SD_BUS_ERROR_UNKNOWN_OBJECT,
2770 "Unknown object '%s'.", m->path);
2771 if (r < 0)
2772 return r;
2773 }
2774
2775 return 1;
2776
2777 null_message:
2778 if (r >= 0 && ret)
2779 *ret = NULL;
2780
2781 return r;
2782 }
2783
2784 static int bus_exit_now(sd_bus *bus) {
2785 assert(bus);
2786
2787 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2788 * sd_event_exit(), otherwise invokes libc exit(). */
2789
2790 if (bus->exited) /* did we already exit? */
2791 return 0;
2792 if (!bus->exit_triggered) /* was the exit condition triggered? */
2793 return 0;
2794 if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2795 return 0;
2796
2797 bus->exited = true; /* never exit more than once */
2798
2799 log_debug("Bus connection disconnected, exiting.");
2800
2801 if (bus->event)
2802 return sd_event_exit(bus->event, EXIT_FAILURE);
2803 else
2804 exit(EXIT_FAILURE);
2805
2806 assert_not_reached("exit() didn't exit?");
2807 }
2808
2809 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2810 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2811 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2812 sd_bus_slot *slot;
2813 int r;
2814
2815 assert(bus);
2816 assert(c);
2817
2818 r = bus_message_new_synthetic_error(
2819 bus,
2820 c->cookie,
2821 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2822 &m);
2823 if (r < 0)
2824 return r;
2825
2826 r = bus_seal_synthetic_message(bus, m);
2827 if (r < 0)
2828 return r;
2829
2830 if (c->timeout_usec != 0) {
2831 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2832 c->timeout_usec = 0;
2833 }
2834
2835 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2836 c->cookie = 0;
2837
2838 slot = container_of(c, sd_bus_slot, reply_callback);
2839
2840 bus->iteration_counter++;
2841
2842 bus->current_message = m;
2843 bus->current_slot = sd_bus_slot_ref(slot);
2844 bus->current_handler = c->callback;
2845 bus->current_userdata = slot->userdata;
2846 r = c->callback(m, slot->userdata, &error_buffer);
2847 bus->current_userdata = NULL;
2848 bus->current_handler = NULL;
2849 bus->current_slot = NULL;
2850 bus->current_message = NULL;
2851
2852 if (slot->floating) {
2853 bus_slot_disconnect(slot);
2854 sd_bus_slot_unref(slot);
2855 }
2856
2857 sd_bus_slot_unref(slot);
2858
2859 return bus_maybe_reply_error(m, r, &error_buffer);
2860 }
2861
2862 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2863 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2864 struct reply_callback *c;
2865 int r;
2866
2867 assert(bus);
2868 assert(bus->state == BUS_CLOSING);
2869
2870 /* First, fail all outstanding method calls */
2871 c = ordered_hashmap_first(bus->reply_callbacks);
2872 if (c)
2873 return process_closing_reply_callback(bus, c);
2874
2875 /* Then, fake-drop all remaining bus tracking references */
2876 if (bus->tracks) {
2877 bus_track_close(bus->tracks);
2878 return 1;
2879 }
2880
2881 /* Then, synthesize a Disconnected message */
2882 r = sd_bus_message_new_signal(
2883 bus,
2884 &m,
2885 "/org/freedesktop/DBus/Local",
2886 "org.freedesktop.DBus.Local",
2887 "Disconnected");
2888 if (r < 0)
2889 return r;
2890
2891 bus_message_set_sender_local(bus, m);
2892
2893 r = bus_seal_synthetic_message(bus, m);
2894 if (r < 0)
2895 return r;
2896
2897 sd_bus_close(bus);
2898
2899 bus->current_message = m;
2900 bus->iteration_counter++;
2901
2902 r = process_filter(bus, m);
2903 if (r != 0)
2904 goto finish;
2905
2906 r = process_match(bus, m);
2907 if (r != 0)
2908 goto finish;
2909
2910 /* Nothing else to do, exit now, if the condition holds */
2911 bus->exit_triggered = true;
2912 (void) bus_exit_now(bus);
2913
2914 if (ret) {
2915 *ret = m;
2916 m = NULL;
2917 }
2918
2919 r = 1;
2920
2921 finish:
2922 bus->current_message = NULL;
2923
2924 return r;
2925 }
2926
2927 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2928 BUS_DONT_DESTROY(bus);
2929 int r;
2930
2931 /* Returns 0 when we didn't do anything. This should cause the
2932 * caller to invoke sd_bus_wait() before returning the next
2933 * time. Returns > 0 when we did something, which possibly
2934 * means *ret is filled in with an unprocessed message. */
2935
2936 assert_return(bus, -EINVAL);
2937 assert_return(bus = bus_resolve(bus), -ENOPKG);
2938 assert_return(!bus_pid_changed(bus), -ECHILD);
2939
2940 /* We don't allow recursively invoking sd_bus_process(). */
2941 assert_return(!bus->current_message, -EBUSY);
2942 assert(!bus->current_slot);
2943
2944 switch (bus->state) {
2945
2946 case BUS_UNSET:
2947 return -ENOTCONN;
2948
2949 case BUS_CLOSED:
2950 return -ECONNRESET;
2951
2952 case BUS_WATCH_BIND:
2953 r = bus_socket_process_watch_bind(bus);
2954 break;
2955
2956 case BUS_OPENING:
2957 r = bus_socket_process_opening(bus);
2958 break;
2959
2960 case BUS_AUTHENTICATING:
2961 r = bus_socket_process_authenticating(bus);
2962 break;
2963
2964 case BUS_RUNNING:
2965 case BUS_HELLO:
2966 r = process_running(bus, hint_priority, priority, ret);
2967 if (r >= 0)
2968 return r;
2969
2970 /* This branch initializes *ret, hence we don't use the generic error checking below */
2971 break;
2972
2973 case BUS_CLOSING:
2974 return process_closing(bus, ret);
2975
2976 default:
2977 assert_not_reached("Unknown state");
2978 }
2979
2980 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2981 bus_enter_closing(bus);
2982 r = 1;
2983 } else if (r < 0)
2984 return r;
2985
2986 if (ret)
2987 *ret = NULL;
2988
2989 return r;
2990 }
2991
2992 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2993 return bus_process_internal(bus, false, 0, ret);
2994 }
2995
2996 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2997 return bus_process_internal(bus, true, priority, ret);
2998 }
2999
3000 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
3001 struct pollfd p[2] = {};
3002 int r, n;
3003 struct timespec ts;
3004 usec_t m = USEC_INFINITY;
3005
3006 assert(bus);
3007
3008 if (bus->state == BUS_CLOSING)
3009 return 1;
3010
3011 if (!BUS_IS_OPEN(bus->state))
3012 return -ENOTCONN;
3013
3014 if (bus->state == BUS_WATCH_BIND) {
3015 assert(bus->inotify_fd >= 0);
3016
3017 p[0].events = POLLIN;
3018 p[0].fd = bus->inotify_fd;
3019 n = 1;
3020 } else {
3021 int e;
3022
3023 e = sd_bus_get_events(bus);
3024 if (e < 0)
3025 return e;
3026
3027 if (need_more)
3028 /* The caller really needs some more data, he doesn't
3029 * care about what's already read, or any timeouts
3030 * except its own. */
3031 e |= POLLIN;
3032 else {
3033 usec_t until;
3034 /* The caller wants to process if there's something to
3035 * process, but doesn't care otherwise */
3036
3037 r = sd_bus_get_timeout(bus, &until);
3038 if (r < 0)
3039 return r;
3040 if (r > 0)
3041 m = usec_sub_unsigned(until, now(CLOCK_MONOTONIC));
3042 }
3043
3044 p[0].fd = bus->input_fd;
3045 if (bus->output_fd == bus->input_fd) {
3046 p[0].events = e;
3047 n = 1;
3048 } else {
3049 p[0].events = e & POLLIN;
3050 p[1].fd = bus->output_fd;
3051 p[1].events = e & POLLOUT;
3052 n = 2;
3053 }
3054 }
3055
3056 if (timeout_usec != (uint64_t) -1 && (m == USEC_INFINITY || timeout_usec < m))
3057 m = timeout_usec;
3058
3059 r = ppoll(p, n, m == USEC_INFINITY ? NULL : timespec_store(&ts, m), NULL);
3060 if (r < 0)
3061 return -errno;
3062
3063 return r > 0 ? 1 : 0;
3064 }
3065
3066 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
3067
3068 assert_return(bus, -EINVAL);
3069 assert_return(bus = bus_resolve(bus), -ENOPKG);
3070 assert_return(!bus_pid_changed(bus), -ECHILD);
3071
3072 if (bus->state == BUS_CLOSING)
3073 return 0;
3074
3075 if (!BUS_IS_OPEN(bus->state))
3076 return -ENOTCONN;
3077
3078 if (bus->rqueue_size > 0)
3079 return 0;
3080
3081 return bus_poll(bus, false, timeout_usec);
3082 }
3083
3084 _public_ int sd_bus_flush(sd_bus *bus) {
3085 int r;
3086
3087 assert_return(bus, -EINVAL);
3088 assert_return(bus = bus_resolve(bus), -ENOPKG);
3089 assert_return(!bus_pid_changed(bus), -ECHILD);
3090
3091 if (bus->state == BUS_CLOSING)
3092 return 0;
3093
3094 if (!BUS_IS_OPEN(bus->state))
3095 return -ENOTCONN;
3096
3097 /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
3098 if (bus->state == BUS_WATCH_BIND)
3099 return -EUNATCH;
3100
3101 r = bus_ensure_running(bus);
3102 if (r < 0)
3103 return r;
3104
3105 if (bus->wqueue_size <= 0)
3106 return 0;
3107
3108 for (;;) {
3109 r = dispatch_wqueue(bus);
3110 if (r < 0) {
3111 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
3112 bus_enter_closing(bus);
3113 return -ECONNRESET;
3114 }
3115
3116 return r;
3117 }
3118
3119 if (bus->wqueue_size <= 0)
3120 return 0;
3121
3122 r = bus_poll(bus, false, (uint64_t) -1);
3123 if (r < 0)
3124 return r;
3125 }
3126 }
3127
3128 _public_ int sd_bus_add_filter(
3129 sd_bus *bus,
3130 sd_bus_slot **slot,
3131 sd_bus_message_handler_t callback,
3132 void *userdata) {
3133
3134 sd_bus_slot *s;
3135
3136 assert_return(bus, -EINVAL);
3137 assert_return(bus = bus_resolve(bus), -ENOPKG);
3138 assert_return(callback, -EINVAL);
3139 assert_return(!bus_pid_changed(bus), -ECHILD);
3140
3141 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
3142 if (!s)
3143 return -ENOMEM;
3144
3145 s->filter_callback.callback = callback;
3146
3147 bus->filter_callbacks_modified = true;
3148 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
3149
3150 if (slot)
3151 *slot = s;
3152
3153 return 0;
3154 }
3155
3156 static int add_match_callback(
3157 sd_bus_message *m,
3158 void *userdata,
3159 sd_bus_error *ret_error) {
3160
3161 sd_bus_slot *match_slot = userdata;
3162 bool failed = false;
3163 int r;
3164
3165 assert(m);
3166 assert(match_slot);
3167
3168 sd_bus_slot_ref(match_slot);
3169
3170 if (sd_bus_message_is_method_error(m, NULL)) {
3171 log_debug_errno(sd_bus_message_get_errno(m),
3172 "Unable to add match %s, failing connection: %s",
3173 match_slot->match_callback.match_string,
3174 sd_bus_message_get_error(m)->message);
3175
3176 failed = true;
3177 } else
3178 log_debug("Match %s successfully installed.", match_slot->match_callback.match_string);
3179
3180 if (match_slot->match_callback.install_callback) {
3181 sd_bus *bus;
3182
3183 bus = sd_bus_message_get_bus(m);
3184
3185 /* This function has been called as slot handler, and we want to call another slot handler. Let's
3186 * update the slot callback metadata temporarily with our own data, and then revert back to the old
3187 * values. */
3188
3189 assert(bus->current_slot == match_slot->match_callback.install_slot);
3190 assert(bus->current_handler == add_match_callback);
3191 assert(bus->current_userdata == userdata);
3192
3193 bus->current_slot = match_slot;
3194 bus->current_handler = match_slot->match_callback.install_callback;
3195 bus->current_userdata = match_slot->userdata;
3196
3197 r = match_slot->match_callback.install_callback(m, match_slot->userdata, ret_error);
3198
3199 bus->current_slot = match_slot->match_callback.install_slot;
3200 bus->current_handler = add_match_callback;
3201 bus->current_userdata = userdata;
3202
3203 match_slot->match_callback.install_slot = sd_bus_slot_unref(match_slot->match_callback.install_slot);
3204 } else {
3205 if (failed) /* Generic failure handling: destroy the connection */
3206 bus_enter_closing(sd_bus_message_get_bus(m));
3207
3208 r = 1;
3209 }
3210
3211 if (failed && match_slot->floating) {
3212 bus_slot_disconnect(match_slot);
3213 sd_bus_slot_unref(match_slot);
3214 }
3215
3216 sd_bus_slot_unref(match_slot);
3217
3218 return r;
3219 }
3220
3221 static int bus_add_match_full(
3222 sd_bus *bus,
3223 sd_bus_slot **slot,
3224 bool asynchronous,
3225 const char *match,
3226 sd_bus_message_handler_t callback,
3227 sd_bus_message_handler_t install_callback,
3228 void *userdata) {
3229
3230 struct bus_match_component *components = NULL;
3231 unsigned n_components = 0;
3232 sd_bus_slot *s = NULL;
3233 int r = 0;
3234
3235 assert_return(bus, -EINVAL);
3236 assert_return(bus = bus_resolve(bus), -ENOPKG);
3237 assert_return(match, -EINVAL);
3238 assert_return(!bus_pid_changed(bus), -ECHILD);
3239
3240 r = bus_match_parse(match, &components, &n_components);
3241 if (r < 0)
3242 goto finish;
3243
3244 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3245 if (!s) {
3246 r = -ENOMEM;
3247 goto finish;
3248 }
3249
3250 s->match_callback.callback = callback;
3251 s->match_callback.install_callback = install_callback;
3252
3253 if (bus->bus_client) {
3254 enum bus_match_scope scope;
3255
3256 scope = bus_match_get_scope(components, n_components);
3257
3258 /* Do not install server-side matches for matches against the local service, interface or bus path. */
3259 if (scope != BUS_MATCH_LOCAL) {
3260
3261 /* We store the original match string, so that we can use it to remove the match again. */
3262
3263 s->match_callback.match_string = strdup(match);
3264 if (!s->match_callback.match_string) {
3265 r = -ENOMEM;
3266 goto finish;
3267 }
3268
3269 if (asynchronous)
3270 r = bus_add_match_internal_async(bus,
3271 &s->match_callback.install_slot,
3272 s->match_callback.match_string,
3273 add_match_callback,
3274 s);
3275 else
3276 r = bus_add_match_internal(bus, s->match_callback.match_string);
3277 if (r < 0)
3278 goto finish;
3279
3280 s->match_added = true;
3281 }
3282 }
3283
3284 bus->match_callbacks_modified = true;
3285 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3286 if (r < 0)
3287 goto finish;
3288
3289 if (slot)
3290 *slot = s;
3291 s = NULL;
3292
3293 finish:
3294 bus_match_parse_free(components, n_components);
3295 sd_bus_slot_unref(s);
3296
3297 return r;
3298 }
3299
3300 _public_ int sd_bus_add_match(
3301 sd_bus *bus,
3302 sd_bus_slot **slot,
3303 const char *match,
3304 sd_bus_message_handler_t callback,
3305 void *userdata) {
3306
3307 return bus_add_match_full(bus, slot, false, match, callback, NULL, userdata);
3308 }
3309
3310 _public_ int sd_bus_add_match_async(
3311 sd_bus *bus,
3312 sd_bus_slot **slot,
3313 const char *match,
3314 sd_bus_message_handler_t callback,
3315 sd_bus_message_handler_t install_callback,
3316 void *userdata) {
3317
3318 return bus_add_match_full(bus, slot, true, match, callback, install_callback, userdata);
3319 }
3320
3321 bool bus_pid_changed(sd_bus *bus) {
3322 assert(bus);
3323
3324 /* We don't support people creating a bus connection and
3325 * keeping it around over a fork(). Let's complain. */
3326
3327 return bus->original_pid != getpid_cached();
3328 }
3329
3330 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3331 sd_bus *bus = userdata;
3332 int r;
3333
3334 assert(bus);
3335
3336 /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3337
3338 r = sd_bus_process(bus, NULL);
3339 if (r < 0) {
3340 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3341 bus_enter_closing(bus);
3342 }
3343
3344 return 1;
3345 }
3346
3347 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3348 sd_bus *bus = userdata;
3349 int r;
3350
3351 assert(bus);
3352
3353 r = sd_bus_process(bus, NULL);
3354 if (r < 0) {
3355 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3356 bus_enter_closing(bus);
3357 }
3358
3359 return 1;
3360 }
3361
3362 static int prepare_callback(sd_event_source *s, void *userdata) {
3363 sd_bus *bus = userdata;
3364 int r, e;
3365 usec_t until;
3366
3367 assert(s);
3368 assert(bus);
3369
3370 e = sd_bus_get_events(bus);
3371 if (e < 0) {
3372 r = e;
3373 goto fail;
3374 }
3375
3376 if (bus->output_fd != bus->input_fd) {
3377
3378 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3379 if (r < 0)
3380 goto fail;
3381
3382 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3383 } else
3384 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3385 if (r < 0)
3386 goto fail;
3387
3388 r = sd_bus_get_timeout(bus, &until);
3389 if (r < 0)
3390 goto fail;
3391 if (r > 0) {
3392 int j;
3393
3394 j = sd_event_source_set_time(bus->time_event_source, until);
3395 if (j < 0) {
3396 r = j;
3397 goto fail;
3398 }
3399 }
3400
3401 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3402 if (r < 0)
3403 goto fail;
3404
3405 return 1;
3406
3407 fail:
3408 log_debug_errno(r, "Preparing of bus events failed, closing down: %m");
3409 bus_enter_closing(bus);
3410
3411 return 1;
3412 }
3413
3414 static int quit_callback(sd_event_source *event, void *userdata) {
3415 sd_bus *bus = userdata;
3416
3417 assert(event);
3418
3419 sd_bus_flush(bus);
3420 sd_bus_close(bus);
3421
3422 return 1;
3423 }
3424
3425 int bus_attach_io_events(sd_bus *bus) {
3426 int r;
3427
3428 assert(bus);
3429
3430 if (bus->input_fd < 0)
3431 return 0;
3432
3433 if (!bus->event)
3434 return 0;
3435
3436 if (!bus->input_io_event_source) {
3437 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3438 if (r < 0)
3439 return r;
3440
3441 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3442 if (r < 0)
3443 return r;
3444
3445 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3446 if (r < 0)
3447 return r;
3448
3449 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3450 } else
3451 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3452
3453 if (r < 0)
3454 return r;
3455
3456 if (bus->output_fd != bus->input_fd) {
3457 assert(bus->output_fd >= 0);
3458
3459 if (!bus->output_io_event_source) {
3460 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3461 if (r < 0)
3462 return r;
3463
3464 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3465 if (r < 0)
3466 return r;
3467
3468 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3469 } else
3470 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3471
3472 if (r < 0)
3473 return r;
3474 }
3475
3476 return 0;
3477 }
3478
3479 static void bus_detach_io_events(sd_bus *bus) {
3480 assert(bus);
3481
3482 if (bus->input_io_event_source) {
3483 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3484 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3485 }
3486
3487 if (bus->output_io_event_source) {
3488 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3489 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3490 }
3491 }
3492
3493 int bus_attach_inotify_event(sd_bus *bus) {
3494 int r;
3495
3496 assert(bus);
3497
3498 if (bus->inotify_fd < 0)
3499 return 0;
3500
3501 if (!bus->event)
3502 return 0;
3503
3504 if (!bus->inotify_event_source) {
3505 r = sd_event_add_io(bus->event, &bus->inotify_event_source, bus->inotify_fd, EPOLLIN, io_callback, bus);
3506 if (r < 0)
3507 return r;
3508
3509 r = sd_event_source_set_priority(bus->inotify_event_source, bus->event_priority);
3510 if (r < 0)
3511 return r;
3512
3513 r = sd_event_source_set_description(bus->inotify_event_source, "bus-inotify");
3514 } else
3515 r = sd_event_source_set_io_fd(bus->inotify_event_source, bus->inotify_fd);
3516 if (r < 0)
3517 return r;
3518
3519 return 0;
3520 }
3521
3522 static void bus_detach_inotify_event(sd_bus *bus) {
3523 assert(bus);
3524
3525 if (bus->inotify_event_source) {
3526 sd_event_source_set_enabled(bus->inotify_event_source, SD_EVENT_OFF);
3527 bus->inotify_event_source = sd_event_source_unref(bus->inotify_event_source);
3528 }
3529 }
3530
3531 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3532 int r;
3533
3534 assert_return(bus, -EINVAL);
3535 assert_return(bus = bus_resolve(bus), -ENOPKG);
3536 assert_return(!bus->event, -EBUSY);
3537
3538 assert(!bus->input_io_event_source);
3539 assert(!bus->output_io_event_source);
3540 assert(!bus->time_event_source);
3541
3542 if (event)
3543 bus->event = sd_event_ref(event);
3544 else {
3545 r = sd_event_default(&bus->event);
3546 if (r < 0)
3547 return r;
3548 }
3549
3550 bus->event_priority = priority;
3551
3552 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3553 if (r < 0)
3554 goto fail;
3555
3556 r = sd_event_source_set_priority(bus->time_event_source, priority);
3557 if (r < 0)
3558 goto fail;
3559
3560 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3561 if (r < 0)
3562 goto fail;
3563
3564 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3565 if (r < 0)
3566 goto fail;
3567
3568 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3569 if (r < 0)
3570 goto fail;
3571
3572 r = bus_attach_io_events(bus);
3573 if (r < 0)
3574 goto fail;
3575
3576 r = bus_attach_inotify_event(bus);
3577 if (r < 0)
3578 goto fail;
3579
3580 return 0;
3581
3582 fail:
3583 sd_bus_detach_event(bus);
3584 return r;
3585 }
3586
3587 _public_ int sd_bus_detach_event(sd_bus *bus) {
3588 assert_return(bus, -EINVAL);
3589 assert_return(bus = bus_resolve(bus), -ENOPKG);
3590
3591 if (!bus->event)
3592 return 0;
3593
3594 bus_detach_io_events(bus);
3595 bus_detach_inotify_event(bus);
3596
3597 if (bus->time_event_source) {
3598 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3599 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3600 }
3601
3602 if (bus->quit_event_source) {
3603 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3604 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3605 }
3606
3607 bus->event = sd_event_unref(bus->event);
3608 return 1;
3609 }
3610
3611 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3612 assert_return(bus, NULL);
3613
3614 return bus->event;
3615 }
3616
3617 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3618 assert_return(bus, NULL);
3619
3620 return bus->current_message;
3621 }
3622
3623 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3624 assert_return(bus, NULL);
3625
3626 return bus->current_slot;
3627 }
3628
3629 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3630 assert_return(bus, NULL);
3631
3632 return bus->current_handler;
3633 }
3634
3635 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3636 assert_return(bus, NULL);
3637
3638 return bus->current_userdata;
3639 }
3640
3641 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3642 sd_bus *b = NULL;
3643 int r;
3644
3645 assert(bus_open);
3646 assert(default_bus);
3647
3648 if (!ret)
3649 return !!*default_bus;
3650
3651 if (*default_bus) {
3652 *ret = sd_bus_ref(*default_bus);
3653 return 0;
3654 }
3655
3656 r = bus_open(&b);
3657 if (r < 0)
3658 return r;
3659
3660 b->default_bus_ptr = default_bus;
3661 b->tid = gettid();
3662 *default_bus = b;
3663
3664 *ret = b;
3665 return 1;
3666 }
3667
3668 _public_ int sd_bus_default_system(sd_bus **ret) {
3669 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3670 }
3671
3672
3673 _public_ int sd_bus_default_user(sd_bus **ret) {
3674 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3675 }
3676
3677 _public_ int sd_bus_default(sd_bus **ret) {
3678 int (*bus_open)(sd_bus **) = NULL;
3679 sd_bus **busp;
3680
3681 busp = bus_choose_default(&bus_open);
3682 return bus_default(bus_open, busp, ret);
3683 }
3684
3685 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3686 assert_return(b, -EINVAL);
3687 assert_return(tid, -EINVAL);
3688 assert_return(!bus_pid_changed(b), -ECHILD);
3689
3690 if (b->tid != 0) {
3691 *tid = b->tid;
3692 return 0;
3693 }
3694
3695 if (b->event)
3696 return sd_event_get_tid(b->event, tid);
3697
3698 return -ENXIO;
3699 }
3700
3701 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3702 _cleanup_free_ char *e = NULL;
3703 char *ret;
3704
3705 assert_return(object_path_is_valid(prefix), -EINVAL);
3706 assert_return(external_id, -EINVAL);
3707 assert_return(ret_path, -EINVAL);
3708
3709 e = bus_label_escape(external_id);
3710 if (!e)
3711 return -ENOMEM;
3712
3713 ret = strjoin(prefix, "/", e);
3714 if (!ret)
3715 return -ENOMEM;
3716
3717 *ret_path = ret;
3718 return 0;
3719 }
3720
3721 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3722 const char *e;
3723 char *ret;
3724
3725 assert_return(object_path_is_valid(path), -EINVAL);
3726 assert_return(object_path_is_valid(prefix), -EINVAL);
3727 assert_return(external_id, -EINVAL);
3728
3729 e = object_path_startswith(path, prefix);
3730 if (!e) {
3731 *external_id = NULL;
3732 return 0;
3733 }
3734
3735 ret = bus_label_unescape(e);
3736 if (!ret)
3737 return -ENOMEM;
3738
3739 *external_id = ret;
3740 return 1;
3741 }
3742
3743 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3744 _cleanup_strv_free_ char **labels = NULL;
3745 char *path, *path_pos, **label_pos;
3746 const char *sep, *template_pos;
3747 size_t path_length;
3748 va_list list;
3749 int r;
3750
3751 assert_return(out, -EINVAL);
3752 assert_return(path_template, -EINVAL);
3753
3754 path_length = strlen(path_template);
3755
3756 va_start(list, path_template);
3757 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3758 const char *arg;
3759 char *label;
3760
3761 arg = va_arg(list, const char *);
3762 if (!arg) {
3763 va_end(list);
3764 return -EINVAL;
3765 }
3766
3767 label = bus_label_escape(arg);
3768 if (!label) {
3769 va_end(list);
3770 return -ENOMEM;
3771 }
3772
3773 r = strv_consume(&labels, label);
3774 if (r < 0) {
3775 va_end(list);
3776 return r;
3777 }
3778
3779 /* add label length, but account for the format character */
3780 path_length += strlen(label) - 1;
3781 }
3782 va_end(list);
3783
3784 path = malloc(path_length + 1);
3785 if (!path)
3786 return -ENOMEM;
3787
3788 path_pos = path;
3789 label_pos = labels;
3790
3791 for (template_pos = path_template; *template_pos; ) {
3792 sep = strchrnul(template_pos, '%');
3793 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3794 if (!*sep)
3795 break;
3796
3797 path_pos = stpcpy(path_pos, *label_pos++);
3798 template_pos = sep + 1;
3799 }
3800
3801 *path_pos = 0;
3802 *out = path;
3803 return 0;
3804 }
3805
3806 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3807 _cleanup_strv_free_ char **labels = NULL;
3808 const char *template_pos, *path_pos;
3809 char **label_pos;
3810 va_list list;
3811 int r;
3812
3813 /*
3814 * This decodes an object-path based on a template argument. The
3815 * template consists of a verbatim path, optionally including special
3816 * directives:
3817 *
3818 * - Each occurrence of '%' in the template matches an arbitrary
3819 * substring of a label in the given path. At most one such
3820 * directive is allowed per label. For each such directive, the
3821 * caller must provide an output parameter (char **) via va_arg. If
3822 * NULL is passed, the given label is verified, but not returned.
3823 * For each matched label, the *decoded* label is stored in the
3824 * passed output argument, and the caller is responsible to free
3825 * it. Note that the output arguments are only modified if the
3826 * actualy path matched the template. Otherwise, they're left
3827 * untouched.
3828 *
3829 * This function returns <0 on error, 0 if the path does not match the
3830 * template, 1 if it matched.
3831 */
3832
3833 assert_return(path, -EINVAL);
3834 assert_return(path_template, -EINVAL);
3835
3836 path_pos = path;
3837
3838 for (template_pos = path_template; *template_pos; ) {
3839 const char *sep;
3840 size_t length;
3841 char *label;
3842
3843 /* verify everything until the next '%' matches verbatim */
3844 sep = strchrnul(template_pos, '%');
3845 length = sep - template_pos;
3846 if (strncmp(path_pos, template_pos, length))
3847 return 0;
3848
3849 path_pos += length;
3850 template_pos += length;
3851
3852 if (!*template_pos)
3853 break;
3854
3855 /* We found the next '%' character. Everything up until here
3856 * matched. We now skip ahead to the end of this label and make
3857 * sure it matches the tail of the label in the path. Then we
3858 * decode the string in-between and save it for later use. */
3859
3860 ++template_pos; /* skip over '%' */
3861
3862 sep = strchrnul(template_pos, '/');
3863 length = sep - template_pos; /* length of suffix to match verbatim */
3864
3865 /* verify the suffixes match */
3866 sep = strchrnul(path_pos, '/');
3867 if (sep - path_pos < (ssize_t)length ||
3868 strncmp(sep - length, template_pos, length))
3869 return 0;
3870
3871 template_pos += length; /* skip over matched label */
3872 length = sep - path_pos - length; /* length of sub-label to decode */
3873
3874 /* store unescaped label for later use */
3875 label = bus_label_unescape_n(path_pos, length);
3876 if (!label)
3877 return -ENOMEM;
3878
3879 r = strv_consume(&labels, label);
3880 if (r < 0)
3881 return r;
3882
3883 path_pos = sep; /* skip decoded label and suffix */
3884 }
3885
3886 /* end of template must match end of path */
3887 if (*path_pos)
3888 return 0;
3889
3890 /* copy the labels over to the caller */
3891 va_start(list, path_template);
3892 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3893 char **arg;
3894
3895 arg = va_arg(list, char **);
3896 if (arg)
3897 *arg = *label_pos;
3898 else
3899 free(*label_pos);
3900 }
3901 va_end(list);
3902
3903 labels = mfree(labels);
3904 return 1;
3905 }
3906
3907 _public_ int sd_bus_try_close(sd_bus *bus) {
3908 assert_return(bus, -EINVAL);
3909 assert_return(bus = bus_resolve(bus), -ENOPKG);
3910 assert_return(!bus_pid_changed(bus), -ECHILD);
3911
3912 return -EOPNOTSUPP;
3913 }
3914
3915 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3916 assert_return(bus, -EINVAL);
3917 assert_return(bus = bus_resolve(bus), -ENOPKG);
3918 assert_return(description, -EINVAL);
3919 assert_return(bus->description, -ENXIO);
3920 assert_return(!bus_pid_changed(bus), -ECHILD);
3921
3922 if (bus->description)
3923 *description = bus->description;
3924 else if (bus->is_system)
3925 *description = "system";
3926 else if (bus->is_user)
3927 *description = "user";
3928 else
3929 *description = NULL;
3930
3931 return 0;
3932 }
3933
3934 int bus_get_root_path(sd_bus *bus) {
3935 int r;
3936
3937 if (bus->cgroup_root)
3938 return 0;
3939
3940 r = cg_get_root_path(&bus->cgroup_root);
3941 if (r == -ENOENT) {
3942 bus->cgroup_root = strdup("/");
3943 if (!bus->cgroup_root)
3944 return -ENOMEM;
3945
3946 r = 0;
3947 }
3948
3949 return r;
3950 }
3951
3952 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3953 assert_return(bus, -EINVAL);
3954 assert_return(bus = bus_resolve(bus), -ENOPKG);
3955 assert_return(scope, -EINVAL);
3956 assert_return(!bus_pid_changed(bus), -ECHILD);
3957
3958 if (bus->is_user) {
3959 *scope = "user";
3960 return 0;
3961 }
3962
3963 if (bus->is_system) {
3964 *scope = "system";
3965 return 0;
3966 }
3967
3968 return -ENODATA;
3969 }
3970
3971 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3972
3973 assert_return(bus, -EINVAL);
3974 assert_return(bus = bus_resolve(bus), -ENOPKG);
3975 assert_return(address, -EINVAL);
3976 assert_return(!bus_pid_changed(bus), -ECHILD);
3977
3978 if (bus->address) {
3979 *address = bus->address;
3980 return 0;
3981 }
3982
3983 return -ENODATA;
3984 }
3985
3986 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3987 assert_return(bus, -EINVAL);
3988 assert_return(bus = bus_resolve(bus), -ENOPKG);
3989 assert_return(mask, -EINVAL);
3990 assert_return(!bus_pid_changed(bus), -ECHILD);
3991
3992 *mask = bus->creds_mask;
3993 return 0;
3994 }
3995
3996 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3997 assert_return(bus, -EINVAL);
3998 assert_return(bus = bus_resolve(bus), -ENOPKG);
3999 assert_return(!bus_pid_changed(bus), -ECHILD);
4000
4001 return bus->bus_client;
4002 }
4003
4004 _public_ int sd_bus_is_server(sd_bus *bus) {
4005 assert_return(bus, -EINVAL);
4006 assert_return(bus = bus_resolve(bus), -ENOPKG);
4007 assert_return(!bus_pid_changed(bus), -ECHILD);
4008
4009 return bus->is_server;
4010 }
4011
4012 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
4013 assert_return(bus, -EINVAL);
4014 assert_return(bus = bus_resolve(bus), -ENOPKG);
4015 assert_return(!bus_pid_changed(bus), -ECHILD);
4016
4017 return bus->anonymous_auth;
4018 }
4019
4020 _public_ int sd_bus_is_trusted(sd_bus *bus) {
4021 assert_return(bus, -EINVAL);
4022 assert_return(bus = bus_resolve(bus), -ENOPKG);
4023 assert_return(!bus_pid_changed(bus), -ECHILD);
4024
4025 return bus->trusted;
4026 }
4027
4028 _public_ int sd_bus_is_monitor(sd_bus *bus) {
4029 assert_return(bus, -EINVAL);
4030 assert_return(bus = bus_resolve(bus), -ENOPKG);
4031 assert_return(!bus_pid_changed(bus), -ECHILD);
4032
4033 return bus->is_monitor;
4034 }
4035
4036 static void flush_close(sd_bus *bus) {
4037 if (!bus)
4038 return;
4039
4040 /* Flushes and closes the specified bus. We take a ref before,
4041 * to ensure the flushing does not cause the bus to be
4042 * unreferenced. */
4043
4044 sd_bus_flush_close_unref(sd_bus_ref(bus));
4045 }
4046
4047 _public_ void sd_bus_default_flush_close(void) {
4048 flush_close(default_starter_bus);
4049 flush_close(default_user_bus);
4050 flush_close(default_system_bus);
4051 }
4052
4053 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
4054 assert_return(bus, -EINVAL);
4055 assert_return(bus = bus_resolve(bus), -ENOPKG);
4056
4057 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
4058 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
4059 * from the client side. */
4060 bus->exit_on_disconnect = b;
4061
4062 /* If the exit condition was triggered already, exit immediately. */
4063 return bus_exit_now(bus);
4064 }
4065
4066 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
4067 assert_return(bus, -EINVAL);
4068 assert_return(bus = bus_resolve(bus), -ENOPKG);
4069
4070 return bus->exit_on_disconnect;
4071 }
4072
4073 _public_ int sd_bus_set_sender(sd_bus *bus, const char *sender) {
4074 assert_return(bus, -EINVAL);
4075 assert_return(bus = bus_resolve(bus), -ENOPKG);
4076 assert_return(!bus->bus_client, -EPERM);
4077 assert_return(!sender || service_name_is_valid(sender), -EINVAL);
4078
4079 return free_and_strdup(&bus->patch_sender, sender);
4080 }
4081
4082 _public_ int sd_bus_get_sender(sd_bus *bus, const char **ret) {
4083 assert_return(bus, -EINVAL);
4084 assert_return(bus = bus_resolve(bus), -ENOPKG);
4085 assert_return(ret, -EINVAL);
4086
4087 if (!bus->patch_sender)
4088 return -ENODATA;
4089
4090 *ret = bus->patch_sender;
4091 return 0;
4092 }
4093
4094 _public_ int sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret) {
4095 assert_return(bus, -EINVAL);
4096 assert_return(bus = bus_resolve(bus), -ENOPKG);
4097 assert_return(!bus_pid_changed(bus), -ECHILD);
4098 assert_return(ret, -EINVAL);
4099
4100 *ret = bus->rqueue_size;
4101 return 0;
4102 }
4103
4104 _public_ int sd_bus_get_n_queued_write(sd_bus *bus, uint64_t *ret) {
4105 assert_return(bus, -EINVAL);
4106 assert_return(bus = bus_resolve(bus), -ENOPKG);
4107 assert_return(!bus_pid_changed(bus), -ECHILD);
4108 assert_return(ret, -EINVAL);
4109
4110 *ret = bus->wqueue_size;
4111 return 0;
4112 }
Unnamed repository; edit this file 'description' to name the repository.