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