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