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