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);
|
(1) Event assignment_where_comparison_intended: |
Assignment "bus = bus_resolve(bus)" has a side effect. This code will work differently in a non-debug build. |
|
(2) Event remediation: |
Did you intend to use a comparison ("==") instead? |
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 m->read_counter = ++bus->read_counter;
488
489 r = bus_seal_synthetic_message(bus, m);
490 if (r < 0)
491 return r;
492
493 r = bus_rqueue_make_room(bus);
494 if (r < 0)
495 return r;
496
497 /* Insert at the very front */
498 memmove(bus->rqueue + 1, bus->rqueue, sizeof(sd_bus_message*) * bus->rqueue_size);
499 bus->rqueue[0] = bus_message_ref_queued(m, bus);
500 bus->rqueue_size++;
501
502 return 0;
503 }
504
505 void bus_set_state(sd_bus *bus, enum bus_state state) {
506
507 static const char * const table[_BUS_STATE_MAX] = {
508 [BUS_UNSET] = "UNSET",
509 [BUS_WATCH_BIND] = "WATCH_BIND",
510 [BUS_OPENING] = "OPENING",
511 [BUS_AUTHENTICATING] = "AUTHENTICATING",
512 [BUS_HELLO] = "HELLO",
513 [BUS_RUNNING] = "RUNNING",
514 [BUS_CLOSING] = "CLOSING",
515 [BUS_CLOSED] = "CLOSED",
516 };
517
518 assert(bus);
519 assert(state < _BUS_STATE_MAX);
520
521 if (state == bus->state)
522 return;
523
524 log_debug("Bus %s: changing state %s → %s", strna(bus->description), table[bus->state], table[state]);
525 bus->state = state;
526 }
527
528 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
529 const char *s;
530 sd_bus *bus;
531 int r;
532
533 assert(reply);
534 bus = reply->bus;
535 assert(bus);
536 assert(IN_SET(bus->state, BUS_HELLO, BUS_CLOSING));
537
538 r = sd_bus_message_get_errno(reply);
539 if (r > 0)
540 return -r;
541
542 r = sd_bus_message_read(reply, "s", &s);
543 if (r < 0)
544 return r;
545
546 if (!service_name_is_valid(s) || s[0] != ':')
547 return -EBADMSG;
548
549 r = free_and_strdup(&bus->unique_name, s);
550 if (r < 0)
551 return r;
552
553 if (bus->state == BUS_HELLO) {
554 bus_set_state(bus, BUS_RUNNING);
555
556 r = synthesize_connected_signal(bus);
557 if (r < 0)
558 return r;
559 }
560
561 return 1;
562 }
563
564 static int bus_send_hello(sd_bus *bus) {
565 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
566 int r;
567
568 assert(bus);
569
570 if (!bus->bus_client)
571 return 0;
572
573 r = sd_bus_message_new_method_call(
574 bus,
575 &m,
576 "org.freedesktop.DBus",
577 "/org/freedesktop/DBus",
578 "org.freedesktop.DBus",
579 "Hello");
580 if (r < 0)
581 return r;
582
583 return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
584 }
585
586 int bus_start_running(sd_bus *bus) {
587 struct reply_callback *c;
588 Iterator i;
589 usec_t n;
590 int r;
591
592 assert(bus);
593 assert(bus->state < BUS_HELLO);
594
595 /* We start all method call timeouts when we enter BUS_HELLO or BUS_RUNNING mode. At this point let's convert
596 * all relative to absolute timestamps. Note that we do not reshuffle the reply callback priority queue since
597 * adding a fixed value to all entries should not alter the internal order. */
598
599 n = now(CLOCK_MONOTONIC);
600 ORDERED_HASHMAP_FOREACH(c, bus->reply_callbacks, i) {
601 if (c->timeout_usec == 0)
602 continue;
603
604 c->timeout_usec = usec_add(n, c->timeout_usec);
605 }
606
607 if (bus->bus_client) {
608 bus_set_state(bus, BUS_HELLO);
609 return 1;
610 }
611
612 bus_set_state(bus, BUS_RUNNING);
613
614 r = synthesize_connected_signal(bus);
615 if (r < 0)
616 return r;
617
618 return 1;
619 }
620
621 static int parse_address_key(const char **p, const char *key, char **value) {
622 size_t l, n = 0, allocated = 0;
623 _cleanup_free_ char *r = NULL;
624 const char *a;
625
626 assert(p);
627 assert(*p);
628 assert(value);
629
630 if (key) {
631 l = strlen(key);
632 if (strncmp(*p, key, l) != 0)
633 return 0;
634
635 if ((*p)[l] != '=')
636 return 0;
637
638 if (*value)
639 return -EINVAL;
640
641 a = *p + l + 1;
642 } else
643 a = *p;
644
645 while (!IN_SET(*a, ';', ',', 0)) {
646 char c;
647
648 if (*a == '%') {
649 int x, y;
650
651 x = unhexchar(a[1]);
652 if (x < 0)
653 return x;
654
655 y = unhexchar(a[2]);
656 if (y < 0)
657 return y;
658
659 c = (char) ((x << 4) | y);
660 a += 3;
661 } else {
662 c = *a;
663 a++;
664 }
665
666 if (!GREEDY_REALLOC(r, allocated, n + 2))
667 return -ENOMEM;
668
669 r[n++] = c;
670 }
671
672 if (!r) {
673 r = strdup("");
674 if (!r)
675 return -ENOMEM;
676 } else
677 r[n] = 0;
678
679 if (*a == ',')
680 a++;
681
682 *p = a;
683
684 free_and_replace(*value, r);
685
686 return 1;
687 }
688
689 static void skip_address_key(const char **p) {
690 assert(p);
691 assert(*p);
692
693 *p += strcspn(*p, ",");
694
695 if (**p == ',')
696 (*p)++;
697 }
698
699 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
700 _cleanup_free_ char *path = NULL, *abstract = NULL;
701 size_t l;
702 int r;
703
704 assert(b);
705 assert(p);
706 assert(*p);
707 assert(guid);
708
709 while (!IN_SET(**p, 0, ';')) {
710 r = parse_address_key(p, "guid", guid);
711 if (r < 0)
712 return r;
713 else if (r > 0)
714 continue;
715
716 r = parse_address_key(p, "path", &path);
717 if (r < 0)
718 return r;
719 else if (r > 0)
720 continue;
721
722 r = parse_address_key(p, "abstract", &abstract);
723 if (r < 0)
724 return r;
725 else if (r > 0)
726 continue;
727
728 skip_address_key(p);
729 }
730
731 if (!path && !abstract)
732 return -EINVAL;
733
734 if (path && abstract)
735 return -EINVAL;
736
737 if (path) {
738 l = strlen(path);
739 if (l >= sizeof(b->sockaddr.un.sun_path)) /* We insist on NUL termination */
740 return -E2BIG;
741
742 b->sockaddr.un = (struct sockaddr_un) {
743 .sun_family = AF_UNIX,
744 };
745
746 memcpy(b->sockaddr.un.sun_path, path, l);
747 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l + 1;
748
749 } else {
750 assert(abstract);
751
752 l = strlen(abstract);
753 if (l >= sizeof(b->sockaddr.un.sun_path) - 1) /* We insist on NUL termination */
754 return -E2BIG;
755
756 b->sockaddr.un = (struct sockaddr_un) {
757 .sun_family = AF_UNIX,
758 };
759
760 memcpy(b->sockaddr.un.sun_path+1, abstract, l);
761 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
762 }
763
764 b->is_local = true;
765
766 return 0;
767 }
768
769 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
770 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
771 int r;
772 struct addrinfo *result, hints = {
773 .ai_socktype = SOCK_STREAM,
774 .ai_flags = AI_ADDRCONFIG,
775 };
776
777 assert(b);
778 assert(p);
779 assert(*p);
780 assert(guid);
781
782 while (!IN_SET(**p, 0, ';')) {
783 r = parse_address_key(p, "guid", guid);
784 if (r < 0)
785 return r;
786 else if (r > 0)
787 continue;
788
789 r = parse_address_key(p, "host", &host);
790 if (r < 0)
791 return r;
792 else if (r > 0)
793 continue;
794
795 r = parse_address_key(p, "port", &port);
796 if (r < 0)
797 return r;
798 else if (r > 0)
799 continue;
800
801 r = parse_address_key(p, "family", &family);
802 if (r < 0)
803 return r;
804 else if (r > 0)
805 continue;
806
807 skip_address_key(p);
808 }
809
810 if (!host || !port)
811 return -EINVAL;
812
813 if (family) {
814 if (streq(family, "ipv4"))
815 hints.ai_family = AF_INET;
816 else if (streq(family, "ipv6"))
817 hints.ai_family = AF_INET6;
818 else
819 return -EINVAL;
820 }
821
822 r = getaddrinfo(host, port, &hints, &result);
823 if (r == EAI_SYSTEM)
824 return -errno;
825 else if (r != 0)
826 return -EADDRNOTAVAIL;
827
828 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
829 b->sockaddr_size = result->ai_addrlen;
830
831 freeaddrinfo(result);
832
833 b->is_local = false;
834
835 return 0;
836 }
837
838 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
839 char *path = NULL;
840 unsigned n_argv = 0, j;
841 char **argv = NULL;
842 size_t allocated = 0;
843 int r;
844
845 assert(b);
846 assert(p);
847 assert(*p);
848 assert(guid);
849
850 while (!IN_SET(**p, 0, ';')) {
851 r = parse_address_key(p, "guid", guid);
852 if (r < 0)
853 goto fail;
854 else if (r > 0)
855 continue;
856
857 r = parse_address_key(p, "path", &path);
858 if (r < 0)
859 goto fail;
860 else if (r > 0)
861 continue;
862
863 if (startswith(*p, "argv")) {
864 unsigned ul;
865
866 errno = 0;
867 ul = strtoul(*p + 4, (char**) p, 10);
868 if (errno > 0 || **p != '=' || ul > 256) {
869 r = -EINVAL;
870 goto fail;
871 }
872
873 (*p)++;
874
875 if (ul >= n_argv) {
876 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
877 r = -ENOMEM;
878 goto fail;
879 }
880
881 n_argv = ul + 1;
882 }
883
884 r = parse_address_key(p, NULL, argv + ul);
885 if (r < 0)
886 goto fail;
887
888 continue;
889 }
890
891 skip_address_key(p);
892 }
893
894 if (!path) {
895 r = -EINVAL;
896 goto fail;
897 }
898
899 /* Make sure there are no holes in the array, with the
900 * exception of argv[0] */
901 for (j = 1; j < n_argv; j++)
902 if (!argv[j]) {
903 r = -EINVAL;
904 goto fail;
905 }
906
907 if (argv && argv[0] == NULL) {
908 argv[0] = strdup(path);
909 if (!argv[0]) {
910 r = -ENOMEM;
911 goto fail;
912 }
913 }
914
915 b->exec_path = path;
916 b->exec_argv = argv;
917
918 b->is_local = false;
919
920 return 0;
921
922 fail:
923 for (j = 0; j < n_argv; j++)
924 free(argv[j]);
925
926 free(argv);
927 free(path);
928 return r;
929 }
930
931 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
932 _cleanup_free_ char *machine = NULL, *pid = NULL;
933 int r;
934
935 assert(b);
936 assert(p);
937 assert(*p);
938 assert(guid);
939
940 while (!IN_SET(**p, 0, ';')) {
941 r = parse_address_key(p, "guid", guid);
942 if (r < 0)
943 return r;
944 else if (r > 0)
945 continue;
946
947 r = parse_address_key(p, "machine", &machine);
948 if (r < 0)
949 return r;
950 else if (r > 0)
951 continue;
952
953 r = parse_address_key(p, "pid", &pid);
954 if (r < 0)
955 return r;
956 else if (r > 0)
957 continue;
958
959 skip_address_key(p);
960 }
961
962 if (!machine == !pid)
963 return -EINVAL;
964
965 if (machine) {
966 if (!streq(machine, ".host") && !machine_name_is_valid(machine))
967 return -EINVAL;
968
969 free_and_replace(b->machine, machine);
970 } else {
971 b->machine = mfree(b->machine);
972 }
973
974 if (pid) {
975 r = parse_pid(pid, &b->nspid);
976 if (r < 0)
977 return r;
978 } else
979 b->nspid = 0;
980
981 b->sockaddr.un = (struct sockaddr_un) {
982 .sun_family = AF_UNIX,
983 /* Note that we use the old /var/run prefix here, to increase compatibility with really old containers */
984 .sun_path = "/var/run/dbus/system_bus_socket",
985 };
986 b->sockaddr_size = SOCKADDR_UN_LEN(b->sockaddr.un);
987 b->is_local = false;
988
989 return 0;
990 }
991
992 static void bus_reset_parsed_address(sd_bus *b) {
993 assert(b);
994
995 zero(b->sockaddr);
996 b->sockaddr_size = 0;
997 b->exec_argv = strv_free(b->exec_argv);
998 b->exec_path = mfree(b->exec_path);
999 b->server_id = SD_ID128_NULL;
1000 b->machine = mfree(b->machine);
1001 b->nspid = 0;
1002 }
1003
1004 static int bus_parse_next_address(sd_bus *b) {
1005 _cleanup_free_ char *guid = NULL;
1006 const char *a;
1007 int r;
1008
1009 assert(b);
1010
1011 if (!b->address)
1012 return 0;
1013 if (b->address[b->address_index] == 0)
1014 return 0;
1015
1016 bus_reset_parsed_address(b);
1017
1018 a = b->address + b->address_index;
1019
1020 while (*a != 0) {
1021
1022 if (*a == ';') {
1023 a++;
1024 continue;
1025 }
1026
1027 if (startswith(a, "unix:")) {
1028 a += 5;
1029
1030 r = parse_unix_address(b, &a, &guid);
1031 if (r < 0)
1032 return r;
1033 break;
1034
1035 } else if (startswith(a, "tcp:")) {
1036
1037 a += 4;
1038 r = parse_tcp_address(b, &a, &guid);
1039 if (r < 0)
1040 return r;
1041
1042 break;
1043
1044 } else if (startswith(a, "unixexec:")) {
1045
1046 a += 9;
1047 r = parse_exec_address(b, &a, &guid);
1048 if (r < 0)
1049 return r;
1050
1051 break;
1052
1053 } else if (startswith(a, "x-machine-unix:")) {
1054
1055 a += 15;
1056 r = parse_container_unix_address(b, &a, &guid);
1057 if (r < 0)
1058 return r;
1059
1060 break;
1061 }
1062
1063 a = strchr(a, ';');
1064 if (!a)
1065 return 0;
1066 }
1067
1068 if (guid) {
1069 r = sd_id128_from_string(guid, &b->server_id);
1070 if (r < 0)
1071 return r;
1072 }
1073
1074 b->address_index = a - b->address;
1075 return 1;
1076 }
1077
1078 static void bus_kill_exec(sd_bus *bus) {
1079 if (pid_is_valid(bus->busexec_pid) > 0) {
1080 sigterm_wait(bus->busexec_pid);
1081 bus->busexec_pid = 0;
1082 }
1083 }
1084
1085 static int bus_start_address(sd_bus *b) {
1086 int r;
1087
1088 assert(b);
1089
1090 for (;;) {
1091 bus_close_io_fds(b);
1092 bus_close_inotify_fd(b);
1093
1094 bus_kill_exec(b);
1095
1096 /* If you provide multiple different bus-addresses, we
1097 * try all of them in order and use the first one that
1098 * succeeds. */
1099
1100 if (b->exec_path)
1101 r = bus_socket_exec(b);
1102 else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1103 r = bus_container_connect_socket(b);
1104 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
1105 r = bus_socket_connect(b);
1106 else
1107 goto next;
1108
1109 if (r >= 0) {
1110 int q;
1111
1112 q = bus_attach_io_events(b);
1113 if (q < 0)
1114 return q;
1115
1116 q = bus_attach_inotify_event(b);
1117 if (q < 0)
1118 return q;
1119
1120 return r;
1121 }
1122
1123 b->last_connect_error = -r;
1124
1125 next:
1126 r = bus_parse_next_address(b);
1127 if (r < 0)
1128 return r;
1129 if (r == 0)
1130 return b->last_connect_error > 0 ? -b->last_connect_error : -ECONNREFUSED;
1131 }
1132 }
1133
1134 int bus_next_address(sd_bus *b) {
1135 assert(b);
1136
1137 bus_reset_parsed_address(b);
1138 return bus_start_address(b);
1139 }
1140
1141 static int bus_start_fd(sd_bus *b) {
1142 struct stat st;
1143 int r;
1144
1145 assert(b);
1146 assert(b->input_fd >= 0);
1147 assert(b->output_fd >= 0);
1148
1149 r = fd_nonblock(b->input_fd, true);
1150 if (r < 0)
1151 return r;
1152
1153 r = fd_cloexec(b->input_fd, true);
1154 if (r < 0)
1155 return r;
1156
1157 if (b->input_fd != b->output_fd) {
1158 r = fd_nonblock(b->output_fd, true);
1159 if (r < 0)
1160 return r;
1161
1162 r = fd_cloexec(b->output_fd, true);
1163 if (r < 0)
1164 return r;
1165 }
1166
1167 if (fstat(b->input_fd, &st) < 0)
1168 return -errno;
1169
1170 return bus_socket_take_fd(b);
1171 }
1172
1173 _public_ int sd_bus_start(sd_bus *bus) {
1174 int r;
1175
1176 assert_return(bus, -EINVAL);
1177 assert_return(bus = bus_resolve(bus), -ENOPKG);
1178 assert_return(bus->state == BUS_UNSET, -EPERM);
1179 assert_return(!bus_pid_changed(bus), -ECHILD);
1180
1181 bus_set_state(bus, BUS_OPENING);
1182
1183 if (bus->is_server && bus->bus_client)
1184 return -EINVAL;
1185
1186 if (bus->input_fd >= 0)
1187 r = bus_start_fd(bus);
1188 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->machine)
1189 r = bus_start_address(bus);
1190 else
1191 return -EINVAL;
1192
1193 if (r < 0) {
1194 sd_bus_close(bus);
1195 return r;
1196 }
1197
1198 return bus_send_hello(bus);
1199 }
1200
1201 _public_ int sd_bus_open_with_description(sd_bus **ret, const char *description) {
1202 const char *e;
1203 _cleanup_(bus_freep) sd_bus *b = NULL;
1204 int r;
1205
1206 assert_return(ret, -EINVAL);
1207
1208 /* Let's connect to the starter bus if it is set, and
1209 * otherwise to the bus that is appropriate for the scope
1210 * we are running in */
1211
1212 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1213 if (e) {
1214 if (streq(e, "system"))
1215 return sd_bus_open_system_with_description(ret, description);
1216 else if (STR_IN_SET(e, "session", "user"))
1217 return sd_bus_open_user_with_description(ret, description);
1218 }
1219
1220 e = secure_getenv("DBUS_STARTER_ADDRESS");
1221 if (!e) {
1222 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1223 return sd_bus_open_user_with_description(ret, description);
1224 else
1225 return sd_bus_open_system_with_description(ret, description);
1226 }
1227
1228 r = sd_bus_new(&b);
1229 if (r < 0)
1230 return r;
1231
1232 r = sd_bus_set_address(b, e);
1233 if (r < 0)
1234 return r;
1235
1236 b->bus_client = true;
1237
1238 /* We don't know whether the bus is trusted or not, so better
1239 * be safe, and authenticate everything */
1240 b->trusted = false;
1241 b->is_local = false;
1242 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1243
1244 r = sd_bus_start(b);
1245 if (r < 0)
1246 return r;
1247
1248 *ret = TAKE_PTR(b);
1249 return 0;
1250 }
1251
1252 _public_ int sd_bus_open(sd_bus **ret) {
1253 return sd_bus_open_with_description(ret, NULL);
1254 }
1255
1256 int bus_set_address_system(sd_bus *b) {
1257 const char *e;
1258 assert(b);
1259
1260 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1261 if (e)
1262 return sd_bus_set_address(b, e);
1263
1264 return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1265 }
1266
1267 _public_ int sd_bus_open_system_with_description(sd_bus **ret, const char *description) {
1268 _cleanup_(bus_freep) sd_bus *b = NULL;
1269 int r;
1270
1271 assert_return(ret, -EINVAL);
1272
1273 r = sd_bus_new(&b);
1274 if (r < 0)
1275 return r;
1276
1277 if (description) {
1278 r = sd_bus_set_description(b, description);
1279 if (r < 0)
1280 return r;
1281 }
1282
1283 r = bus_set_address_system(b);
1284 if (r < 0)
1285 return r;
1286
1287 b->bus_client = true;
1288 b->is_system = true;
1289
1290 /* Let's do per-method access control on the system bus. We
1291 * need the caller's UID and capability set for that. */
1292 b->trusted = false;
1293 b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1294 b->is_local = true;
1295
1296 r = sd_bus_start(b);
1297 if (r < 0)
1298 return r;
1299
1300 *ret = TAKE_PTR(b);
1301 return 0;
1302 }
1303
1304 _public_ int sd_bus_open_system(sd_bus **ret) {
1305 return sd_bus_open_system_with_description(ret, NULL);
1306 }
1307
1308 int bus_set_address_user(sd_bus *b) {
1309 const char *e;
1310 _cleanup_free_ char *ee = NULL, *s = NULL;
1311
1312 assert(b);
1313
1314 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1315 if (e)
1316 return sd_bus_set_address(b, e);
1317
1318 e = secure_getenv("XDG_RUNTIME_DIR");
1319 if (!e)
1320 return -ENOENT;
1321
1322 ee = bus_address_escape(e);
1323 if (!ee)
1324 return -ENOMEM;
1325
1326 if (asprintf(&s, DEFAULT_USER_BUS_ADDRESS_FMT, ee) < 0)
1327 return -ENOMEM;
1328
1329 b->address = TAKE_PTR(s);
1330
1331 return 0;
1332 }
1333
1334 _public_ int sd_bus_open_user_with_description(sd_bus **ret, const char *description) {
1335 _cleanup_(bus_freep) sd_bus *b = NULL;
1336 int r;
1337
1338 assert_return(ret, -EINVAL);
1339
1340 r = sd_bus_new(&b);
1341 if (r < 0)
1342 return r;
1343
1344 if (description) {
1345 r = sd_bus_set_description(b, description);
1346 if (r < 0)
1347 return r;
1348 }
1349
1350 r = bus_set_address_user(b);
1351 if (r < 0)
1352 return r;
1353
1354 b->bus_client = true;
1355 b->is_user = true;
1356
1357 /* We don't do any per-method access control on the user 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 m->read_counter = ++bus->read_counter;
2426
2427 r = bus_seal_synthetic_message(bus, m);
2428 if (r < 0)
2429 return r;
2430
2431 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2432 c->timeout_usec = 0;
2433
2434 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2435 c->cookie = 0;
2436
2437 slot = container_of(c, sd_bus_slot, reply_callback);
2438
2439 bus->iteration_counter++;
2440
2441 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2442
2443 bus->current_message = m;
2444 bus->current_slot = sd_bus_slot_ref(slot);
2445 bus->current_handler = c->callback;
2446 bus->current_userdata = slot->userdata;
2447 r = c->callback(m, slot->userdata, &error_buffer);
2448 bus->current_userdata = NULL;
2449 bus->current_handler = NULL;
2450 bus->current_slot = NULL;
2451 bus->current_message = NULL;
2452
2453 if (slot->floating)
2454 bus_slot_disconnect(slot, true);
2455
2456 sd_bus_slot_unref(slot);
2457
2458 /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2459 * and ignore the callback handler's return value. */
2460 if (is_hello)
2461 return r;
2462
2463 return bus_maybe_reply_error(m, r, &error_buffer);
2464 }
2465
2466 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2467 assert(bus);
2468 assert(m);
2469
2470 if (bus->state != BUS_HELLO)
2471 return 0;
2472
2473 /* Let's make sure the first message on the bus is the HELLO
2474 * reply. But note that we don't actually parse the message
2475 * here (we leave that to the usual handling), we just verify
2476 * we don't let any earlier msg through. */
2477
2478 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2479 return -EIO;
2480
2481 if (m->reply_cookie != 1)
2482 return -EIO;
2483
2484 return 0;
2485 }
2486
2487 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2488 _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2489 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2490 struct reply_callback *c;
2491 sd_bus_slot *slot;
2492 bool is_hello;
2493 int r;
2494
2495 assert(bus);
2496 assert(m);
2497
2498 if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2499 return 0;
2500
2501 if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2502 return 0;
2503
2504 c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2505 if (!c)
2506 return 0;
2507
2508 c->cookie = 0;
2509
2510 slot = container_of(c, sd_bus_slot, reply_callback);
2511
2512 if (m->n_fds > 0 && !bus->accept_fd) {
2513
2514 /* If the reply contained a file descriptor which we
2515 * didn't want we pass an error instead. */
2516
2517 r = bus_message_new_synthetic_error(
2518 bus,
2519 m->reply_cookie,
2520 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2521 &synthetic_reply);
2522 if (r < 0)
2523 return r;
2524
2525 /* Copy over original timestamp */
2526 synthetic_reply->realtime = m->realtime;
2527 synthetic_reply->monotonic = m->monotonic;
2528 synthetic_reply->seqnum = m->seqnum;
2529 synthetic_reply->read_counter = m->read_counter;
2530
2531 r = bus_seal_synthetic_message(bus, synthetic_reply);
2532 if (r < 0)
2533 return r;
2534
2535 m = synthetic_reply;
2536 } else {
2537 r = sd_bus_message_rewind(m, true);
2538 if (r < 0)
2539 return r;
2540 }
2541
2542 if (c->timeout_usec != 0) {
2543 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2544 c->timeout_usec = 0;
2545 }
2546
2547 is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2548
2549 bus->current_slot = sd_bus_slot_ref(slot);
2550 bus->current_handler = c->callback;
2551 bus->current_userdata = slot->userdata;
2552 r = c->callback(m, slot->userdata, &error_buffer);
2553 bus->current_userdata = NULL;
2554 bus->current_handler = NULL;
2555 bus->current_slot = NULL;
2556
2557 if (slot->floating)
2558 bus_slot_disconnect(slot, true);
2559
2560 sd_bus_slot_unref(slot);
2561
2562 /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2563 * ignore the callback handler's return value. */
2564 if (is_hello)
2565 return r;
2566
2567 return bus_maybe_reply_error(m, r, &error_buffer);
2568 }
2569
2570 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2571 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2572 struct filter_callback *l;
2573 int r;
2574
2575 assert(bus);
2576 assert(m);
2577
2578 do {
2579 bus->filter_callbacks_modified = false;
2580
2581 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2582 sd_bus_slot *slot;
2583
2584 if (bus->filter_callbacks_modified)
2585 break;
2586
2587 /* Don't run this more than once per iteration */
2588 if (l->last_iteration == bus->iteration_counter)
2589 continue;
2590
2591 l->last_iteration = bus->iteration_counter;
2592
2593 r = sd_bus_message_rewind(m, true);
2594 if (r < 0)
2595 return r;
2596
2597 slot = container_of(l, sd_bus_slot, filter_callback);
2598
2599 bus->current_slot = sd_bus_slot_ref(slot);
2600 bus->current_handler = l->callback;
2601 bus->current_userdata = slot->userdata;
2602 r = l->callback(m, slot->userdata, &error_buffer);
2603 bus->current_userdata = NULL;
2604 bus->current_handler = NULL;
2605 bus->current_slot = sd_bus_slot_unref(slot);
2606
2607 r = bus_maybe_reply_error(m, r, &error_buffer);
2608 if (r != 0)
2609 return r;
2610
2611 }
2612
2613 } while (bus->filter_callbacks_modified);
2614
2615 return 0;
2616 }
2617
2618 static int process_match(sd_bus *bus, sd_bus_message *m) {
2619 int r;
2620
2621 assert(bus);
2622 assert(m);
2623
2624 do {
2625 bus->match_callbacks_modified = false;
2626
2627 r = bus_match_run(bus, &bus->match_callbacks, m);
2628 if (r != 0)
2629 return r;
2630
2631 } while (bus->match_callbacks_modified);
2632
2633 return 0;
2634 }
2635
2636 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2637 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2638 int r;
2639
2640 assert(bus);
2641 assert(m);
2642
2643 if (bus->is_monitor)
2644 return 0;
2645
2646 if (bus->manual_peer_interface)
2647 return 0;
2648
2649 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2650 return 0;
2651
2652 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2653 return 0;
2654
2655 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2656 return 1;
2657
2658 if (streq_ptr(m->member, "Ping"))
2659 r = sd_bus_message_new_method_return(m, &reply);
2660 else if (streq_ptr(m->member, "GetMachineId")) {
2661 sd_id128_t id;
2662 char sid[33];
2663
2664 r = sd_id128_get_machine(&id);
2665 if (r < 0)
2666 return r;
2667
2668 r = sd_bus_message_new_method_return(m, &reply);
2669 if (r < 0)
2670 return r;
2671
2672 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2673 } else {
2674 r = sd_bus_message_new_method_errorf(
2675 m, &reply,
2676 SD_BUS_ERROR_UNKNOWN_METHOD,
2677 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2678 }
2679 if (r < 0)
2680 return r;
2681
2682 r = sd_bus_send(bus, reply, NULL);
2683 if (r < 0)
2684 return r;
2685
2686 return 1;
2687 }
2688
2689 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2690 assert(bus);
2691 assert(m);
2692
2693 /* If we got a message with a file descriptor which we didn't
2694 * want to accept, then let's drop it. How can this even
2695 * happen? For example, when the kernel queues a message into
2696 * an activatable names's queue which allows fds, and then is
2697 * delivered to us later even though we ourselves did not
2698 * negotiate it. */
2699
2700 if (bus->is_monitor)
2701 return 0;
2702
2703 if (m->n_fds <= 0)
2704 return 0;
2705
2706 if (bus->accept_fd)
2707 return 0;
2708
2709 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2710 return 1; /* just eat it up */
2711
2712 return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2713 }
2714
2715 static int process_message(sd_bus *bus, sd_bus_message *m) {
2716 int r;
2717
2718 assert(bus);
2719 assert(m);
2720
2721 bus->current_message = m;
2722 bus->iteration_counter++;
2723
2724 log_debug_bus_message(m);
2725
2726 r = process_hello(bus, m);
2727 if (r != 0)
2728 goto finish;
2729
2730 r = process_reply(bus, m);
2731 if (r != 0)
2732 goto finish;
2733
2734 r = process_fd_check(bus, m);
2735 if (r != 0)
2736 goto finish;
2737
2738 r = process_filter(bus, m);
2739 if (r != 0)
2740 goto finish;
2741
2742 r = process_match(bus, m);
2743 if (r != 0)
2744 goto finish;
2745
2746 r = process_builtin(bus, m);
2747 if (r != 0)
2748 goto finish;
2749
2750 r = bus_process_object(bus, m);
2751
2752 finish:
2753 bus->current_message = NULL;
2754 return r;
2755 }
2756
2757 static int dispatch_track(sd_bus *bus) {
2758 assert(bus);
2759
2760 if (!bus->track_queue)
2761 return 0;
2762
2763 bus_track_dispatch(bus->track_queue);
2764 return 1;
2765 }
2766
2767 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2768 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2769 int r;
2770
2771 assert(bus);
2772 assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2773
2774 r = process_timeout(bus);
2775 if (r != 0)
2776 goto null_message;
2777
2778 r = dispatch_wqueue(bus);
2779 if (r != 0)
2780 goto null_message;
2781
2782 r = dispatch_track(bus);
2783 if (r != 0)
2784 goto null_message;
2785
2786 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2787 if (r < 0)
2788 return r;
2789 if (!m)
2790 goto null_message;
2791
2792 r = process_message(bus, m);
2793 if (r != 0)
2794 goto null_message;
2795
2796 if (ret) {
2797 r = sd_bus_message_rewind(m, true);
2798 if (r < 0)
2799 return r;
2800
2801 *ret = TAKE_PTR(m);
2802 return 1;
2803 }
2804
2805 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2806
2807 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2808 strna(sd_bus_message_get_sender(m)),
2809 strna(sd_bus_message_get_path(m)),
2810 strna(sd_bus_message_get_interface(m)),
2811 strna(sd_bus_message_get_member(m)));
2812
2813 r = sd_bus_reply_method_errorf(
2814 m,
2815 SD_BUS_ERROR_UNKNOWN_OBJECT,
2816 "Unknown object '%s'.", m->path);
2817 if (r < 0)
2818 return r;
2819 }
2820
2821 return 1;
2822
2823 null_message:
2824 if (r >= 0 && ret)
2825 *ret = NULL;
2826
2827 return r;
2828 }
2829
2830 static int bus_exit_now(sd_bus *bus) {
2831 assert(bus);
2832
2833 /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2834 * sd_event_exit(), otherwise invokes libc exit(). */
2835
2836 if (bus->exited) /* did we already exit? */
2837 return 0;
2838 if (!bus->exit_triggered) /* was the exit condition triggered? */
2839 return 0;
2840 if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2841 return 0;
2842
2843 bus->exited = true; /* never exit more than once */
2844
2845 log_debug("Bus connection disconnected, exiting.");
2846
2847 if (bus->event)
2848 return sd_event_exit(bus->event, EXIT_FAILURE);
2849 else
2850 exit(EXIT_FAILURE);
2851
2852 assert_not_reached("exit() didn't exit?");
2853 }
2854
2855 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2856 _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2857 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2858 sd_bus_slot *slot;
2859 int r;
2860
2861 assert(bus);
2862 assert(c);
2863
2864 r = bus_message_new_synthetic_error(
2865 bus,
2866 c->cookie,
2867 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2868 &m);
2869 if (r < 0)
2870 return r;
2871
2872 m->read_counter = ++bus->read_counter;
2873
2874 r = bus_seal_synthetic_message(bus, m);
2875 if (r < 0)
2876 return r;
2877
2878 if (c->timeout_usec != 0) {
2879 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2880 c->timeout_usec = 0;
2881 }
2882
2883 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2884 c->cookie = 0;
2885
2886 slot = container_of(c, sd_bus_slot, reply_callback);
2887
2888 bus->iteration_counter++;
2889
2890 bus->current_message = m;
2891 bus->current_slot = sd_bus_slot_ref(slot);
2892 bus->current_handler = c->callback;
2893 bus->current_userdata = slot->userdata;
2894 r = c->callback(m, slot->userdata, &error_buffer);
2895 bus->current_userdata = NULL;
2896 bus->current_handler = NULL;
2897 bus->current_slot = NULL;
2898 bus->current_message = NULL;
2899
2900 if (slot->floating)
2901 bus_slot_disconnect(slot, true);
2902
2903 sd_bus_slot_unref(slot);
2904
2905 return bus_maybe_reply_error(m, r, &error_buffer);
2906 }
2907
2908 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2909 _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2910 struct reply_callback *c;
2911 int r;
2912
2913 assert(bus);
2914 assert(bus->state == BUS_CLOSING);
2915
2916 /* First, fail all outstanding method calls */
2917 c = ordered_hashmap_first(bus->reply_callbacks);
2918 if (c)
2919 return process_closing_reply_callback(bus, c);
2920
2921 /* Then, fake-drop all remaining bus tracking references */
2922 if (bus->tracks) {
2923 bus_track_close(bus->tracks);
2924 return 1;
2925 }
2926
2927 /* Then, synthesize a Disconnected message */
2928 r = sd_bus_message_new_signal(
2929 bus,
2930 &m,
2931 "/org/freedesktop/DBus/Local",
2932 "org.freedesktop.DBus.Local",
2933 "Disconnected");
2934 if (r < 0)
2935 return r;
2936
2937 bus_message_set_sender_local(bus, m);
2938 m->read_counter = ++bus->read_counter;
2939
2940 r = bus_seal_synthetic_message(bus, m);
2941 if (r < 0)
2942 return r;
2943
2944 sd_bus_close(bus);
2945
2946 bus->current_message = m;
2947 bus->iteration_counter++;
2948
2949 r = process_filter(bus, m);
2950 if (r != 0)
2951 goto finish;
2952
2953 r = process_match(bus, m);
2954 if (r != 0)
2955 goto finish;
2956
2957 /* Nothing else to do, exit now, if the condition holds */
2958 bus->exit_triggered = true;
2959 (void) bus_exit_now(bus);
2960
2961 if (ret)
2962 *ret = TAKE_PTR(m);
2963
2964 r = 1;
2965
2966 finish:
2967 bus->current_message = NULL;
2968
2969 return r;
2970 }
2971
2972 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2973 int r;
2974
2975 /* Returns 0 when we didn't do anything. This should cause the
2976 * caller to invoke sd_bus_wait() before returning the next
2977 * time. Returns > 0 when we did something, which possibly
2978 * means *ret is filled in with an unprocessed message. */
2979
2980 assert_return(bus, -EINVAL);
2981 assert_return(bus = bus_resolve(bus), -ENOPKG);
2982 assert_return(!bus_pid_changed(bus), -ECHILD);
2983
2984 /* We don't allow recursively invoking sd_bus_process(). */
2985 assert_return(!bus->current_message, -EBUSY);
2986 assert(!bus->current_slot); /* This should be NULL whenever bus->current_message is */
2987
2988 BUS_DONT_DESTROY(bus);
2989
2990 switch (bus->state) {
2991
2992 case BUS_UNSET:
2993 return -ENOTCONN;
2994
2995 case BUS_CLOSED:
2996 return -ECONNRESET;
2997
2998 case BUS_WATCH_BIND:
2999 r = bus_socket_process_watch_bind(bus);
3000 break;
3001
3002 case BUS_OPENING:
3003 r = bus_socket_process_opening(bus);
3004 break;
3005
3006 case BUS_AUTHENTICATING:
3007 r = bus_socket_process_authenticating(bus);
3008 break;
3009
3010 case BUS_RUNNING:
3011 case BUS_HELLO:
3012 r = process_running(bus, hint_priority, priority, ret);
3013 if (r >= 0)
3014 return r;
3015
3016 /* This branch initializes *ret, hence we don't use the generic error checking below */
3017 break;
3018
3019 case BUS_CLOSING:
3020 return process_closing(bus, ret);
3021
3022 default:
3023 assert_not_reached("Unknown state");
3024 }
3025
3026 if (ERRNO_IS_DISCONNECT(r)) {
3027 bus_enter_closing(bus);
3028 r = 1;
3029 } else if (r < 0)
3030 return r;
3031
3032 if (ret)
3033 *ret = NULL;
3034
3035 return r;
3036 }
3037
3038 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
3039 return bus_process_internal(bus, false, 0, ret);
3040 }
3041
3042 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
3043 return bus_process_internal(bus, true, priority, ret);
3044 }
3045
3046 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
3047 struct pollfd p[2] = {};
3048 int r, n;
3049 struct timespec ts;
3050 usec_t m = USEC_INFINITY;
3051
3052 assert(bus);
3053
3054 if (bus->state == BUS_CLOSING)
3055 return 1;
3056
3057 if (!BUS_IS_OPEN(bus->state))
3058 return -ENOTCONN;
3059
3060 if (bus->state == BUS_WATCH_BIND) {
3061 assert(bus->inotify_fd >= 0);
3062
3063 p[0].events = POLLIN;
3064 p[0].fd = bus->inotify_fd;
3065 n = 1;
3066 } else {
3067 int e;
3068
3069 e = sd_bus_get_events(bus);
3070 if (e < 0)
3071 return e;
3072
3073 if (need_more)
3074 /* The caller really needs some more data, he doesn't
3075 * care about what's already read, or any timeouts
3076 * except its own. */
3077 e |= POLLIN;
3078 else {
3079 usec_t until;
3080 /* The caller wants to process if there's something to
3081 * process, but doesn't care otherwise */
3082
3083 r = sd_bus_get_timeout(bus, &until);
3084 if (r < 0)
3085 return r;
3086 if (r > 0)
3087 m = usec_sub_unsigned(until, now(CLOCK_MONOTONIC));
3088 }
3089
3090 p[0].fd = bus->input_fd;
3091 if (bus->output_fd == bus->input_fd) {
3092 p[0].events = e;
3093 n = 1;
3094 } else {
3095 p[0].events = e & POLLIN;
3096 p[1].fd = bus->output_fd;
3097 p[1].events = e & POLLOUT;
3098 n = 2;
3099 }
3100 }
3101
3102 if (timeout_usec != (uint64_t) -1 && (m == USEC_INFINITY || timeout_usec < m))
3103 m = timeout_usec;
3104
3105 r = ppoll(p, n, m == USEC_INFINITY ? NULL : timespec_store(&ts, m), NULL);
3106 if (r < 0)
3107 return -errno;
3108
3109 return r > 0 ? 1 : 0;
3110 }
3111
3112 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
3113
3114 assert_return(bus, -EINVAL);
3115 assert_return(bus = bus_resolve(bus), -ENOPKG);
3116 assert_return(!bus_pid_changed(bus), -ECHILD);
3117
3118 if (bus->state == BUS_CLOSING)
3119 return 0;
3120
3121 if (!BUS_IS_OPEN(bus->state))
3122 return -ENOTCONN;
3123
3124 if (bus->rqueue_size > 0)
3125 return 0;
3126
3127 return bus_poll(bus, false, timeout_usec);
3128 }
3129
3130 _public_ int sd_bus_flush(sd_bus *bus) {
3131 int r;
3132
3133 assert_return(bus, -EINVAL);
3134 assert_return(bus = bus_resolve(bus), -ENOPKG);
3135 assert_return(!bus_pid_changed(bus), -ECHILD);
3136
3137 if (bus->state == BUS_CLOSING)
3138 return 0;
3139
3140 if (!BUS_IS_OPEN(bus->state))
3141 return -ENOTCONN;
3142
3143 /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
3144 if (bus->state == BUS_WATCH_BIND)
3145 return -EUNATCH;
3146
3147 r = bus_ensure_running(bus);
3148 if (r < 0)
3149 return r;
3150
3151 if (bus->wqueue_size <= 0)
3152 return 0;
3153
3154 for (;;) {
3155 r = dispatch_wqueue(bus);
3156 if (r < 0) {
3157 if (ERRNO_IS_DISCONNECT(r)) {
3158 bus_enter_closing(bus);
3159 return -ECONNRESET;
3160 }
3161
3162 return r;
3163 }
3164
3165 if (bus->wqueue_size <= 0)
3166 return 0;
3167
3168 r = bus_poll(bus, false, (uint64_t) -1);
3169 if (r < 0)
3170 return r;
3171 }
3172 }
3173
3174 _public_ int sd_bus_add_filter(
3175 sd_bus *bus,
3176 sd_bus_slot **slot,
3177 sd_bus_message_handler_t callback,
3178 void *userdata) {
3179
3180 sd_bus_slot *s;
3181
3182 assert_return(bus, -EINVAL);
3183 assert_return(bus = bus_resolve(bus), -ENOPKG);
3184 assert_return(callback, -EINVAL);
3185 assert_return(!bus_pid_changed(bus), -ECHILD);
3186
3187 s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
3188 if (!s)
3189 return -ENOMEM;
3190
3191 s->filter_callback.callback = callback;
3192
3193 bus->filter_callbacks_modified = true;
3194 LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
3195
3196 if (slot)
3197 *slot = s;
3198
3199 return 0;
3200 }
3201
3202 static int add_match_callback(
3203 sd_bus_message *m,
3204 void *userdata,
3205 sd_bus_error *ret_error) {
3206
3207 sd_bus_slot *match_slot = userdata;
3208 bool failed = false;
3209 int r;
3210
3211 assert(m);
3212 assert(match_slot);
3213
3214 sd_bus_slot_ref(match_slot);
3215
3216 if (sd_bus_message_is_method_error(m, NULL)) {
3217 log_debug_errno(sd_bus_message_get_errno(m),
3218 "Unable to add match %s, failing connection: %s",
3219 match_slot->match_callback.match_string,
3220 sd_bus_message_get_error(m)->message);
3221
3222 failed = true;
3223 } else
3224 log_debug("Match %s successfully installed.", match_slot->match_callback.match_string);
3225
3226 if (match_slot->match_callback.install_callback) {
3227 sd_bus *bus;
3228
3229 bus = sd_bus_message_get_bus(m);
3230
3231 /* This function has been called as slot handler, and we want to call another slot handler. Let's
3232 * update the slot callback metadata temporarily with our own data, and then revert back to the old
3233 * values. */
3234
3235 assert(bus->current_slot == match_slot->match_callback.install_slot);
3236 assert(bus->current_handler == add_match_callback);
3237 assert(bus->current_userdata == userdata);
3238
3239 bus->current_slot = match_slot;
3240 bus->current_handler = match_slot->match_callback.install_callback;
3241 bus->current_userdata = match_slot->userdata;
3242
3243 r = match_slot->match_callback.install_callback(m, match_slot->userdata, ret_error);
3244
3245 bus->current_slot = match_slot->match_callback.install_slot;
3246 bus->current_handler = add_match_callback;
3247 bus->current_userdata = userdata;
3248 } else {
3249 if (failed) /* Generic failure handling: destroy the connection */
3250 bus_enter_closing(sd_bus_message_get_bus(m));
3251
3252 r = 1;
3253 }
3254
3255 /* We don't need the install method reply slot anymore, let's free it */
3256 match_slot->match_callback.install_slot = sd_bus_slot_unref(match_slot->match_callback.install_slot);
3257
3258 if (failed && match_slot->floating)
3259 bus_slot_disconnect(match_slot, true);
3260
3261 sd_bus_slot_unref(match_slot);
3262
3263 return r;
3264 }
3265
3266 static int bus_add_match_full(
3267 sd_bus *bus,
3268 sd_bus_slot **slot,
3269 bool asynchronous,
3270 const char *match,
3271 sd_bus_message_handler_t callback,
3272 sd_bus_message_handler_t install_callback,
3273 void *userdata) {
3274
3275 struct bus_match_component *components = NULL;
3276 unsigned n_components = 0;
3277 sd_bus_slot *s = NULL;
3278 int r = 0;
3279
3280 assert_return(bus, -EINVAL);
3281 assert_return(bus = bus_resolve(bus), -ENOPKG);
3282 assert_return(match, -EINVAL);
3283 assert_return(!bus_pid_changed(bus), -ECHILD);
3284
3285 r = bus_match_parse(match, &components, &n_components);
3286 if (r < 0)
3287 goto finish;
3288
3289 s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3290 if (!s) {
3291 r = -ENOMEM;
3292 goto finish;
3293 }
3294
3295 s->match_callback.callback = callback;
3296 s->match_callback.install_callback = install_callback;
3297
3298 if (bus->bus_client) {
3299 enum bus_match_scope scope;
3300
3301 scope = bus_match_get_scope(components, n_components);
3302
3303 /* Do not install server-side matches for matches against the local service, interface or bus path. */
3304 if (scope != BUS_MATCH_LOCAL) {
3305
3306 /* We store the original match string, so that we can use it to remove the match again. */
3307
3308 s->match_callback.match_string = strdup(match);
3309 if (!s->match_callback.match_string) {
3310 r = -ENOMEM;
3311 goto finish;
3312 }
3313
3314 if (asynchronous) {
3315 r = bus_add_match_internal_async(bus,
3316 &s->match_callback.install_slot,
3317 s->match_callback.match_string,
3318 add_match_callback,
3319 s);
3320
3321 if (r < 0)
3322 return r;
3323
3324 /* Make the slot of the match call floating now. We need the reference, but we don't
3325 * want that this match pins the bus object, hence we first create it non-floating, but
3326 * then make it floating. */
3327 r = sd_bus_slot_set_floating(s->match_callback.install_slot, true);
3328 } else
3329 r = bus_add_match_internal(bus, s->match_callback.match_string, &s->match_callback.after);
3330 if (r < 0)
3331 goto finish;
3332
3333 s->match_added = true;
3334 }
3335 }
3336
3337 bus->match_callbacks_modified = true;
3338 r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3339 if (r < 0)
3340 goto finish;
3341
3342 if (slot)
3343 *slot = s;
3344 s = NULL;
3345
3346 finish:
3347 bus_match_parse_free(components, n_components);
3348 sd_bus_slot_unref(s);
3349
3350 return r;
3351 }
3352
3353 _public_ int sd_bus_add_match(
3354 sd_bus *bus,
3355 sd_bus_slot **slot,
3356 const char *match,
3357 sd_bus_message_handler_t callback,
3358 void *userdata) {
3359
3360 return bus_add_match_full(bus, slot, false, match, callback, NULL, userdata);
3361 }
3362
3363 _public_ int sd_bus_add_match_async(
3364 sd_bus *bus,
3365 sd_bus_slot **slot,
3366 const char *match,
3367 sd_bus_message_handler_t callback,
3368 sd_bus_message_handler_t install_callback,
3369 void *userdata) {
3370
3371 return bus_add_match_full(bus, slot, true, match, callback, install_callback, userdata);
3372 }
3373
3374 bool bus_pid_changed(sd_bus *bus) {
3375 assert(bus);
3376
3377 /* We don't support people creating a bus connection and
3378 * keeping it around over a fork(). Let's complain. */
3379
3380 return bus->original_pid != getpid_cached();
3381 }
3382
3383 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3384 sd_bus *bus = userdata;
3385 int r;
3386
3387 assert(bus);
3388
3389 /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3390
3391 r = sd_bus_process(bus, NULL);
3392 if (r < 0) {
3393 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3394 bus_enter_closing(bus);
3395 }
3396
3397 return 1;
3398 }
3399
3400 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3401 sd_bus *bus = userdata;
3402 int r;
3403
3404 assert(bus);
3405
3406 r = sd_bus_process(bus, NULL);
3407 if (r < 0) {
3408 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3409 bus_enter_closing(bus);
3410 }
3411
3412 return 1;
3413 }
3414
3415 static int prepare_callback(sd_event_source *s, void *userdata) {
3416 sd_bus *bus = userdata;
3417 int r, e;
3418 usec_t until;
3419
3420 assert(s);
3421 assert(bus);
3422
3423 e = sd_bus_get_events(bus);
3424 if (e < 0) {
3425 r = e;
3426 goto fail;
3427 }
3428
3429 if (bus->output_fd != bus->input_fd) {
3430
3431 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3432 if (r < 0)
3433 goto fail;
3434
3435 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3436 } else
3437 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3438 if (r < 0)
3439 goto fail;
3440
3441 r = sd_bus_get_timeout(bus, &until);
3442 if (r < 0)
3443 goto fail;
3444 if (r > 0) {
3445 int j;
3446
3447 j = sd_event_source_set_time(bus->time_event_source, until);
3448 if (j < 0) {
3449 r = j;
3450 goto fail;
3451 }
3452 }
3453
3454 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3455 if (r < 0)
3456 goto fail;
3457
3458 return 1;
3459
3460 fail:
3461 log_debug_errno(r, "Preparing of bus events failed, closing down: %m");
3462 bus_enter_closing(bus);
3463
3464 return 1;
3465 }
3466
3467 static int quit_callback(sd_event_source *event, void *userdata) {
3468 sd_bus *bus = userdata;
3469
3470 assert(event);
3471
3472 if (bus->close_on_exit) {
3473 sd_bus_flush(bus);
3474 sd_bus_close(bus);
3475 }
3476
3477 return 1;
3478 }
3479
3480 int bus_attach_io_events(sd_bus *bus) {
3481 int r;
3482
3483 assert(bus);
3484
3485 if (bus->input_fd < 0)
3486 return 0;
3487
3488 if (!bus->event)
3489 return 0;
3490
3491 if (!bus->input_io_event_source) {
3492 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3493 if (r < 0)
3494 return r;
3495
3496 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3497 if (r < 0)
3498 return r;
3499
3500 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3501 if (r < 0)
3502 return r;
3503
3504 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3505 } else
3506 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3507
3508 if (r < 0)
3509 return r;
3510
3511 if (bus->output_fd != bus->input_fd) {
3512 assert(bus->output_fd >= 0);
3513
3514 if (!bus->output_io_event_source) {
3515 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3516 if (r < 0)
3517 return r;
3518
3519 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3520 if (r < 0)
3521 return r;
3522
3523 r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3524 } else
3525 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3526
3527 if (r < 0)
3528 return r;
3529 }
3530
3531 return 0;
3532 }
3533
3534 static void bus_detach_io_events(sd_bus *bus) {
3535 assert(bus);
3536
3537 if (bus->input_io_event_source) {
3538 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3539 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3540 }
3541
3542 if (bus->output_io_event_source) {
3543 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3544 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3545 }
3546 }
3547
3548 int bus_attach_inotify_event(sd_bus *bus) {
3549 int r;
3550
3551 assert(bus);
3552
3553 if (bus->inotify_fd < 0)
3554 return 0;
3555
3556 if (!bus->event)
3557 return 0;
3558
3559 if (!bus->inotify_event_source) {
3560 r = sd_event_add_io(bus->event, &bus->inotify_event_source, bus->inotify_fd, EPOLLIN, io_callback, bus);
3561 if (r < 0)
3562 return r;
3563
3564 r = sd_event_source_set_priority(bus->inotify_event_source, bus->event_priority);
3565 if (r < 0)
3566 return r;
3567
3568 r = sd_event_source_set_description(bus->inotify_event_source, "bus-inotify");
3569 } else
3570 r = sd_event_source_set_io_fd(bus->inotify_event_source, bus->inotify_fd);
3571 if (r < 0)
3572 return r;
3573
3574 return 0;
3575 }
3576
3577 static void bus_detach_inotify_event(sd_bus *bus) {
3578 assert(bus);
3579
3580 if (bus->inotify_event_source) {
3581 sd_event_source_set_enabled(bus->inotify_event_source, SD_EVENT_OFF);
3582 bus->inotify_event_source = sd_event_source_unref(bus->inotify_event_source);
3583 }
3584 }
3585
3586 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3587 int r;
3588
3589 assert_return(bus, -EINVAL);
3590 assert_return(bus = bus_resolve(bus), -ENOPKG);
3591 assert_return(!bus->event, -EBUSY);
3592
3593 assert(!bus->input_io_event_source);
3594 assert(!bus->output_io_event_source);
3595 assert(!bus->time_event_source);
3596
3597 if (event)
3598 bus->event = sd_event_ref(event);
3599 else {
3600 r = sd_event_default(&bus->event);
3601 if (r < 0)
3602 return r;
3603 }
3604
3605 bus->event_priority = priority;
3606
3607 r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3608 if (r < 0)
3609 goto fail;
3610
3611 r = sd_event_source_set_priority(bus->time_event_source, priority);
3612 if (r < 0)
3613 goto fail;
3614
3615 r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3616 if (r < 0)
3617 goto fail;
3618
3619 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3620 if (r < 0)
3621 goto fail;
3622
3623 r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3624 if (r < 0)
3625 goto fail;
3626
3627 r = bus_attach_io_events(bus);
3628 if (r < 0)
3629 goto fail;
3630
3631 r = bus_attach_inotify_event(bus);
3632 if (r < 0)
3633 goto fail;
3634
3635 return 0;
3636
3637 fail:
3638 sd_bus_detach_event(bus);
3639 return r;
3640 }
3641
3642 _public_ int sd_bus_detach_event(sd_bus *bus) {
3643 assert_return(bus, -EINVAL);
3644 assert_return(bus = bus_resolve(bus), -ENOPKG);
3645
3646 if (!bus->event)
3647 return 0;
3648
3649 bus_detach_io_events(bus);
3650 bus_detach_inotify_event(bus);
3651
3652 if (bus->time_event_source) {
3653 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3654 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3655 }
3656
3657 if (bus->quit_event_source) {
3658 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3659 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3660 }
3661
3662 bus->event = sd_event_unref(bus->event);
3663 return 1;
3664 }
3665
3666 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3667 assert_return(bus, NULL);
3668
3669 return bus->event;
3670 }
3671
3672 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3673 assert_return(bus, NULL);
3674
3675 return bus->current_message;
3676 }
3677
3678 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3679 assert_return(bus, NULL);
3680
3681 return bus->current_slot;
3682 }
3683
3684 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3685 assert_return(bus, NULL);
3686
3687 return bus->current_handler;
3688 }
3689
3690 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3691 assert_return(bus, NULL);
3692
3693 return bus->current_userdata;
3694 }
3695
3696 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3697 sd_bus *b = NULL;
3698 int r;
3699
3700 assert(bus_open);
3701 assert(default_bus);
3702
3703 if (!ret)
3704 return !!*default_bus;
3705
3706 if (*default_bus) {
3707 *ret = sd_bus_ref(*default_bus);
3708 return 0;
3709 }
3710
3711 r = bus_open(&b);
3712 if (r < 0)
3713 return r;
3714
3715 b->default_bus_ptr = default_bus;
3716 b->tid = gettid();
3717 *default_bus = b;
3718
3719 *ret = b;
3720 return 1;
3721 }
3722
3723 _public_ int sd_bus_default_system(sd_bus **ret) {
3724 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3725 }
3726
3727 _public_ int sd_bus_default_user(sd_bus **ret) {
3728 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3729 }
3730
3731 _public_ int sd_bus_default(sd_bus **ret) {
3732 int (*bus_open)(sd_bus **) = NULL;
3733 sd_bus **busp;
3734
3735 busp = bus_choose_default(&bus_open);
3736 return bus_default(bus_open, busp, ret);
3737 }
3738
3739 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3740 assert_return(b, -EINVAL);
3741 assert_return(tid, -EINVAL);
3742 assert_return(!bus_pid_changed(b), -ECHILD);
3743
3744 if (b->tid != 0) {
3745 *tid = b->tid;
3746 return 0;
3747 }
3748
3749 if (b->event)
3750 return sd_event_get_tid(b->event, tid);
3751
3752 return -ENXIO;
3753 }
3754
3755 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3756 _cleanup_free_ char *e = NULL;
3757 char *ret;
3758
3759 assert_return(object_path_is_valid(prefix), -EINVAL);
3760 assert_return(external_id, -EINVAL);
3761 assert_return(ret_path, -EINVAL);
3762
3763 e = bus_label_escape(external_id);
3764 if (!e)
3765 return -ENOMEM;
3766
3767 ret = path_join(prefix, e);
3768 if (!ret)
3769 return -ENOMEM;
3770
3771 *ret_path = ret;
3772 return 0;
3773 }
3774
3775 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3776 const char *e;
3777 char *ret;
3778
3779 assert_return(object_path_is_valid(path), -EINVAL);
3780 assert_return(object_path_is_valid(prefix), -EINVAL);
3781 assert_return(external_id, -EINVAL);
3782
3783 e = object_path_startswith(path, prefix);
3784 if (!e) {
3785 *external_id = NULL;
3786 return 0;
3787 }
3788
3789 ret = bus_label_unescape(e);
3790 if (!ret)
3791 return -ENOMEM;
3792
3793 *external_id = ret;
3794 return 1;
3795 }
3796
3797 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3798 _cleanup_strv_free_ char **labels = NULL;
3799 char *path, *path_pos, **label_pos;
3800 const char *sep, *template_pos;
3801 size_t path_length;
3802 va_list list;
3803 int r;
3804
3805 assert_return(out, -EINVAL);
3806 assert_return(path_template, -EINVAL);
3807
3808 path_length = strlen(path_template);
3809
3810 va_start(list, path_template);
3811 for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3812 const char *arg;
3813 char *label;
3814
3815 arg = va_arg(list, const char *);
3816 if (!arg) {
3817 va_end(list);
3818 return -EINVAL;
3819 }
3820
3821 label = bus_label_escape(arg);
3822 if (!label) {
3823 va_end(list);
3824 return -ENOMEM;
3825 }
3826
3827 r = strv_consume(&labels, label);
3828 if (r < 0) {
3829 va_end(list);
3830 return r;
3831 }
3832
3833 /* add label length, but account for the format character */
3834 path_length += strlen(label) - 1;
3835 }
3836 va_end(list);
3837
3838 path = malloc(path_length + 1);
3839 if (!path)
3840 return -ENOMEM;
3841
3842 path_pos = path;
3843 label_pos = labels;
3844
3845 for (template_pos = path_template; *template_pos; ) {
3846 sep = strchrnul(template_pos, '%');
3847 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3848 if (!*sep)
3849 break;
3850
3851 path_pos = stpcpy(path_pos, *label_pos++);
3852 template_pos = sep + 1;
3853 }
3854
3855 *path_pos = 0;
3856 *out = path;
3857 return 0;
3858 }
3859
3860 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3861 _cleanup_strv_free_ char **labels = NULL;
3862 const char *template_pos, *path_pos;
3863 char **label_pos;
3864 va_list list;
3865 int r;
3866
3867 /*
3868 * This decodes an object-path based on a template argument. The
3869 * template consists of a verbatim path, optionally including special
3870 * directives:
3871 *
3872 * - Each occurrence of '%' in the template matches an arbitrary
3873 * substring of a label in the given path. At most one such
3874 * directive is allowed per label. For each such directive, the
3875 * caller must provide an output parameter (char **) via va_arg. If
3876 * NULL is passed, the given label is verified, but not returned.
3877 * For each matched label, the *decoded* label is stored in the
3878 * passed output argument, and the caller is responsible to free
3879 * it. Note that the output arguments are only modified if the
3880 * actually path matched the template. Otherwise, they're left
3881 * untouched.
3882 *
3883 * This function returns <0 on error, 0 if the path does not match the
3884 * template, 1 if it matched.
3885 */
3886
3887 assert_return(path, -EINVAL);
3888 assert_return(path_template, -EINVAL);
3889
3890 path_pos = path;
3891
3892 for (template_pos = path_template; *template_pos; ) {
3893 const char *sep;
3894 size_t length;
3895 char *label;
3896
3897 /* verify everything until the next '%' matches verbatim */
3898 sep = strchrnul(template_pos, '%');
3899 length = sep - template_pos;
3900 if (strncmp(path_pos, template_pos, length))
3901 return 0;
3902
3903 path_pos += length;
3904 template_pos += length;
3905
3906 if (!*template_pos)
3907 break;
3908
3909 /* We found the next '%' character. Everything up until here
3910 * matched. We now skip ahead to the end of this label and make
3911 * sure it matches the tail of the label in the path. Then we
3912 * decode the string in-between and save it for later use. */
3913
3914 ++template_pos; /* skip over '%' */
3915
3916 sep = strchrnul(template_pos, '/');
3917 length = sep - template_pos; /* length of suffix to match verbatim */
3918
3919 /* verify the suffixes match */
3920 sep = strchrnul(path_pos, '/');
3921 if (sep - path_pos < (ssize_t)length ||
3922 strncmp(sep - length, template_pos, length))
3923 return 0;
3924
3925 template_pos += length; /* skip over matched label */
3926 length = sep - path_pos - length; /* length of sub-label to decode */
3927
3928 /* store unescaped label for later use */
3929 label = bus_label_unescape_n(path_pos, length);
3930 if (!label)
3931 return -ENOMEM;
3932
3933 r = strv_consume(&labels, label);
3934 if (r < 0)
3935 return r;
3936
3937 path_pos = sep; /* skip decoded label and suffix */
3938 }
3939
3940 /* end of template must match end of path */
3941 if (*path_pos)
3942 return 0;
3943
3944 /* copy the labels over to the caller */
3945 va_start(list, path_template);
3946 for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3947 char **arg;
3948
3949 arg = va_arg(list, char **);
3950 if (arg)
3951 *arg = *label_pos;
3952 else
3953 free(*label_pos);
3954 }
3955 va_end(list);
3956
3957 labels = mfree(labels);
3958 return 1;
3959 }
3960
3961 _public_ int sd_bus_try_close(sd_bus *bus) {
3962 assert_return(bus, -EINVAL);
3963 assert_return(bus = bus_resolve(bus), -ENOPKG);
3964 assert_return(!bus_pid_changed(bus), -ECHILD);
3965
3966 return -EOPNOTSUPP;
3967 }
3968
3969 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3970 assert_return(bus, -EINVAL);
3971 assert_return(bus = bus_resolve(bus), -ENOPKG);
3972 assert_return(description, -EINVAL);
3973 assert_return(bus->description, -ENXIO);
3974 assert_return(!bus_pid_changed(bus), -ECHILD);
3975
3976 if (bus->description)
3977 *description = bus->description;
3978 else if (bus->is_system)
3979 *description = "system";
3980 else if (bus->is_user)
3981 *description = "user";
3982 else
3983 *description = NULL;
3984
3985 return 0;
3986 }
3987
3988 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3989 assert_return(bus, -EINVAL);
3990 assert_return(bus = bus_resolve(bus), -ENOPKG);
3991 assert_return(scope, -EINVAL);
3992 assert_return(!bus_pid_changed(bus), -ECHILD);
3993
3994 if (bus->is_user) {
3995 *scope = "user";
3996 return 0;
3997 }
3998
3999 if (bus->is_system) {
4000 *scope = "system";
4001 return 0;
4002 }
4003
4004 return -ENODATA;
4005 }
4006
4007 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
4008
4009 assert_return(bus, -EINVAL);
4010 assert_return(bus = bus_resolve(bus), -ENOPKG);
4011 assert_return(address, -EINVAL);
4012 assert_return(!bus_pid_changed(bus), -ECHILD);
4013
4014 if (bus->address) {
4015 *address = bus->address;
4016 return 0;
4017 }
4018
4019 return -ENODATA;
4020 }
4021
4022 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
4023 assert_return(bus, -EINVAL);
4024 assert_return(bus = bus_resolve(bus), -ENOPKG);
4025 assert_return(mask, -EINVAL);
4026 assert_return(!bus_pid_changed(bus), -ECHILD);
4027
4028 *mask = bus->creds_mask;
4029 return 0;
4030 }
4031
4032 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
4033 assert_return(bus, -EINVAL);
4034 assert_return(bus = bus_resolve(bus), -ENOPKG);
4035 assert_return(!bus_pid_changed(bus), -ECHILD);
4036
4037 return bus->bus_client;
4038 }
4039
4040 _public_ int sd_bus_is_server(sd_bus *bus) {
4041 assert_return(bus, -EINVAL);
4042 assert_return(bus = bus_resolve(bus), -ENOPKG);
4043 assert_return(!bus_pid_changed(bus), -ECHILD);
4044
4045 return bus->is_server;
4046 }
4047
4048 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
4049 assert_return(bus, -EINVAL);
4050 assert_return(bus = bus_resolve(bus), -ENOPKG);
4051 assert_return(!bus_pid_changed(bus), -ECHILD);
4052
4053 return bus->anonymous_auth;
4054 }
4055
4056 _public_ int sd_bus_is_trusted(sd_bus *bus) {
4057 assert_return(bus, -EINVAL);
4058 assert_return(bus = bus_resolve(bus), -ENOPKG);
4059 assert_return(!bus_pid_changed(bus), -ECHILD);
4060
4061 return bus->trusted;
4062 }
4063
4064 _public_ int sd_bus_is_monitor(sd_bus *bus) {
4065 assert_return(bus, -EINVAL);
4066 assert_return(bus = bus_resolve(bus), -ENOPKG);
4067 assert_return(!bus_pid_changed(bus), -ECHILD);
4068
4069 return bus->is_monitor;
4070 }
4071
4072 static void flush_close(sd_bus *bus) {
4073 if (!bus)
4074 return;
4075
4076 /* Flushes and closes the specified bus. We take a ref before,
4077 * to ensure the flushing does not cause the bus to be
4078 * unreferenced. */
4079
4080 sd_bus_flush_close_unref(sd_bus_ref(bus));
4081 }
4082
4083 _public_ void sd_bus_default_flush_close(void) {
4084 flush_close(default_starter_bus);
4085 flush_close(default_user_bus);
4086 flush_close(default_system_bus);
4087 }
4088
4089 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
4090 assert_return(bus, -EINVAL);
4091 assert_return(bus = bus_resolve(bus), -ENOPKG);
4092
4093 /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
4094 * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
4095 * from the client side. */
4096 bus->exit_on_disconnect = b;
4097
4098 /* If the exit condition was triggered already, exit immediately. */
4099 return bus_exit_now(bus);
4100 }
4101
4102 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
4103 assert_return(bus, -EINVAL);
4104 assert_return(bus = bus_resolve(bus), -ENOPKG);
4105
4106 return bus->exit_on_disconnect;
4107 }
4108
4109 _public_ int sd_bus_set_sender(sd_bus *bus, const char *sender) {
4110 assert_return(bus, -EINVAL);
4111 assert_return(bus = bus_resolve(bus), -ENOPKG);
4112 assert_return(!bus->bus_client, -EPERM);
4113 assert_return(!sender || service_name_is_valid(sender), -EINVAL);
4114
4115 return free_and_strdup(&bus->patch_sender, sender);
4116 }
4117
4118 _public_ int sd_bus_get_sender(sd_bus *bus, const char **ret) {
4119 assert_return(bus, -EINVAL);
4120 assert_return(bus = bus_resolve(bus), -ENOPKG);
4121 assert_return(ret, -EINVAL);
4122
4123 if (!bus->patch_sender)
4124 return -ENODATA;
4125
4126 *ret = bus->patch_sender;
4127 return 0;
4128 }
4129
4130 _public_ int sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret) {
4131 assert_return(bus, -EINVAL);
4132 assert_return(bus = bus_resolve(bus), -ENOPKG);
4133 assert_return(!bus_pid_changed(bus), -ECHILD);
4134 assert_return(ret, -EINVAL);
4135
4136 *ret = bus->rqueue_size;
4137 return 0;
4138 }
4139
4140 _public_ int sd_bus_get_n_queued_write(sd_bus *bus, uint64_t *ret) {
4141 assert_return(bus, -EINVAL);
4142 assert_return(bus = bus_resolve(bus), -ENOPKG);
4143 assert_return(!bus_pid_changed(bus), -ECHILD);
4144 assert_return(ret, -EINVAL);
4145
4146 *ret = bus->wqueue_size;
4147 return 0;
4148 }
4149
4150 _public_ int sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec) {
4151 assert_return(bus, -EINVAL);
4152 assert_return(bus = bus_resolve(bus), -ENOPKG);
4153
4154 bus->method_call_timeout = usec;
4155 return 0;
4156 }
4157
4158 _public_ int sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret) {
4159 const char *e;
4160 usec_t usec;
4161
4162 assert_return(bus, -EINVAL);
4163 assert_return(bus = bus_resolve(bus), -ENOPKG);
4164 assert_return(ret, -EINVAL);
4165
4166 if (bus->method_call_timeout != 0) {
4167 *ret = bus->method_call_timeout;
4168 return 0;
4169 }
4170
4171 e = secure_getenv("SYSTEMD_BUS_TIMEOUT");
4172 if (e && parse_sec(e, &usec) >= 0 && usec != 0) {
4173 /* Save the parsed value to avoid multiple parsing. To change the timeout value,
4174 * use sd_bus_set_method_call_timeout() instead of setenv(). */
4175 *ret = bus->method_call_timeout = usec;
4176 return 0;
4177 }
4178
4179 *ret = bus->method_call_timeout = BUS_DEFAULT_TIMEOUT;
4180 return 0;
4181 }
4182
4183 _public_ int sd_bus_set_close_on_exit(sd_bus *bus, int b) {
4184 assert_return(bus, -EINVAL);
4185 assert_return(bus = bus_resolve(bus), -ENOPKG);
4186
4187 bus->close_on_exit = b;
4188 return 0;
4189 }
4190
4191 _public_ int sd_bus_get_close_on_exit(sd_bus *bus) {
4192 assert_return(bus, -EINVAL);
4193 assert_return(bus = bus_resolve(bus), -ENOPKG);
4194
4195 return bus->close_on_exit;
4196 }
4197