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