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