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