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