]> 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
Merge pull request #8083 from shawnl/close-ssh
[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 = s;
1346 s = NULL;
1347
1348 return 0;
1349 }
1350
1351 _public_ int sd_bus_open_user(sd_bus **ret) {
1352 sd_bus *b;
1353 int r;
1354
1355 assert_return(ret, -EINVAL);
1356
1357 r = sd_bus_new(&b);
1358 if (r < 0)
1359 return r;
1360
1361 r = bus_set_address_user(b);
1362 if (r < 0)
1363 goto fail;
1364
1365 b->bus_client = true;
1366 b->is_user = true;
1367
1368 /* We don't do any per-method access control on the user
1369 * bus. */
1370 b->trusted = true;
1371 b->is_local = true;
1372
1373 r = sd_bus_start(b);
1374 if (r < 0)
1375 goto fail;
1376
1377 *ret = b;
1378 return 0;
1379
1380 fail:
1381 bus_free(b);
1382 return r;
1383 }
1384
1385 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1386 _cleanup_free_ char *e = NULL;
1387 char *m = NULL, *c = NULL, *a;
1388
1389 assert(b);
1390 assert(host);
1391
1392 /* Let's see if we shall enter some container */
1393 m = strchr(host, ':');
1394 if (m) {
1395 m++;
1396
1397 /* Let's make sure this is not a port of some kind,
1398 * and is a valid machine name. */
1399 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1400 char *t;
1401
1402 /* Cut out the host part */
1403 t = strndupa(host, m - host - 1);
1404 e = bus_address_escape(t);
1405 if (!e)
1406 return -ENOMEM;
1407
1408 c = strjoina(",argv5=--machine=", m);
1409 }
1410 }
1411
1412 if (!e) {
1413 e = bus_address_escape(host);
1414 if (!e)
1415 return -ENOMEM;
1416 }
1417
1418 a = strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e, ",argv4=systemd-stdio-bridge", c);
1419 if (!a)
1420 return -ENOMEM;
1421
1422 free_and_replace(b->address, a);
1423
1424 return 0;
1425 }
1426
1427 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1428 sd_bus *bus;
1429 int r;
1430
1431 assert_return(host, -EINVAL);
1432 assert_return(ret, -EINVAL);
1433
1434 r = sd_bus_new(&bus);
1435 if (r < 0)
1436 return r;
1437
1438 r = bus_set_address_system_remote(bus, host);
1439 if (r < 0)
1440 goto fail;
1441
1442 bus->bus_client = true;
1443 bus->trusted = false;
1444 bus->is_system = true;
1445 bus->is_local = false;
1446
1447 r = sd_bus_start(bus);
1448 if (r < 0)
1449 goto fail;
1450
1451 *ret = bus;
1452 return 0;
1453
1454 fail:
1455 bus_free(bus);
1456 return r;
1457 }
1458
1459 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1460 _cleanup_free_ char *e = NULL;
1461 char *a;
1462
1463 assert(b);
1464 assert(machine);
1465
1466 e = bus_address_escape(machine);
1467 if (!e)
1468 return -ENOMEM;
1469
1470 a = strjoin("x-machine-unix:machine=", e);
1471 if (!a)
1472 return -ENOMEM;
1473
1474 free_and_replace(b->address, a);
1475
1476 return 0;
1477 }
1478
1479 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1480 sd_bus *bus;
1481 int r;
1482
1483 assert_return(machine, -EINVAL);
1484 assert_return(ret, -EINVAL);
1485 assert_return(machine_name_is_valid(machine), -EINVAL);
1486
1487 r = sd_bus_new(&bus);
1488 if (r < 0)
1489 return r;
1490
1491 r = bus_set_address_system_machine(bus, machine);
1492 if (r < 0)
1493 goto fail;
1494
1495 bus->bus_client = true;
1496 bus->trusted = false;
1497 bus->is_system = true;
1498 bus->is_local = false;
1499
1500 r = sd_bus_start(bus);
1501 if (r < 0)
1502 goto fail;
1503
1504 *ret = bus;
1505 return 0;
1506
1507 fail:
1508 bus_free(bus);
1509 return r;
1510 }
1511
1512 _public_ void sd_bus_close(sd_bus *bus) {
1513
1514 if (!bus)
1515 return;
1516 if (bus->state == BUS_CLOSED)
1517 return;
1518 if (bus_pid_changed(bus))
1519 return;
1520
1521 /* Don't leave ssh hanging around */
1522 bus_kill_exec(bus);
1523
1524 bus_set_state(bus, BUS_CLOSED);
1525
1526 sd_bus_detach_event(bus);
1527
1528 /* Drop all queued messages so that they drop references to
1529 * the bus object and the bus may be freed */
1530 bus_reset_queues(bus);
1531
1532 bus_close_io_fds(bus);
1533 bus_close_inotify_fd(bus);
1534 }
1535
1536 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1537
1538 if (!bus)
1539 return NULL;
1540
1541 /* Have to do this before flush() to prevent hang */
1542 bus_kill_exec(bus);
1543
1544 sd_bus_flush(bus);
1545 sd_bus_close(bus);
1546
1547 return sd_bus_unref(bus);
1548 }
1549
1550 void bus_enter_closing(sd_bus *bus) {
1551 assert(bus);
1552
1553 if (!IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING))
1554 return;
1555
1556 bus_set_state(bus, BUS_CLOSING);
1557 }
1558
1559 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1560
1561 if (!bus)
1562 return NULL;
1563
1564 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1565
1566 return bus;
1567 }
1568
1569 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1570 unsigned i;
1571
1572 if (!bus)
1573 return NULL;
1574
1575 i = REFCNT_DEC(bus->n_ref);
1576 if (i > 0)
1577 return NULL;
1578
1579 bus_free(bus);
1580 return NULL;
1581 }
1582
1583 _public_ int sd_bus_is_open(sd_bus *bus) {
1584
1585 assert_return(bus, -EINVAL);
1586 assert_return(bus = bus_resolve(bus), -ENOPKG);
1587 assert_return(!bus_pid_changed(bus), -ECHILD);
1588
1589 return BUS_IS_OPEN(bus->state);
1590 }
1591
1592 _public_ int sd_bus_is_ready(sd_bus *bus) {
1593 assert_return(bus, -EINVAL);
1594 assert_return(bus = bus_resolve(bus), -ENOPKG);
1595 assert_return(!bus_pid_changed(bus), -ECHILD);
1596
1597 return bus->state == BUS_RUNNING;
1598 }
1599
1600 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1601 int r;
1602
1603 assert_return(bus, -EINVAL);
1604 assert_return(bus = bus_resolve(bus), -ENOPKG);
1605 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1606 assert_return(!bus_pid_changed(bus), -ECHILD);
1607
1608 if (bus->is_monitor)
1609 return 0;
1610
1611 if (type == SD_BUS_TYPE_UNIX_FD) {
1612 if (!bus->accept_fd)
1613 return 0;
1614
1615 r = bus_ensure_running(bus);
1616 if (r < 0)
1617 return r;
1618
1619 return bus->can_fds;
1620 }
1621
1622 return bus_type_is_valid(type);
1623 }
1624
1625 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1626 int r;
1627
1628 assert_return(bus, -EINVAL);
1629 assert_return(bus = bus_resolve(bus), -ENOPKG);
1630 assert_return(id, -EINVAL);
1631 assert_return(!bus_pid_changed(bus), -ECHILD);
1632
1633 r = bus_ensure_running(bus);
1634 if (r < 0)
1635 return r;
1636
1637 *id = bus->server_id;
1638 return 0;
1639 }
1640
1641 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1642 int r;
1643
1644 assert(b);
1645 assert(m);
1646
1647 if (m->sealed) {
1648 /* If we copy the same message to multiple
1649 * destinations, avoid using the same cookie
1650 * numbers. */
1651 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1652 return 0;
1653 }
1654
1655 if (timeout == 0)
1656 timeout = BUS_DEFAULT_TIMEOUT;
1657
1658 if (!m->sender && b->patch_sender) {
1659 r = sd_bus_message_set_sender(m, b->patch_sender);
1660 if (r < 0)
1661 return r;
1662 }
1663
1664 return sd_bus_message_seal(m, ++b->cookie, timeout);
1665 }
1666
1667 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1668 bool remarshal = false;
1669
1670 assert(b);
1671
1672 /* wrong packet version */
1673 if (b->message_version != 0 && b->message_version != (*m)->header->version)
1674 remarshal = true;
1675
1676 /* wrong packet endianness */
1677 if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1678 remarshal = true;
1679
1680 return remarshal ? bus_message_remarshal(b, m) : 0;
1681 }
1682
1683 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1684 assert(b);
1685 assert(m);
1686
1687 /* Fake some timestamps, if they were requested, and not
1688 * already initialized */
1689 if (b->attach_timestamp) {
1690 if (m->realtime <= 0)
1691 m->realtime = now(CLOCK_REALTIME);
1692
1693 if (m->monotonic <= 0)
1694 m->monotonic = now(CLOCK_MONOTONIC);
1695 }
1696
1697 /* The bus specification says the serial number cannot be 0,
1698 * hence let's fill something in for synthetic messages. Since
1699 * synthetic messages might have a fake sender and we don't
1700 * want to interfere with the real sender's serial numbers we
1701 * pick a fixed, artificial one. We use (uint32_t) -1 rather
1702 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1703 * even though kdbus can do 64bit. */
1704 return sd_bus_message_seal(m, 0xFFFFFFFFULL, 0);
1705 }
1706
1707 static int bus_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
1708 int r;
1709
1710 assert(bus);
1711 assert(m);
1712
1713 r = bus_socket_write_message(bus, m, idx);
1714 if (r <= 0)
1715 return r;
1716
1717 if (*idx >= BUS_MESSAGE_SIZE(m))
1718 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",
1719 bus_message_type_to_string(m->header->type),
1720 strna(sd_bus_message_get_sender(m)),
1721 strna(sd_bus_message_get_destination(m)),
1722 strna(sd_bus_message_get_path(m)),
1723 strna(sd_bus_message_get_interface(m)),
1724 strna(sd_bus_message_get_member(m)),
1725 BUS_MESSAGE_COOKIE(m),
1726 m->reply_cookie,
1727 strna(m->root_container.signature),
1728 strna(m->error.name),
1729 strna(m->error.message));
1730
1731 return r;
1732 }
1733
1734 static int dispatch_wqueue(sd_bus *bus) {
1735 int r, ret = 0;
1736
1737 assert(bus);
1738 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1739
1740 while (bus->wqueue_size > 0) {
1741
1742 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1743 if (r < 0)
1744 return r;
1745 else if (r == 0)
1746 /* Didn't do anything this time */
1747 return ret;
1748 else if (bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1749 /* Fully written. Let's drop the entry from
1750 * the queue.
1751 *
1752 * This isn't particularly optimized, but
1753 * well, this is supposed to be our worst-case
1754 * buffer only, and the socket buffer is
1755 * supposed to be our primary buffer, and if
1756 * it got full, then all bets are off
1757 * anyway. */
1758
1759 bus->wqueue_size--;
1760 sd_bus_message_unref(bus->wqueue[0]);
1761 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1762 bus->windex = 0;
1763
1764 ret = 1;
1765 }
1766 }
1767
1768 return ret;
1769 }
1770
1771 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1772 assert(bus);
1773
1774 return bus_socket_read_message(bus);
1775 }
1776
1777 int bus_rqueue_make_room(sd_bus *bus) {
1778 assert(bus);
1779
1780 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1781 return -ENOBUFS;
1782
1783 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1784 return -ENOMEM;
1785
1786 return 0;
1787 }
1788
1789 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1790 int r, ret = 0;
1791
1792 assert(bus);
1793 assert(m);
1794 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1795
1796 /* Note that the priority logic is only available on kdbus,
1797 * where the rqueue is unused. We check the rqueue here
1798 * anyway, because it's simple... */
1799
1800 for (;;) {
1801 if (bus->rqueue_size > 0) {
1802 /* Dispatch a queued message */
1803
1804 *m = bus->rqueue[0];
1805 bus->rqueue_size--;
1806 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1807 return 1;
1808 }
1809
1810 /* Try to read a new message */
1811 r = bus_read_message(bus, hint_priority, priority);
1812 if (r < 0)
1813 return r;
1814 if (r == 0)
1815 return ret;
1816
1817 ret = 1;
1818 }
1819 }
1820
1821 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie) {
1822 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1823 int r;
1824
1825 assert_return(m, -EINVAL);
1826
1827 if (!bus)
1828 bus = m->bus;
1829
1830 assert_return(!bus_pid_changed(bus), -ECHILD);
1831
1832 if (!BUS_IS_OPEN(bus->state))
1833 return -ENOTCONN;
1834
1835 if (m->n_fds > 0) {
1836 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1837 if (r < 0)
1838 return r;
1839 if (r == 0)
1840 return -EOPNOTSUPP;
1841 }
1842
1843 /* If the cookie number isn't kept, then we know that no reply
1844 * is expected */
1845 if (!cookie && !m->sealed)
1846 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1847
1848 r = bus_seal_message(bus, m, 0);
1849 if (r < 0)
1850 return r;
1851
1852 /* Remarshall if we have to. This will possibly unref the
1853 * message and place a replacement in m */
1854 r = bus_remarshal_message(bus, &m);
1855 if (r < 0)
1856 return r;
1857
1858 /* If this is a reply and no reply was requested, then let's
1859 * suppress this, if we can */
1860 if (m->dont_send)
1861 goto finish;
1862
1863 if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO) && bus->wqueue_size <= 0) {
1864 size_t idx = 0;
1865
1866 r = bus_write_message(bus, m, &idx);
1867 if (r < 0) {
1868 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1869 bus_enter_closing(bus);
1870 return -ECONNRESET;
1871 }
1872
1873 return r;
1874 }
1875
1876 if (idx < BUS_MESSAGE_SIZE(m)) {
1877 /* Wasn't fully written. So let's remember how
1878 * much was written. Note that the first entry
1879 * of the wqueue array is always allocated so
1880 * that we always can remember how much was
1881 * written. */
1882 bus->wqueue[0] = sd_bus_message_ref(m);
1883 bus->wqueue_size = 1;
1884 bus->windex = idx;
1885 }
1886
1887 } else {
1888 /* Just append it to the queue. */
1889
1890 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1891 return -ENOBUFS;
1892
1893 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1894 return -ENOMEM;
1895
1896 bus->wqueue[bus->wqueue_size++] = sd_bus_message_ref(m);
1897 }
1898
1899 finish:
1900 if (cookie)
1901 *cookie = BUS_MESSAGE_COOKIE(m);
1902
1903 return 1;
1904 }
1905
1906 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1907 int r;
1908
1909 assert_return(m, -EINVAL);
1910
1911 if (!bus)
1912 bus = m->bus;
1913
1914 assert_return(!bus_pid_changed(bus), -ECHILD);
1915
1916 if (!BUS_IS_OPEN(bus->state))
1917 return -ENOTCONN;
1918
1919 if (!streq_ptr(m->destination, destination)) {
1920
1921 if (!destination)
1922 return -EEXIST;
1923
1924 r = sd_bus_message_set_destination(m, destination);
1925 if (r < 0)
1926 return r;
1927 }
1928
1929 return sd_bus_send(bus, m, cookie);
1930 }
1931
1932 static usec_t calc_elapse(sd_bus *bus, uint64_t usec) {
1933 assert(bus);
1934
1935 if (usec == (uint64_t) -1)
1936 return 0;
1937
1938 /* We start all timeouts the instant we enter BUS_HELLO/BUS_RUNNING state, so that the don't run in parallel
1939 * with any connection setup states. Hence, if a method callback is started earlier than that we just store the
1940 * relative timestamp, and afterwards the absolute one. */
1941
1942 if (IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING))
1943 return usec;
1944 else
1945 return now(CLOCK_MONOTONIC) + usec;
1946 }
1947
1948 static int timeout_compare(const void *a, const void *b) {
1949 const struct reply_callback *x = a, *y = b;
1950
1951 if (x->timeout_usec != 0 && y->timeout_usec == 0)
1952 return -1;
1953
1954 if (x->timeout_usec == 0 && y->timeout_usec != 0)
1955 return 1;
1956
1957 if (x->timeout_usec < y->timeout_usec)
1958 return -1;
1959
1960 if (x->timeout_usec > y->timeout_usec)
1961 return 1;
1962
1963 return 0;
1964 }
1965
1966 _public_ int sd_bus_call_async(
1967 sd_bus *bus,
1968 sd_bus_slot **slot,
1969 sd_bus_message *_m,
1970 sd_bus_message_handler_t callback,
1971 void *userdata,
1972 uint64_t usec) {
1973
1974 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1975 _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
1976 int r;
1977
1978 assert_return(m, -EINVAL);
1979 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1980 assert_return(!m->sealed || (!!callback == !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)), -EINVAL);
1981
1982 if (!bus)
1983 bus = m->bus;
1984
1985 assert_return(!bus_pid_changed(bus), -ECHILD);
1986
1987 if (!BUS_IS_OPEN(bus->state))
1988 return -ENOTCONN;
1989
1990 /* If no callback is specified and there's no interest in a slot, then there's no reason to ask for a reply */
1991 if (!callback && !slot && !m->sealed)
1992 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1993
1994 r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1995 if (r < 0)
1996 return r;
1997
1998 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1999 if (r < 0)
2000 return r;
2001
2002 r = bus_seal_message(bus, m, usec);
2003 if (r < 0)
2004 return r;
2005
2006 r = bus_remarshal_message(bus, &m);
2007 if (r < 0)
2008 return r;
2009
2010 if (slot || callback) {
2011 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
2012 if (!s)
2013 return -ENOMEM;
2014
2015 s->reply_callback.callback = callback;
2016
2017 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
2018 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
2019 if (r < 0) {
2020 s->reply_callback.cookie = 0;
2021 return r;
2022 }
2023
2024 s->reply_callback.timeout_usec = calc_elapse(bus, m->timeout);
2025 if (s->reply_callback.timeout_usec != 0) {
2026 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
2027 if (r < 0) {
2028 s->reply_callback.timeout_usec = 0;
2029 return r;
2030 }
2031 }
2032 }
2033
2034 r = sd_bus_send(bus, m, s ? &s->reply_callback.cookie : NULL);
2035 if (r < 0)
2036 return r;
2037
2038 if (slot)
2039 *slot = s;
2040 s = NULL;
2041
2042 return r;
2043 }
2044
2045 int bus_ensure_running(sd_bus *bus) {
2046 int r;
2047
2048 assert(bus);
2049
2050 if (IN_SET(bus->state, BUS_UNSET, BUS_CLOSED, BUS_CLOSING))
2051 return -ENOTCONN;
2052 if (bus->state == BUS_RUNNING)
2053 return 1;
2054
2055 for (;;) {
2056 r = sd_bus_process(bus, NULL);
2057 if (r < 0)
2058 return r;
2059 if (bus->state == BUS_RUNNING)
2060 return 1;
2061 if (r > 0)
2062 continue;
2063
2064 r = sd_bus_wait(bus, (uint64_t) -1);
2065 if (r < 0)
2066 return r;
2067 }
2068 }
2069
2070 _public_ int sd_bus_call(
2071 sd_bus *bus,
2072 sd_bus_message *_m,
2073 uint64_t usec,
2074 sd_bus_error *error,
2075 sd_bus_message **reply) {
2076
2077 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
2078 usec_t timeout;
2079 uint64_t cookie;
2080 unsigned i;
2081 int r;
2082
2083 bus_assert_return(m, -EINVAL, error);
2084 bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2085 bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2086 bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2087
2088 if (!bus)
2089 bus = m->bus;
2090
2091 bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2092
2093 if (!BUS_IS_OPEN(bus->state)) {
2094 r = -ENOTCONN;
2095 goto fail;
2096 }
2097
2098 r = bus_ensure_running(bus);
2099 if (r < 0)
2100 goto fail;
2101
2102 i = bus->rqueue_size;
2103
2104 r = bus_seal_message(bus, m, usec);
2105 if (r < 0)
2106 goto fail;
2107
2108 r = bus_remarshal_message(bus, &m);
2109 if (r < 0)
2110 goto fail;
2111
2112 r = sd_bus_send(bus, m, &cookie);
2113 if (r < 0)
2114 goto fail;
2115
2116 timeout = calc_elapse(bus, m->timeout);
2117
2118 for (;;) {
2119 usec_t left;
2120
2121 while (i < bus->rqueue_size) {
2122 sd_bus_message *incoming = NULL;
2123
2124 incoming = bus->rqueue[i];
2125
2126 if (incoming->reply_cookie == cookie) {
2127 /* Found a match! */
2128
2129 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2130 bus->rqueue_size--;
2131 log_debug_bus_message(incoming);
2132
2133 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2134
2135 if (incoming->n_fds <= 0 || bus->accept_fd) {
2136 if (reply)
2137 *reply = incoming;
2138 else
2139 sd_bus_message_unref(incoming);
2140
2141 return 1;
2142 }
2143
2144 r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2145 sd_bus_message_unref(incoming);
2146 return r;
2147
2148 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2149 r = sd_bus_error_copy(error, &incoming->error);
2150 sd_bus_message_unref(incoming);
2151 return r;
2152 } else {
2153 r = -EIO;
2154 goto fail;
2155 }
2156
2157 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2158 bus->unique_name &&
2159 incoming->sender &&
2160 streq(bus->unique_name, incoming->sender)) {
2161
2162 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2163 bus->rqueue_size--;
2164
2165 /* Our own message? Somebody is trying
2166 * to send its own client a message,
2167 * let's not dead-lock, let's fail
2168 * immediately. */
2169
2170 sd_bus_message_unref(incoming);
2171 r = -ELOOP;
2172 goto fail;
2173 }
2174
2175 /* Try to read more, right-away */
2176 i++;
2177 }
2178
2179 r = bus_read_message(bus, false, 0);
2180 if (r < 0) {
2181 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2182 bus_enter_closing(bus);
2183 r = -ECONNRESET;
2184 }
2185
2186 goto fail;
2187 }
2188 if (r > 0)
2189 continue;
2190
2191 if (timeout > 0) {
2192 usec_t n;
2193
2194 n = now(CLOCK_MONOTONIC);
2195 if (n >= timeout) {
2196 r = -ETIMEDOUT;
2197 goto fail;
2198 }
2199
2200 left = timeout - n;
2201 } else
2202 left = (uint64_t) -1;
2203
2204 r = bus_poll(bus, true, left);
2205 if (r < 0)
2206 goto fail;
2207 if (r == 0) {
2208 r = -ETIMEDOUT;
2209 goto fail;
2210 }
2211
2212 r = dispatch_wqueue(bus);
2213 if (r < 0) {
2214 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2215 bus_enter_closing(bus);
2216 r = -ECONNRESET;
2217 }
2218
2219 goto fail;
2220 }
2221 }
2222
2223 fail:
2224 return sd_bus_error_set_errno(error, r);
2225 }
2226
2227 _public_ int sd_bus_get_fd(sd_bus *bus) {
2228
2229 assert_return(bus, -EINVAL);
2230 assert_return(bus = bus_resolve(bus), -ENOPKG);
2231 assert_return(bus->input_fd == bus->output_fd, -EPERM);
2232 assert_return(!bus_pid_changed(bus), -ECHILD);
2233
2234 if (bus->state == BUS_CLOSED)
2235 return -ENOTCONN;
2236
2237 if (bus->inotify_fd >= 0)
2238 return bus->inotify_fd;
2239
2240 if (bus->input_fd >= 0)
2241 return bus->input_fd;
2242
2243 return -ENOTCONN;
2244 }
2245
2246 _public_ int sd_bus_get_events(sd_bus *bus) {
2247 int flags = 0;
2248
2249 assert_return(bus, -EINVAL);
2250 assert_return(bus = bus_resolve(bus), -ENOPKG);
2251 assert_return(!bus_pid_changed(bus), -ECHILD);
2252
2253 switch (bus->state) {
2254
2255 case BUS_UNSET:
2256 case BUS_CLOSED:
2257 return -ENOTCONN;
2258
2259 case BUS_WATCH_BIND:
2260 flags |= POLLIN;
2261 break;
2262
2263 case BUS_OPENING:
2264 flags |= POLLOUT;
2265 break;
2266
2267 case BUS_AUTHENTICATING:
2268 if (bus_socket_auth_needs_write(bus))
2269 flags |= POLLOUT;
2270
2271 flags |= POLLIN;
2272 break;
2273
2274 case BUS_RUNNING:
2275 case BUS_HELLO:
2276 if (bus->rqueue_size <= 0)
2277 flags |= POLLIN;
2278 if (bus->wqueue_size > 0)
2279 flags |= POLLOUT;
2280 break;
2281
2282 case BUS_CLOSING:
2283 break;
2284
2285 default:
2286 assert_not_reached("Unknown state");
2287 }
2288
2289 return flags;
2290 }
2291
2292 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2293 struct reply_callback *c;
2294
2295 assert_return(bus, -EINVAL);
2296 assert_return(bus = bus_resolve(bus), -ENOPKG);
2297 assert_return(timeout_usec, -EINVAL);
2298 assert_return(!bus_pid_changed(bus), -ECHILD);
2299
2300 if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2301 return -ENOTCONN;
2302
2303 if (bus->track_queue) {
2304 *timeout_usec = 0;
2305 return 1;
2306 }
2307
2308 switch (bus->state) {
2309
2310 case BUS_AUTHENTICATING:
2311 *timeout_usec = bus->auth_timeout;
2312 return 1;
2313
2314 case BUS_RUNNING:
2315 case BUS_HELLO:
2316 if (bus->rqueue_size > 0) {
2317 *timeout_usec = 0;
2318 return 1;
2319 }
2320
2321 c = prioq_peek(bus->reply_callbacks_prioq);
2322 if (!c) {
2323 *timeout_usec = (uint64_t) -1;
2324 return 0;
2325 }
2326
2327 if (c->timeout_usec == 0) {
2328 *timeout_usec = (uint64_t) -1;
2329 return 0;
2330 }
2331
2332 *timeout_usec = c->timeout_usec;
2333 return 1;
2334
2335 case BUS_CLOSING:
2336 *timeout_usec = 0;
2337 return 1;
2338
2339 case BUS_WATCH_BIND:
2340 case BUS_OPENING:
2341 *timeout_usec = (uint64_t) -1;
2342 return 0;
2343
2344 default:
2345 assert_not_reached("Unknown or unexpected stat");
2346 }
2347 }
2348
2349 static int process_timeout(sd_bus *bus) {
2350 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2351 _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2352 struct reply_callback *c;
2353 sd_bus_slot *slot;
2354 bool is_hello;
2355 usec_t n;
2356 int r;
2357
2358 assert(bus);
2359 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2360
2361 c = prioq_peek(bus->reply_callbacks_prioq);
2362 if (!c)
2363 return 0;
2364
2365 n = now(CLOCK_MONOTONIC);
2366 if (c->timeout_usec > n)
2367 return 0;
2368
2369 r = bus_message_new_synthetic_error(
2370 bus,
2371 c->cookie,
2372 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2373 &m);
2374 if (r < 0)
2375 return r;
2376
2377 r = bus_seal_synthetic_message(bus, m);
2378 if (r < 0)
2379 return r;
2380
2381 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2382 c->timeout_usec = 0;
2383
2384 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2385 c->cookie = 0;
2386
2387 slot = container_of(c, sd_bus_slot, reply_callback);
2388
2389 bus->iteration_counter++;
2390
2391 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2392
2393 bus->current_message = m;
2394 bus->current_slot = sd_bus_slot_ref(slot);
2395 bus->current_handler = c->callback;
2396 bus->current_userdata = slot->userdata;
2397 r = c->callback(m, slot->userdata, &error_buffer);
2398 bus->current_userdata = NULL;
2399 bus->current_handler = NULL;
2400 bus->current_slot = NULL;
2401 bus->current_message = NULL;
2402
2403 if (slot->floating) {
2404 bus_slot_disconnect(slot);
2405 sd_bus_slot_unref(slot);
2406 }
2407
2408 sd_bus_slot_unref(slot);
2409
2410 /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2411 * and ignore the callback handler's return value. */
2412 if (is_hello)
2413 return r;
2414
2415 return bus_maybe_reply_error(m, r, &error_buffer);
2416 }
2417
2418 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2419 assert(bus);
2420 assert(m);
2421
2422 if (bus->state != BUS_HELLO)
2423 return 0;
2424
2425 /* Let's make sure the first message on the bus is the HELLO
2426 * reply. But note that we don't actually parse the message
2427 * here (we leave that to the usual handling), we just verify
2428 * we don't let any earlier msg through. */
2429
2430 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2431 return -EIO;
2432
2433 if (m->reply_cookie != 1)
2434 return -EIO;
2435
2436 return 0;
2437 }
2438
2439 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2440 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2441 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2442 struct reply_callback *c;
2443 sd_bus_slot *slot;
2444 bool is_hello;
2445 int r;
2446
2447 assert(bus);
2448 assert(m);
2449
2450 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2451 return 0;
2452
2453 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2454 return 0;
2455
2456 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2457 if (!c)
2458 return 0;
2459
2460 c->cookie = 0;
2461
2462 slot = container_of(c, sd_bus_slot, reply_callback);
2463
2464 if (m->n_fds > 0 && !bus->accept_fd) {
2465
2466 /* If the reply contained a file descriptor which we
2467 * didn't want we pass an error instead. */
2468
2469 r = bus_message_new_synthetic_error(
2470 bus,
2471 m->reply_cookie,
2472 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2473 &synthetic_reply);
2474 if (r < 0)
2475 return r;
2476
2477 /* Copy over original timestamp */
2478 synthetic_reply->realtime = m->realtime;
2479 synthetic_reply->monotonic = m->monotonic;
2480 synthetic_reply->seqnum = m->seqnum;
2481
2482 r = bus_seal_synthetic_message(bus, synthetic_reply);
2483 if (r < 0)
2484 return r;
2485
2486 m = synthetic_reply;
2487 } else {
2488 r = sd_bus_message_rewind(m, true);
2489 if (r < 0)
2490 return r;
2491 }
2492
2493 if (c->timeout_usec != 0) {
2494 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2495 c->timeout_usec = 0;
2496 }
2497
2498 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2499
2500 bus->current_slot = sd_bus_slot_ref(slot);
2501 bus->current_handler = c->callback;
2502 bus->current_userdata = slot->userdata;
2503 r = c->callback(m, slot->userdata, &error_buffer);
2504 bus->current_userdata = NULL;
2505 bus->current_handler = NULL;
2506 bus->current_slot = NULL;
2507
2508 if (slot->floating) {
2509 bus_slot_disconnect(slot);
2510 sd_bus_slot_unref(slot);
2511 }
2512
2513 sd_bus_slot_unref(slot);
2514
2515 /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2516 * ignore the callback handler's return value. */
2517 if (is_hello)
2518 return r;
2519
2520 return bus_maybe_reply_error(m, r, &error_buffer);
2521 }
2522
2523 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2524 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2525 struct filter_callback *l;
2526 int r;
2527
2528 assert(bus);
2529 assert(m);
2530
2531 do {
2532 bus->filter_callbacks_modified = false;
2533
2534 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2535 sd_bus_slot *slot;
2536
2537 if (bus->filter_callbacks_modified)
2538 break;
2539
2540 /* Don't run this more than once per iteration */
2541 if (l->last_iteration == bus->iteration_counter)
2542 continue;
2543
2544 l->last_iteration = bus->iteration_counter;
2545
2546 r = sd_bus_message_rewind(m, true);
2547 if (r < 0)
2548 return r;
2549
2550 slot = container_of(l, sd_bus_slot, filter_callback);
2551
2552 bus->current_slot = sd_bus_slot_ref(slot);
2553 bus->current_handler = l->callback;
2554 bus->current_userdata = slot->userdata;
2555 r = l->callback(m, slot->userdata, &error_buffer);
2556 bus->current_userdata = NULL;
2557 bus->current_handler = NULL;
2558 bus->current_slot = sd_bus_slot_unref(slot);
2559
2560 r = bus_maybe_reply_error(m, r, &error_buffer);
2561 if (r != 0)
2562 return r;
2563
2564 }
2565
2566 } while (bus->filter_callbacks_modified);
2567
2568 return 0;
2569 }
2570
2571 static int process_match(sd_bus *bus, sd_bus_message *m) {
2572 int r;
2573
2574 assert(bus);
2575 assert(m);
2576
2577 do {
2578 bus->match_callbacks_modified = false;
2579
2580 r = bus_match_run(bus, &bus->match_callbacks, m);
2581 if (r != 0)
2582 return r;
2583
2584 } while (bus->match_callbacks_modified);
2585
2586 return 0;
2587 }
2588
2589 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2590 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2591 int r;
2592
2593 assert(bus);
2594 assert(m);
2595
2596 if (bus->is_monitor)
2597 return 0;
2598
2599 if (bus->manual_peer_interface)
2600 return 0;
2601
2602 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2603 return 0;
2604
2605 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2606 return 0;
2607
2608 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2609 return 1;
2610
2611 if (streq_ptr(m->member, "Ping"))
2612 r = sd_bus_message_new_method_return(m, &reply);
2613 else if (streq_ptr(m->member, "GetMachineId")) {
2614 sd_id128_t id;
2615 char sid[33];
2616
2617 r = sd_id128_get_machine(&id);
2618 if (r < 0)
2619 return r;
2620
2621 r = sd_bus_message_new_method_return(m, &reply);
2622 if (r < 0)
2623 return r;
2624
2625 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2626 } else {
2627 r = sd_bus_message_new_method_errorf(
2628 m, &reply,
2629 SD_BUS_ERROR_UNKNOWN_METHOD,
2630 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2631 }
2632
2633 if (r < 0)
2634 return r;
2635
2636 r = sd_bus_send(bus, reply, NULL);
2637 if (r < 0)
2638 return r;
2639
2640 return 1;
2641 }
2642
2643 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2644 assert(bus);
2645 assert(m);
2646
2647 /* If we got a message with a file descriptor which we didn't
2648 * want to accept, then let's drop it. How can this even
2649 * happen? For example, when the kernel queues a message into
2650 * an activatable names's queue which allows fds, and then is
2651 * delivered to us later even though we ourselves did not
2652 * negotiate it. */
2653
2654 if (bus->is_monitor)
2655 return 0;
2656
2657 if (m->n_fds <= 0)
2658 return 0;
2659
2660 if (bus->accept_fd)
2661 return 0;
2662
2663 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2664 return 1; /* just eat it up */
2665
2666 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2667 }
2668
2669 static int process_message(sd_bus *bus, sd_bus_message *m) {
2670 int r;
2671
2672 assert(bus);
2673 assert(m);
2674
2675 bus->current_message = m;
2676 bus->iteration_counter++;
2677
2678 log_debug_bus_message(m);
2679
2680 r = process_hello(bus, m);
2681 if (r != 0)
2682 goto finish;
2683
2684 r = process_reply(bus, m);
2685 if (r != 0)
2686 goto finish;
2687
2688 r = process_fd_check(bus, m);
2689 if (r != 0)
2690 goto finish;
2691
2692 r = process_filter(bus, m);
2693 if (r != 0)
2694 goto finish;
2695
2696 r = process_match(bus, m);
2697 if (r != 0)
2698 goto finish;
2699
2700 r = process_builtin(bus, m);
2701 if (r != 0)
2702 goto finish;
2703
2704 r = bus_process_object(bus, m);
2705
2706 finish:
2707 bus->current_message = NULL;
2708 return r;
2709 }
2710
2711 static int dispatch_track(sd_bus *bus) {
2712 assert(bus);
2713
2714 if (!bus->track_queue)
2715 return 0;
2716
2717 bus_track_dispatch(bus->track_queue);
2718 return 1;
2719 }
2720
2721 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2722 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2723 int r;
2724
2725 assert(bus);
2726 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2727
2728 r = process_timeout(bus);
2729 if (r != 0)
2730 goto null_message;
2731
2732 r = dispatch_wqueue(bus);
2733 if (r != 0)
2734 goto null_message;
2735
2736 r = dispatch_track(bus);
2737 if (r != 0)
2738 goto null_message;
2739
2740 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2741 if (r < 0)
2742 return r;
2743 if (!m)
2744 goto null_message;
2745
2746 r = process_message(bus, m);
2747 if (r != 0)
2748 goto null_message;
2749
2750 if (ret) {
2751 r = sd_bus_message_rewind(m, true);
2752 if (r < 0)
2753 return r;
2754
2755 *ret = m;
2756 m = NULL;
2757 return 1;
2758 }
2759
2760 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2761
2762 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2763 strna(sd_bus_message_get_sender(m)),
2764 strna(sd_bus_message_get_path(m)),
2765 strna(sd_bus_message_get_interface(m)),
2766 strna(sd_bus_message_get_member(m)));
2767
2768 r = sd_bus_reply_method_errorf(
2769 m,
2770 SD_BUS_ERROR_UNKNOWN_OBJECT,
2771 "Unknown object '%s'.", m->path);
2772 if (r < 0)
2773 return r;
2774 }
2775
2776 return 1;
2777
2778 null_message:
2779 if (r >= 0 && ret)
2780 *ret = NULL;
2781
2782 return r;
2783 }
2784
2785 static int bus_exit_now(sd_bus *bus) {
2786 assert(bus);
2787
2788 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2789 * sd_event_exit(), otherwise invokes libc exit(). */
2790
2791 if (bus->exited) /* did we already exit? */
2792 return 0;
2793 if (!bus->exit_triggered) /* was the exit condition triggered? */
2794 return 0;
2795 if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2796 return 0;
2797
2798 bus->exited = true; /* never exit more than once */
2799
2800 log_debug("Bus connection disconnected, exiting.");
2801
2802 if (bus->event)
2803 return sd_event_exit(bus->event, EXIT_FAILURE);
2804 else
2805 exit(EXIT_FAILURE);
2806
2807 assert_not_reached("exit() didn't exit?");
2808 }
2809
2810 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2811 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2812 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2813 sd_bus_slot *slot;
2814 int r;
2815
2816 assert(bus);
2817 assert(c);
2818
2819 r = bus_message_new_synthetic_error(
2820 bus,
2821 c->cookie,
2822 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2823 &m);
2824 if (r < 0)
2825 return r;
2826
2827 r = bus_seal_synthetic_message(bus, m);
2828 if (r < 0)
2829 return r;
2830
2831 if (c->timeout_usec != 0) {
2832 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2833 c->timeout_usec = 0;
2834 }
2835
2836 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2837 c->cookie = 0;
2838
2839 slot = container_of(c, sd_bus_slot, reply_callback);
2840
2841 bus->iteration_counter++;
2842
2843 bus->current_message = m;
2844 bus->current_slot = sd_bus_slot_ref(slot);
2845 bus->current_handler = c->callback;
2846 bus->current_userdata = slot->userdata;
2847 r = c->callback(m, slot->userdata, &error_buffer);
2848 bus->current_userdata = NULL;
2849 bus->current_handler = NULL;
2850 bus->current_slot = NULL;
2851 bus->current_message = NULL;
2852
2853 if (slot->floating) {
2854 bus_slot_disconnect(slot);
2855 sd_bus_slot_unref(slot);
2856 }
2857
2858 sd_bus_slot_unref(slot);
2859
2860 return bus_maybe_reply_error(m, r, &error_buffer);
2861 }
2862
2863 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2864 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2865 struct reply_callback *c;
2866 int r;
2867
2868 assert(bus);
2869 assert(bus->state == BUS_CLOSING);
2870
2871 /* First, fail all outstanding method calls */
2872 c = ordered_hashmap_first(bus->reply_callbacks);
2873 if (c)
2874 return process_closing_reply_callback(bus, c);
2875
2876 /* Then, fake-drop all remaining bus tracking references */
2877 if (bus->tracks) {
2878 bus_track_close(bus->tracks);
2879 return 1;
2880 }
2881
2882 /* Then, synthesize a Disconnected message */
2883 r = sd_bus_message_new_signal(
2884 bus,
2885 &m,
2886 "/org/freedesktop/DBus/Local",
2887 "org.freedesktop.DBus.Local",
2888 "Disconnected");
2889 if (r < 0)
2890 return r;
2891
2892 bus_message_set_sender_local(bus, m);
2893
2894 r = bus_seal_synthetic_message(bus, m);
2895 if (r < 0)
2896 return r;
2897
2898 sd_bus_close(bus);
2899
2900 bus->current_message = m;
2901 bus->iteration_counter++;
2902
2903 r = process_filter(bus, m);
2904 if (r != 0)
2905 goto finish;
2906
2907 r = process_match(bus, m);
2908 if (r != 0)
2909 goto finish;
2910
2911 /* Nothing else to do, exit now, if the condition holds */
2912 bus->exit_triggered = true;
2913 (void) bus_exit_now(bus);
2914
2915 if (ret) {
2916 *ret = m;
2917 m = NULL;
2918 }
2919
2920 r = 1;
2921
2922 finish:
2923 bus->current_message = NULL;
2924
2925 return r;
2926 }
2927
2928 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2929 BUS_DONT_DESTROY(bus);
2930 int r;
2931
2932 /* Returns 0 when we didn't do anything. This should cause the
2933 * caller to invoke sd_bus_wait() before returning the next
2934 * time. Returns > 0 when we did something, which possibly
2935 * means *ret is filled in with an unprocessed message. */
2936
2937 assert_return(bus, -EINVAL);
2938 assert_return(bus = bus_resolve(bus), -ENOPKG);
2939 assert_return(!bus_pid_changed(bus), -ECHILD);
2940
2941 /* We don't allow recursively invoking sd_bus_process(). */
2942 assert_return(!bus->current_message, -EBUSY);
2943 assert(!bus->current_slot);
2944
2945 switch (bus->state) {
2946
2947 case BUS_UNSET:
2948 return -ENOTCONN;
2949
2950 case BUS_CLOSED:
2951 return -ECONNRESET;
2952
2953 case BUS_WATCH_BIND:
2954 r = bus_socket_process_watch_bind(bus);
2955 break;
2956
2957 case BUS_OPENING:
2958 r = bus_socket_process_opening(bus);
2959 break;
2960
2961 case BUS_AUTHENTICATING:
2962 r = bus_socket_process_authenticating(bus);
2963 break;
2964
2965 case BUS_RUNNING:
2966 case BUS_HELLO:
2967 r = process_running(bus, hint_priority, priority, ret);
2968 if (r >= 0)
2969 return r;
2970
2971 /* This branch initializes *ret, hence we don't use the generic error checking below */
2972 break;
2973
2974 case BUS_CLOSING:
2975 return process_closing(bus, ret);
2976
2977 default:
2978 assert_not_reached("Unknown state");
2979 }
2980
2981 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2982 bus_enter_closing(bus);
2983 r = 1;
2984 } else if (r < 0)
2985 return r;
2986
2987 if (ret)
2988 *ret = NULL;
2989
2990 return r;
2991 }
2992
2993 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2994 return bus_process_internal(bus, false, 0, ret);
2995 }
2996
2997 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2998 return bus_process_internal(bus, true, priority, ret);
2999 }
3000
3001 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
3002 struct pollfd p[2] = {};
3003 int r, n;
3004 struct timespec ts;
3005 usec_t m = USEC_INFINITY;
3006
3007 assert(bus);
3008
3009 if (bus->state == BUS_CLOSING)
3010 return 1;
3011
3012 if (!BUS_IS_OPEN(bus->state))
3013 return -ENOTCONN;
3014
3015 if (bus->state == BUS_WATCH_BIND) {
3016 assert(bus->inotify_fd >= 0);
3017
3018 p[0].events = POLLIN;
3019 p[0].fd = bus->inotify_fd;
3020 n = 1;
3021 } else {
3022 int e;
3023
3024 e = sd_bus_get_events(bus);
3025 if (e < 0)
3026 return e;
3027
3028 if (need_more)
3029 /* The caller really needs some more data, he doesn't
3030 * care about what's already read, or any timeouts
3031 * except its own. */
3032 e |= POLLIN;
3033 else {
3034 usec_t until;
3035 /* The caller wants to process if there's something to
3036 * process, but doesn't care otherwise */
3037
3038 r = sd_bus_get_timeout(bus, &until);
3039 if (r < 0)
3040 return r;
3041 if (r > 0)
3042 m = usec_sub_unsigned(until, now(CLOCK_MONOTONIC));
3043 }
3044
3045 p[0].fd = bus->input_fd;
3046 if (bus->output_fd == bus->input_fd) {
3047 p[0].events = e;
3048 n = 1;
3049 } else {
3050 p[0].events = e & POLLIN;
3051 p[1].fd = bus->output_fd;
3052 p[1].events = e & POLLOUT;
3053 n = 2;
3054 }
3055 }
3056
3057 if (timeout_usec != (uint64_t) -1 && (m == USEC_INFINITY || timeout_usec < m))
3058 m = timeout_usec;
3059
3060 r = ppoll(p, n, m == USEC_INFINITY ? NULL : timespec_store(&ts, m), NULL);
3061 if (r < 0)
3062 return -errno;
3063
3064 return r > 0 ? 1 : 0;
3065 }
3066
3067 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
3068
3069 assert_return(bus, -EINVAL);
3070 assert_return(bus = bus_resolve(bus), -ENOPKG);
3071 assert_return(!bus_pid_changed(bus), -ECHILD);
3072
3073 if (bus->state == BUS_CLOSING)
3074 return 0;
3075
3076 if (!BUS_IS_OPEN(bus->state))
3077 return -ENOTCONN;
3078
3079 if (bus->rqueue_size > 0)
3080 return 0;
3081
3082 return bus_poll(bus, false, timeout_usec);
3083 }
3084
3085 _public_ int sd_bus_flush(sd_bus *bus) {
3086 int r;
3087
3088 assert_return(bus, -EINVAL);
3089 assert_return(bus = bus_resolve(bus), -ENOPKG);
3090 assert_return(!bus_pid_changed(bus), -ECHILD);
3091
3092 if (bus->state == BUS_CLOSING)
3093 return 0;
3094
3095 if (!BUS_IS_OPEN(bus->state))
3096 return -ENOTCONN;
3097
3098 /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
3099 if (bus->state == BUS_WATCH_BIND)
3100 return -EUNATCH;
3101
3102 r = bus_ensure_running(bus);
3103 if (r < 0)
3104 return r;
3105
3106 if (bus->wqueue_size <= 0)
3107 return 0;
3108
3109 for (;;) {
3110 r = dispatch_wqueue(bus);
3111 if (r < 0) {
3112 if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
3113 bus_enter_closing(bus);
3114 return -ECONNRESET;
3115 }
3116
3117 return r;
3118 }
3119
3120 if (bus->wqueue_size <= 0)
3121 return 0;
3122
3123 r = bus_poll(bus, false, (uint64_t) -1);
3124 if (r < 0)
3125 return r;
3126 }
3127 }
3128
3129 _public_ int sd_bus_add_filter(
3130 sd_bus *bus,
3131 sd_bus_slot **slot,
3132 sd_bus_message_handler_t callback,
3133 void *userdata) {
3134
3135 sd_bus_slot *s;
3136
3137 assert_return(bus, -EINVAL);
3138 assert_return(bus = bus_resolve(bus), -ENOPKG);
3139 assert_return(callback, -EINVAL);
3140 assert_return(!bus_pid_changed(bus), -ECHILD);
3141
3142 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
3143 if (!s)
3144 return -ENOMEM;
3145
3146 s->filter_callback.callback = callback;
3147
3148 bus->filter_callbacks_modified = true;
3149 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
3150
3151 if (slot)
3152 *slot = s;
3153
3154 return 0;
3155 }
3156
3157 static int add_match_callback(
3158 sd_bus_message *m,
3159 void *userdata,
3160 sd_bus_error *ret_error) {
3161
3162 sd_bus_slot *match_slot = userdata;
3163 bool failed = false;
3164 int r;
3165
3166 assert(m);
3167 assert(match_slot);
3168
3169 sd_bus_slot_ref(match_slot);
3170
3171 if (sd_bus_message_is_method_error(m, NULL)) {
3172 log_debug_errno(sd_bus_message_get_errno(m),
3173 "Unable to add match %s, failing connection: %s",
3174 match_slot->match_callback.match_string,
3175 sd_bus_message_get_error(m)->message);
3176
3177 failed = true;
3178 } else
3179 log_debug("Match %s successfully installed.", match_slot->match_callback.match_string);
3180
3181 if (match_slot->match_callback.install_callback) {
3182 sd_bus *bus;
3183
3184 bus = sd_bus_message_get_bus(m);
3185
3186 /* This function has been called as slot handler, and we want to call another slot handler. Let's
3187 * update the slot callback metadata temporarily with our own data, and then revert back to the old
3188 * values. */
3189
3190 assert(bus->current_slot == match_slot->match_callback.install_slot);
3191 assert(bus->current_handler == add_match_callback);
3192 assert(bus->current_userdata == userdata);
3193
3194 bus->current_slot = match_slot;
3195 bus->current_handler = match_slot->match_callback.install_callback;
3196 bus->current_userdata = match_slot->userdata;
3197
3198 r = match_slot->match_callback.install_callback(m, match_slot->userdata, ret_error);
3199
3200 bus->current_slot = match_slot->match_callback.install_slot;
3201 bus->current_handler = add_match_callback;
3202 bus->current_userdata = userdata;
3203
3204 match_slot->match_callback.install_slot = sd_bus_slot_unref(match_slot->match_callback.install_slot);
3205 } else {
3206 if (failed) /* Generic failure handling: destroy the connection */
3207 bus_enter_closing(sd_bus_message_get_bus(m));
3208
3209 r = 1;
3210 }
3211
3212 if (failed && match_slot->floating) {
3213 bus_slot_disconnect(match_slot);
3214 sd_bus_slot_unref(match_slot);
3215 }
3216
3217 sd_bus_slot_unref(match_slot);
3218
3219 return r;
3220 }
3221
3222 static int bus_add_match_full(
3223 sd_bus *bus,
3224 sd_bus_slot **slot,
3225 bool asynchronous,
3226 const char *match,
3227 sd_bus_message_handler_t callback,
3228 sd_bus_message_handler_t install_callback,
3229 void *userdata) {
3230
3231 struct bus_match_component *components = NULL;
3232 unsigned n_components = 0;
3233 sd_bus_slot *s = NULL;
3234 int r = 0;
3235
3236 assert_return(bus, -EINVAL);
3237 assert_return(bus = bus_resolve(bus), -ENOPKG);
3238 assert_return(match, -EINVAL);
3239 assert_return(!bus_pid_changed(bus), -ECHILD);
3240
3241 r = bus_match_parse(match, &components, &n_components);
3242 if (r < 0)
3243 goto finish;
3244
3245 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3246 if (!s) {
3247 r = -ENOMEM;
3248 goto finish;
3249 }
3250
3251 s->match_callback.callback = callback;
3252 s->match_callback.install_callback = install_callback;
3253
3254 if (bus->bus_client) {
3255 enum bus_match_scope scope;
3256
3257 scope = bus_match_get_scope(components, n_components);
3258
3259 /* Do not install server-side matches for matches against the local service, interface or bus path. */
3260 if (scope != BUS_MATCH_LOCAL) {
3261
3262 /* We store the original match string, so that we can use it to remove the match again. */
3263
3264 s->match_callback.match_string = strdup(match);
3265 if (!s->match_callback.match_string) {
3266 r = -ENOMEM;
3267 goto finish;
3268 }
3269
3270 if (asynchronous)
3271 r = bus_add_match_internal_async(bus,
3272 &s->match_callback.install_slot,
3273 s->match_callback.match_string,
3274 add_match_callback,
3275 s);
3276 else
3277 r = bus_add_match_internal(bus, s->match_callback.match_string);
3278 if (r < 0)
3279 goto finish;
3280
3281 s->match_added = true;
3282 }
3283 }
3284
3285 bus->match_callbacks_modified = true;
3286 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3287 if (r < 0)
3288 goto finish;
3289
3290 if (slot)
3291 *slot = s;
3292 s = NULL;
3293
3294 finish:
3295 bus_match_parse_free(components, n_components);
3296 sd_bus_slot_unref(s);
3297
3298 return r;
3299 }
3300
3301 _public_ int sd_bus_add_match(
3302 sd_bus *bus,
3303 sd_bus_slot **slot,
3304 const char *match,
3305 sd_bus_message_handler_t callback,
3306 void *userdata) {
3307
3308 return bus_add_match_full(bus, slot, false, match, callback, NULL, userdata);
3309 }
3310
3311 _public_ int sd_bus_add_match_async(
3312 sd_bus *bus,
3313 sd_bus_slot **slot,
3314 const char *match,
3315 sd_bus_message_handler_t callback,
3316 sd_bus_message_handler_t install_callback,
3317 void *userdata) {
3318
3319 return bus_add_match_full(bus, slot, true, match, callback, install_callback, userdata);
3320 }
3321
3322 bool bus_pid_changed(sd_bus *bus) {
3323 assert(bus);
3324
3325 /* We don't support people creating a bus connection and
3326 * keeping it around over a fork(). Let's complain. */
3327
3328 return bus->original_pid != getpid_cached();
3329 }
3330
3331 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3332 sd_bus *bus = userdata;
3333 int r;
3334
3335 assert(bus);
3336
3337 /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3338
3339 r = sd_bus_process(bus, NULL);
3340 if (r < 0) {
3341 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3342 bus_enter_closing(bus);
3343 }
3344
3345 return 1;
3346 }
3347
3348 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3349 sd_bus *bus = userdata;
3350 int r;
3351
3352 assert(bus);
3353
3354 r = sd_bus_process(bus, NULL);
3355 if (r < 0) {
3356 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3357 bus_enter_closing(bus);
3358 }
3359
3360 return 1;
3361 }
3362
3363 static int prepare_callback(sd_event_source *s, void *userdata) {
3364 sd_bus *bus = userdata;
3365 int r, e;
3366 usec_t until;
3367
3368 assert(s);
3369 assert(bus);
3370
3371 e = sd_bus_get_events(bus);
3372 if (e < 0) {
3373 r = e;
3374 goto fail;
3375 }
3376
3377 if (bus->output_fd != bus->input_fd) {
3378
3379 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3380 if (r < 0)
3381 goto fail;
3382
3383 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3384 } else
3385 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3386 if (r < 0)
3387 goto fail;
3388
3389 r = sd_bus_get_timeout(bus, &until);
3390 if (r < 0)
3391 goto fail;
3392 if (r > 0) {
3393 int j;
3394
3395 j = sd_event_source_set_time(bus->time_event_source, until);
3396 if (j < 0) {
3397 r = j;
3398 goto fail;
3399 }
3400 }
3401
3402 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3403 if (r < 0)
3404 goto fail;
3405
3406 return 1;
3407
3408 fail:
3409 log_debug_errno(r, "Preparing of bus events failed, closing down: %m");
3410 bus_enter_closing(bus);
3411
3412 return 1;
3413 }
3414
3415 static int quit_callback(sd_event_source *event, void *userdata) {
3416 sd_bus *bus = userdata;
3417
3418 assert(event);
3419
3420 sd_bus_flush(bus);
3421 sd_bus_close(bus);
3422
3423 return 1;
3424 }
3425
3426 int bus_attach_io_events(sd_bus *bus) {
3427 int r;
3428
3429 assert(bus);
3430
3431 if (bus->input_fd < 0)
3432 return 0;
3433
3434 if (!bus->event)
3435 return 0;
3436
3437 if (!bus->input_io_event_source) {
3438 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3439 if (r < 0)
3440 return r;
3441
3442 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3443 if (r < 0)
3444 return r;
3445
3446 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3447 if (r < 0)
3448 return r;
3449
3450 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3451 } else
3452 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3453
3454 if (r < 0)
3455 return r;
3456
3457 if (bus->output_fd != bus->input_fd) {
3458 assert(bus->output_fd >= 0);
3459
3460 if (!bus->output_io_event_source) {
3461 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3462 if (r < 0)
3463 return r;
3464
3465 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3466 if (r < 0)
3467 return r;
3468
3469 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3470 } else
3471 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3472
3473 if (r < 0)
3474 return r;
3475 }
3476
3477 return 0;
3478 }
3479
3480 static void bus_detach_io_events(sd_bus *bus) {
3481 assert(bus);
3482
3483 if (bus->input_io_event_source) {
3484 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3485 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3486 }
3487
3488 if (bus->output_io_event_source) {
3489 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3490 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3491 }
3492 }
3493
3494 int bus_attach_inotify_event(sd_bus *bus) {
3495 int r;
3496
3497 assert(bus);
3498
3499 if (bus->inotify_fd < 0)
3500 return 0;
3501
3502 if (!bus->event)
3503 return 0;
3504
3505 if (!bus->inotify_event_source) {
3506 r = sd_event_add_io(bus->event, &bus->inotify_event_source, bus->inotify_fd, EPOLLIN, io_callback, bus);
3507 if (r < 0)
3508 return r;
3509
3510 r = sd_event_source_set_priority(bus->inotify_event_source, bus->event_priority);
3511 if (r < 0)
3512 return r;
3513
3514 r = sd_event_source_set_description(bus->inotify_event_source, "bus-inotify");
3515 } else
3516 r = sd_event_source_set_io_fd(bus->inotify_event_source, bus->inotify_fd);
3517 if (r < 0)
3518 return r;
3519
3520 return 0;
3521 }
3522
3523 static void bus_detach_inotify_event(sd_bus *bus) {
3524 assert(bus);
3525
3526 if (bus->inotify_event_source) {
3527 sd_event_source_set_enabled(bus->inotify_event_source, SD_EVENT_OFF);
3528 bus->inotify_event_source = sd_event_source_unref(bus->inotify_event_source);
3529 }
3530 }
3531
3532 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3533 int r;
3534
3535 assert_return(bus, -EINVAL);
3536 assert_return(bus = bus_resolve(bus), -ENOPKG);
3537 assert_return(!bus->event, -EBUSY);
3538
3539 assert(!bus->input_io_event_source);
3540 assert(!bus->output_io_event_source);
3541 assert(!bus->time_event_source);
3542
3543 if (event)
3544 bus->event = sd_event_ref(event);
3545 else {
3546 r = sd_event_default(&bus->event);
3547 if (r < 0)
3548 return r;
3549 }
3550
3551 bus->event_priority = priority;
3552
3553 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3554 if (r < 0)
3555 goto fail;
3556
3557 r = sd_event_source_set_priority(bus->time_event_source, priority);
3558 if (r < 0)
3559 goto fail;
3560
3561 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3562 if (r < 0)
3563 goto fail;
3564
3565 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3566 if (r < 0)
3567 goto fail;
3568
3569 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3570 if (r < 0)
3571 goto fail;
3572
3573 r = bus_attach_io_events(bus);
3574 if (r < 0)
3575 goto fail;
3576
3577 r = bus_attach_inotify_event(bus);
3578 if (r < 0)
3579 goto fail;
3580
3581 return 0;
3582
3583 fail:
3584 sd_bus_detach_event(bus);
3585 return r;
3586 }
3587
3588 _public_ int sd_bus_detach_event(sd_bus *bus) {
3589 assert_return(bus, -EINVAL);
3590 assert_return(bus = bus_resolve(bus), -ENOPKG);
3591
3592 if (!bus->event)
3593 return 0;
3594
3595 bus_detach_io_events(bus);
3596 bus_detach_inotify_event(bus);
3597
3598 if (bus->time_event_source) {
3599 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3600 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3601 }
3602
3603 if (bus->quit_event_source) {
3604 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3605 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3606 }
3607
3608 bus->event = sd_event_unref(bus->event);
3609 return 1;
3610 }
3611
3612 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3613 assert_return(bus, NULL);
3614
3615 return bus->event;
3616 }
3617
3618 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3619 assert_return(bus, NULL);
3620
3621 return bus->current_message;
3622 }
3623
3624 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3625 assert_return(bus, NULL);
3626
3627 return bus->current_slot;
3628 }
3629
3630 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3631 assert_return(bus, NULL);
3632
3633 return bus->current_handler;
3634 }
3635
3636 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3637 assert_return(bus, NULL);
3638
3639 return bus->current_userdata;
3640 }
3641
3642 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3643 sd_bus *b = NULL;
3644 int r;
3645
3646 assert(bus_open);
3647 assert(default_bus);
3648
3649 if (!ret)
3650 return !!*default_bus;
3651
3652 if (*default_bus) {
3653 *ret = sd_bus_ref(*default_bus);
3654 return 0;
3655 }
3656
3657 r = bus_open(&b);
3658 if (r < 0)
3659 return r;
3660
3661 b->default_bus_ptr = default_bus;
3662 b->tid = gettid();
3663 *default_bus = b;
3664
3665 *ret = b;
3666 return 1;
3667 }
3668
3669 _public_ int sd_bus_default_system(sd_bus **ret) {
3670 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3671 }
3672
3673
3674 _public_ int sd_bus_default_user(sd_bus **ret) {
3675 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3676 }
3677
3678 _public_ int sd_bus_default(sd_bus **ret) {
3679 int (*bus_open)(sd_bus **) = NULL;
3680 sd_bus **busp;
3681
3682 busp = bus_choose_default(&bus_open);
3683 return bus_default(bus_open, busp, ret);
3684 }
3685
3686 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3687 assert_return(b, -EINVAL);
3688 assert_return(tid, -EINVAL);
3689 assert_return(!bus_pid_changed(b), -ECHILD);
3690
3691 if (b->tid != 0) {
3692 *tid = b->tid;
3693 return 0;
3694 }
3695
3696 if (b->event)
3697 return sd_event_get_tid(b->event, tid);
3698
3699 return -ENXIO;
3700 }
3701
3702 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3703 _cleanup_free_ char *e = NULL;
3704 char *ret;
3705
3706 assert_return(object_path_is_valid(prefix), -EINVAL);
3707 assert_return(external_id, -EINVAL);
3708 assert_return(ret_path, -EINVAL);
3709
3710 e = bus_label_escape(external_id);
3711 if (!e)
3712 return -ENOMEM;
3713
3714 ret = strjoin(prefix, "/", e);
3715 if (!ret)
3716 return -ENOMEM;
3717
3718 *ret_path = ret;
3719 return 0;
3720 }
3721
3722 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3723 const char *e;
3724 char *ret;
3725
3726 assert_return(object_path_is_valid(path), -EINVAL);
3727 assert_return(object_path_is_valid(prefix), -EINVAL);
3728 assert_return(external_id, -EINVAL);
3729
3730 e = object_path_startswith(path, prefix);
3731 if (!e) {
3732 *external_id = NULL;
3733 return 0;
3734 }
3735
3736 ret = bus_label_unescape(e);
3737 if (!ret)
3738 return -ENOMEM;
3739
3740 *external_id = ret;
3741 return 1;
3742 }
3743
3744 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3745 _cleanup_strv_free_ char **labels = NULL;
3746 char *path, *path_pos, **label_pos;
3747 const char *sep, *template_pos;
3748 size_t path_length;
3749 va_list list;
3750 int r;
3751
3752 assert_return(out, -EINVAL);
3753 assert_return(path_template, -EINVAL);
3754
3755 path_length = strlen(path_template);
3756
3757 va_start(list, path_template);
3758 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3759 const char *arg;
3760 char *label;
3761
3762 arg = va_arg(list, const char *);
3763 if (!arg) {
3764 va_end(list);
3765 return -EINVAL;
3766 }
3767
3768 label = bus_label_escape(arg);
3769 if (!label) {
3770 va_end(list);
3771 return -ENOMEM;
3772 }
3773
3774 r = strv_consume(&labels, label);
3775 if (r < 0) {
3776 va_end(list);
3777 return r;
3778 }
3779
3780 /* add label length, but account for the format character */
3781 path_length += strlen(label) - 1;
3782 }
3783 va_end(list);
3784
3785 path = malloc(path_length + 1);
3786 if (!path)
3787 return -ENOMEM;
3788
3789 path_pos = path;
3790 label_pos = labels;
3791
3792 for (template_pos = path_template; *template_pos; ) {
3793 sep = strchrnul(template_pos, '%');
3794 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3795 if (!*sep)
3796 break;
3797
3798 path_pos = stpcpy(path_pos, *label_pos++);
3799 template_pos = sep + 1;
3800 }
3801
3802 *path_pos = 0;
3803 *out = path;
3804 return 0;
3805 }
3806
3807 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3808 _cleanup_strv_free_ char **labels = NULL;
3809 const char *template_pos, *path_pos;
3810 char **label_pos;
3811 va_list list;
3812 int r;
3813
3814 /*
3815 * This decodes an object-path based on a template argument. The
3816 * template consists of a verbatim path, optionally including special
3817 * directives:
3818 *
3819 * - Each occurrence of '%' in the template matches an arbitrary
3820 * substring of a label in the given path. At most one such
3821 * directive is allowed per label. For each such directive, the
3822 * caller must provide an output parameter (char **) via va_arg. If
3823 * NULL is passed, the given label is verified, but not returned.
3824 * For each matched label, the *decoded* label is stored in the
3825 * passed output argument, and the caller is responsible to free
3826 * it. Note that the output arguments are only modified if the
3827 * actualy path matched the template. Otherwise, they're left
3828 * untouched.
3829 *
3830 * This function returns <0 on error, 0 if the path does not match the
3831 * template, 1 if it matched.
3832 */
3833
3834 assert_return(path, -EINVAL);
3835 assert_return(path_template, -EINVAL);
3836
3837 path_pos = path;
3838
3839 for (template_pos = path_template; *template_pos; ) {
3840 const char *sep;
3841 size_t length;
3842 char *label;
3843
3844 /* verify everything until the next '%' matches verbatim */
3845 sep = strchrnul(template_pos, '%');
3846 length = sep - template_pos;
3847 if (strncmp(path_pos, template_pos, length))
3848 return 0;
3849
3850 path_pos += length;
3851 template_pos += length;
3852
3853 if (!*template_pos)
3854 break;
3855
3856 /* We found the next '%' character. Everything up until here
3857 * matched. We now skip ahead to the end of this label and make
3858 * sure it matches the tail of the label in the path. Then we
3859 * decode the string in-between and save it for later use. */
3860
3861 ++template_pos; /* skip over '%' */
3862
3863 sep = strchrnul(template_pos, '/');
3864 length = sep - template_pos; /* length of suffix to match verbatim */
3865
3866 /* verify the suffixes match */
3867 sep = strchrnul(path_pos, '/');
3868 if (sep - path_pos < (ssize_t)length ||
3869 strncmp(sep - length, template_pos, length))
3870 return 0;
3871
3872 template_pos += length; /* skip over matched label */
3873 length = sep - path_pos - length; /* length of sub-label to decode */
3874
3875 /* store unescaped label for later use */
3876 label = bus_label_unescape_n(path_pos, length);
3877 if (!label)
3878 return -ENOMEM;
3879
3880 r = strv_consume(&labels, label);
3881 if (r < 0)
3882 return r;
3883
3884 path_pos = sep; /* skip decoded label and suffix */
3885 }
3886
3887 /* end of template must match end of path */
3888 if (*path_pos)
3889 return 0;
3890
3891 /* copy the labels over to the caller */
3892 va_start(list, path_template);
3893 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3894 char **arg;
3895
3896 arg = va_arg(list, char **);
3897 if (arg)
3898 *arg = *label_pos;
3899 else
3900 free(*label_pos);
3901 }
3902 va_end(list);
3903
3904 labels = mfree(labels);
3905 return 1;
3906 }
3907
3908 _public_ int sd_bus_try_close(sd_bus *bus) {
3909 assert_return(bus, -EINVAL);
3910 assert_return(bus = bus_resolve(bus), -ENOPKG);
3911 assert_return(!bus_pid_changed(bus), -ECHILD);
3912
3913 return -EOPNOTSUPP;
3914 }
3915
3916 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3917 assert_return(bus, -EINVAL);
3918 assert_return(bus = bus_resolve(bus), -ENOPKG);
3919 assert_return(description, -EINVAL);
3920 assert_return(bus->description, -ENXIO);
3921 assert_return(!bus_pid_changed(bus), -ECHILD);
3922
3923 *description = bus->description;
3924 return 0;
3925 }
3926
3927 int bus_get_root_path(sd_bus *bus) {
3928 int r;
3929
3930 if (bus->cgroup_root)
3931 return 0;
3932
3933 r = cg_get_root_path(&bus->cgroup_root);
3934 if (r == -ENOENT) {
3935 bus->cgroup_root = strdup("/");
3936 if (!bus->cgroup_root)
3937 return -ENOMEM;
3938
3939 r = 0;
3940 }
3941
3942 return r;
3943 }
3944
3945 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3946 assert_return(bus, -EINVAL);
3947 assert_return(bus = bus_resolve(bus), -ENOPKG);
3948 assert_return(scope, -EINVAL);
3949 assert_return(!bus_pid_changed(bus), -ECHILD);
3950
3951 if (bus->is_user) {
3952 *scope = "user";
3953 return 0;
3954 }
3955
3956 if (bus->is_system) {
3957 *scope = "system";
3958 return 0;
3959 }
3960
3961 return -ENODATA;
3962 }
3963
3964 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3965
3966 assert_return(bus, -EINVAL);
3967 assert_return(bus = bus_resolve(bus), -ENOPKG);
3968 assert_return(address, -EINVAL);
3969 assert_return(!bus_pid_changed(bus), -ECHILD);
3970
3971 if (bus->address) {
3972 *address = bus->address;
3973 return 0;
3974 }
3975
3976 return -ENODATA;
3977 }
3978
3979 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3980 assert_return(bus, -EINVAL);
3981 assert_return(bus = bus_resolve(bus), -ENOPKG);
3982 assert_return(mask, -EINVAL);
3983 assert_return(!bus_pid_changed(bus), -ECHILD);
3984
3985 *mask = bus->creds_mask;
3986 return 0;
3987 }
3988
3989 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3990 assert_return(bus, -EINVAL);
3991 assert_return(bus = bus_resolve(bus), -ENOPKG);
3992 assert_return(!bus_pid_changed(bus), -ECHILD);
3993
3994 return bus->bus_client;
3995 }
3996
3997 _public_ int sd_bus_is_server(sd_bus *bus) {
3998 assert_return(bus, -EINVAL);
3999 assert_return(bus = bus_resolve(bus), -ENOPKG);
4000 assert_return(!bus_pid_changed(bus), -ECHILD);
4001
4002 return bus->is_server;
4003 }
4004
4005 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
4006 assert_return(bus, -EINVAL);
4007 assert_return(bus = bus_resolve(bus), -ENOPKG);
4008 assert_return(!bus_pid_changed(bus), -ECHILD);
4009
4010 return bus->anonymous_auth;
4011 }
4012
4013 _public_ int sd_bus_is_trusted(sd_bus *bus) {
4014 assert_return(bus, -EINVAL);
4015 assert_return(bus = bus_resolve(bus), -ENOPKG);
4016 assert_return(!bus_pid_changed(bus), -ECHILD);
4017
4018 return bus->trusted;
4019 }
4020
4021 _public_ int sd_bus_is_monitor(sd_bus *bus) {
4022 assert_return(bus, -EINVAL);
4023 assert_return(bus = bus_resolve(bus), -ENOPKG);
4024 assert_return(!bus_pid_changed(bus), -ECHILD);
4025
4026 return bus->is_monitor;
4027 }
4028
4029 static void flush_close(sd_bus *bus) {
4030 if (!bus)
4031 return;
4032
4033 /* Flushes and closes the specified bus. We take a ref before,
4034 * to ensure the flushing does not cause the bus to be
4035 * unreferenced. */
4036
4037 sd_bus_flush_close_unref(sd_bus_ref(bus));
4038 }
4039
4040 _public_ void sd_bus_default_flush_close(void) {
4041 flush_close(default_starter_bus);
4042 flush_close(default_user_bus);
4043 flush_close(default_system_bus);
4044 }
4045
4046 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
4047 assert_return(bus, -EINVAL);
4048 assert_return(bus = bus_resolve(bus), -ENOPKG);
4049
4050 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
4051 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
4052 * from the client side. */
4053 bus->exit_on_disconnect = b;
4054
4055 /* If the exit condition was triggered already, exit immediately. */
4056 return bus_exit_now(bus);
4057 }
4058
4059 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
4060 assert_return(bus, -EINVAL);
4061 assert_return(bus = bus_resolve(bus), -ENOPKG);
4062
4063 return bus->exit_on_disconnect;
4064 }
4065
4066 _public_ int sd_bus_set_sender(sd_bus *bus, const char *sender) {
4067 assert_return(bus, -EINVAL);
4068 assert_return(bus = bus_resolve(bus), -ENOPKG);
4069 assert_return(!bus->bus_client, -EPERM);
4070 assert_return(!sender || service_name_is_valid(sender), -EINVAL);
4071
4072 return free_and_strdup(&bus->patch_sender, sender);
4073 }
4074
4075 _public_ int sd_bus_get_sender(sd_bus *bus, const char **ret) {
4076 assert_return(bus, -EINVAL);
4077 assert_return(bus = bus_resolve(bus), -ENOPKG);
4078 assert_return(ret, -EINVAL);
4079
4080 if (!bus->patch_sender)
4081 return -ENODATA;
4082
4083 *ret = bus->patch_sender;
4084 return 0;
4085 }
Unnamed repository; edit this file 'description' to name the repository.