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