]> 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
bus: replace sd_bus_label_{escape,unescape}() by new sd_bus_path_{encode,decode}()
[thirdparty/systemd.git] / src / libsystemd / sd-bus / sd-bus.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <endian.h>
23 #include <assert.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <netdb.h>
27 #include <sys/poll.h>
28 #include <byteswap.h>
29 #include <sys/mman.h>
30 #include <pthread.h>
31
32 #include "util.h"
33 #include "macro.h"
34 #include "strv.h"
35 #include "set.h"
36 #include "missing.h"
37 #include "def.h"
38 #include "cgroup-util.h"
39 #include "bus-label.h"
40
41 #include "sd-bus.h"
42 #include "bus-internal.h"
43 #include "bus-message.h"
44 #include "bus-type.h"
45 #include "bus-socket.h"
46 #include "bus-kernel.h"
47 #include "bus-control.h"
48 #include "bus-introspect.h"
49 #include "bus-signature.h"
50 #include "bus-objects.h"
51 #include "bus-util.h"
52 #include "bus-container.h"
53 #include "bus-protocol.h"
54 #include "bus-track.h"
55
56 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
57 static int attach_io_events(sd_bus *b);
58 static void detach_io_events(sd_bus *b);
59
60 static void bus_close_fds(sd_bus *b) {
61 assert(b);
62
63 detach_io_events(b);
64
65 if (b->input_fd >= 0)
66 close_nointr_nofail(b->input_fd);
67
68 if (b->output_fd >= 0 && b->output_fd != b->input_fd)
69 close_nointr_nofail(b->output_fd);
70
71 b->input_fd = b->output_fd = -1;
72 }
73
74 static void bus_node_destroy(sd_bus *b, struct node *n) {
75 struct node_callback *c;
76 struct node_vtable *v;
77 struct node_enumerator *e;
78
79 assert(b);
80
81 if (!n)
82 return;
83
84 while (n->child)
85 bus_node_destroy(b, n->child);
86
87 while ((c = n->callbacks)) {
88 LIST_REMOVE(callbacks, n->callbacks, c);
89 free(c);
90 }
91
92 while ((v = n->vtables)) {
93 LIST_REMOVE(vtables, n->vtables, v);
94 free(v->interface);
95 free(v);
96 }
97
98 while ((e = n->enumerators)) {
99 LIST_REMOVE(enumerators, n->enumerators, e);
100 free(e);
101 }
102
103 if (n->parent)
104 LIST_REMOVE(siblings, n->parent->child, n);
105
106 assert_se(hashmap_remove(b->nodes, n->path) == n);
107 free(n->path);
108 free(n);
109 }
110
111 static void bus_reset_queues(sd_bus *b) {
112 assert(b);
113
114 while (b->rqueue_size > 0)
115 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
116
117 free(b->rqueue);
118 b->rqueue = NULL;
119 b->rqueue_allocated = 0;
120
121 while (b->wqueue_size > 0)
122 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
123
124 free(b->wqueue);
125 b->wqueue = NULL;
126 b->wqueue_allocated = 0;
127 }
128
129 static void bus_free(sd_bus *b) {
130 struct filter_callback *f;
131 struct node *n;
132
133 assert(b);
134
135 assert(!b->track_queue);
136
137 sd_bus_detach_event(b);
138
139 if (b->default_bus_ptr)
140 *b->default_bus_ptr = NULL;
141
142 bus_close_fds(b);
143
144 if (b->kdbus_buffer)
145 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
146
147 free(b->rbuffer);
148 free(b->unique_name);
149 free(b->auth_buffer);
150 free(b->address);
151 free(b->kernel);
152 free(b->machine);
153 free(b->fake_label);
154 free(b->cgroup_root);
155 free(b->connection_name);
156
157 free(b->exec_path);
158 strv_free(b->exec_argv);
159
160 close_many(b->fds, b->n_fds);
161 free(b->fds);
162
163 bus_reset_queues(b);
164
165 hashmap_free_free(b->reply_callbacks);
166 prioq_free(b->reply_callbacks_prioq);
167
168 while ((f = b->filter_callbacks)) {
169 LIST_REMOVE(callbacks, b->filter_callbacks, f);
170 free(f);
171 }
172
173 bus_match_free(&b->match_callbacks);
174
175 hashmap_free_free(b->vtable_methods);
176 hashmap_free_free(b->vtable_properties);
177
178 while ((n = hashmap_first(b->nodes)))
179 bus_node_destroy(b, n);
180
181 hashmap_free(b->nodes);
182
183 bus_kernel_flush_memfd(b);
184
185 assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
186
187 free(b);
188 }
189
190 _public_ int sd_bus_new(sd_bus **ret) {
191 sd_bus *r;
192
193 assert_return(ret, -EINVAL);
194
195 r = new0(sd_bus, 1);
196 if (!r)
197 return -ENOMEM;
198
199 r->n_ref = REFCNT_INIT;
200 r->input_fd = r->output_fd = -1;
201 r->message_version = 1;
202 r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
203 r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
204 r->attach_flags |= KDBUS_ATTACH_NAMES;
205 r->original_pid = getpid();
206
207 assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
208
209 /* We guarantee that wqueue always has space for at least one
210 * entry */
211 if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
212 free(r);
213 return -ENOMEM;
214 }
215
216 *ret = r;
217 return 0;
218 }
219
220 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
221 char *a;
222
223 assert_return(bus, -EINVAL);
224 assert_return(bus->state == BUS_UNSET, -EPERM);
225 assert_return(address, -EINVAL);
226 assert_return(!bus_pid_changed(bus), -ECHILD);
227
228 a = strdup(address);
229 if (!a)
230 return -ENOMEM;
231
232 free(bus->address);
233 bus->address = a;
234
235 return 0;
236 }
237
238 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
239 assert_return(bus, -EINVAL);
240 assert_return(bus->state == BUS_UNSET, -EPERM);
241 assert_return(input_fd >= 0, -EINVAL);
242 assert_return(output_fd >= 0, -EINVAL);
243 assert_return(!bus_pid_changed(bus), -ECHILD);
244
245 bus->input_fd = input_fd;
246 bus->output_fd = output_fd;
247 return 0;
248 }
249
250 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
251 char *p, **a;
252
253 assert_return(bus, -EINVAL);
254 assert_return(bus->state == BUS_UNSET, -EPERM);
255 assert_return(path, -EINVAL);
256 assert_return(!strv_isempty(argv), -EINVAL);
257 assert_return(!bus_pid_changed(bus), -ECHILD);
258
259 p = strdup(path);
260 if (!p)
261 return -ENOMEM;
262
263 a = strv_copy(argv);
264 if (!a) {
265 free(p);
266 return -ENOMEM;
267 }
268
269 free(bus->exec_path);
270 strv_free(bus->exec_argv);
271
272 bus->exec_path = p;
273 bus->exec_argv = a;
274
275 return 0;
276 }
277
278 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
279 assert_return(bus, -EINVAL);
280 assert_return(bus->state == BUS_UNSET, -EPERM);
281 assert_return(!bus_pid_changed(bus), -ECHILD);
282
283 bus->bus_client = !!b;
284 return 0;
285 }
286
287 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
288 assert_return(bus, -EINVAL);
289 assert_return(bus->state == BUS_UNSET, -EPERM);
290 assert_return(!bus_pid_changed(bus), -ECHILD);
291
292 SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
293 return 0;
294 }
295
296 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
297 assert_return(bus, -EINVAL);
298 assert_return(bus->state == BUS_UNSET, -EPERM);
299 assert_return(!bus_pid_changed(bus), -ECHILD);
300
301 SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
302 return 0;
303 }
304
305 _public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) {
306 assert_return(bus, -EINVAL);
307 assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
308 assert_return(bus->state == BUS_UNSET, -EPERM);
309 assert_return(!bus_pid_changed(bus), -ECHILD);
310
311 /* The well knowns we need unconditionally, so that matches can work */
312 bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
313
314 return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
315 }
316
317 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
318 assert_return(bus, -EINVAL);
319 assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
320 assert_return(bus->state == BUS_UNSET, -EPERM);
321 assert_return(!bus_pid_changed(bus), -ECHILD);
322
323 bus->is_server = !!b;
324 bus->server_id = server_id;
325 return 0;
326 }
327
328 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
329 assert_return(bus, -EINVAL);
330 assert_return(bus->state == BUS_UNSET, -EPERM);
331 assert_return(!bus_pid_changed(bus), -ECHILD);
332
333 bus->anonymous_auth = !!b;
334 return 0;
335 }
336
337 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
338 assert_return(bus, -EINVAL);
339 assert_return(bus->state == BUS_UNSET, -EPERM);
340 assert_return(!bus_pid_changed(bus), -ECHILD);
341
342 bus->trusted = !!b;
343 return 0;
344 }
345
346 _public_ int sd_bus_set_name(sd_bus *bus, const char *name) {
347 char *n;
348
349 assert_return(bus, -EINVAL);
350 assert_return(name, -EINVAL);
351 assert_return(bus->state == BUS_UNSET, -EPERM);
352 assert_return(!bus_pid_changed(bus), -ECHILD);
353
354 n = strdup(name);
355 if (!n)
356 return -ENOMEM;
357
358 free(bus->connection_name);
359 bus->connection_name = n;
360
361 return 0;
362 }
363
364 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
365 const char *s;
366 int r;
367
368 assert(bus);
369 assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
370 assert(reply);
371
372 r = sd_bus_message_get_errno(reply);
373 if (r < 0)
374 return r;
375 if (r > 0)
376 return -r;
377
378 r = sd_bus_message_read(reply, "s", &s);
379 if (r < 0)
380 return r;
381
382 if (!service_name_is_valid(s) || s[0] != ':')
383 return -EBADMSG;
384
385 bus->unique_name = strdup(s);
386 if (!bus->unique_name)
387 return -ENOMEM;
388
389 if (bus->state == BUS_HELLO)
390 bus->state = BUS_RUNNING;
391
392 return 1;
393 }
394
395 static int bus_send_hello(sd_bus *bus) {
396 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
397 int r;
398
399 assert(bus);
400
401 if (!bus->bus_client || bus->is_kernel)
402 return 0;
403
404 r = sd_bus_message_new_method_call(
405 bus,
406 &m,
407 "org.freedesktop.DBus",
408 "/org/freedesktop/DBus",
409 "org.freedesktop.DBus",
410 "Hello");
411 if (r < 0)
412 return r;
413
414 return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie);
415 }
416
417 int bus_start_running(sd_bus *bus) {
418 assert(bus);
419
420 if (bus->bus_client && !bus->is_kernel) {
421 bus->state = BUS_HELLO;
422 return 1;
423 }
424
425 bus->state = BUS_RUNNING;
426 return 1;
427 }
428
429 static int parse_address_key(const char **p, const char *key, char **value) {
430 size_t l, n = 0, allocated = 0;
431 const char *a;
432 char *r = NULL;
433
434 assert(p);
435 assert(*p);
436 assert(value);
437
438 if (key) {
439 l = strlen(key);
440 if (strncmp(*p, key, l) != 0)
441 return 0;
442
443 if ((*p)[l] != '=')
444 return 0;
445
446 if (*value)
447 return -EINVAL;
448
449 a = *p + l + 1;
450 } else
451 a = *p;
452
453 while (*a != ';' && *a != ',' && *a != 0) {
454 char c;
455
456 if (*a == '%') {
457 int x, y;
458
459 x = unhexchar(a[1]);
460 if (x < 0) {
461 free(r);
462 return x;
463 }
464
465 y = unhexchar(a[2]);
466 if (y < 0) {
467 free(r);
468 return y;
469 }
470
471 c = (char) ((x << 4) | y);
472 a += 3;
473 } else {
474 c = *a;
475 a++;
476 }
477
478 if (!GREEDY_REALLOC(r, allocated, n + 2))
479 return -ENOMEM;
480
481 r[n++] = c;
482 }
483
484 if (!r) {
485 r = strdup("");
486 if (!r)
487 return -ENOMEM;
488 } else
489 r[n] = 0;
490
491 if (*a == ',')
492 a++;
493
494 *p = a;
495
496 free(*value);
497 *value = r;
498
499 return 1;
500 }
501
502 static void skip_address_key(const char **p) {
503 assert(p);
504 assert(*p);
505
506 *p += strcspn(*p, ",");
507
508 if (**p == ',')
509 (*p) ++;
510 }
511
512 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
513 _cleanup_free_ char *path = NULL, *abstract = NULL;
514 size_t l;
515 int r;
516
517 assert(b);
518 assert(p);
519 assert(*p);
520 assert(guid);
521
522 while (**p != 0 && **p != ';') {
523 r = parse_address_key(p, "guid", guid);
524 if (r < 0)
525 return r;
526 else if (r > 0)
527 continue;
528
529 r = parse_address_key(p, "path", &path);
530 if (r < 0)
531 return r;
532 else if (r > 0)
533 continue;
534
535 r = parse_address_key(p, "abstract", &abstract);
536 if (r < 0)
537 return r;
538 else if (r > 0)
539 continue;
540
541 skip_address_key(p);
542 }
543
544 if (!path && !abstract)
545 return -EINVAL;
546
547 if (path && abstract)
548 return -EINVAL;
549
550 if (path) {
551 l = strlen(path);
552 if (l > sizeof(b->sockaddr.un.sun_path))
553 return -E2BIG;
554
555 b->sockaddr.un.sun_family = AF_UNIX;
556 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
557 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
558 } else if (abstract) {
559 l = strlen(abstract);
560 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
561 return -E2BIG;
562
563 b->sockaddr.un.sun_family = AF_UNIX;
564 b->sockaddr.un.sun_path[0] = 0;
565 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
566 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
567 }
568
569 return 0;
570 }
571
572 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
573 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
574 int r;
575 struct addrinfo *result, hints = {
576 .ai_socktype = SOCK_STREAM,
577 .ai_flags = AI_ADDRCONFIG,
578 };
579
580 assert(b);
581 assert(p);
582 assert(*p);
583 assert(guid);
584
585 while (**p != 0 && **p != ';') {
586 r = parse_address_key(p, "guid", guid);
587 if (r < 0)
588 return r;
589 else if (r > 0)
590 continue;
591
592 r = parse_address_key(p, "host", &host);
593 if (r < 0)
594 return r;
595 else if (r > 0)
596 continue;
597
598 r = parse_address_key(p, "port", &port);
599 if (r < 0)
600 return r;
601 else if (r > 0)
602 continue;
603
604 r = parse_address_key(p, "family", &family);
605 if (r < 0)
606 return r;
607 else if (r > 0)
608 continue;
609
610 skip_address_key(p);
611 }
612
613 if (!host || !port)
614 return -EINVAL;
615
616 if (family) {
617 if (streq(family, "ipv4"))
618 hints.ai_family = AF_INET;
619 else if (streq(family, "ipv6"))
620 hints.ai_family = AF_INET6;
621 else
622 return -EINVAL;
623 }
624
625 r = getaddrinfo(host, port, &hints, &result);
626 if (r == EAI_SYSTEM)
627 return -errno;
628 else if (r != 0)
629 return -EADDRNOTAVAIL;
630
631 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
632 b->sockaddr_size = result->ai_addrlen;
633
634 freeaddrinfo(result);
635
636 return 0;
637 }
638
639 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
640 char *path = NULL;
641 unsigned n_argv = 0, j;
642 char **argv = NULL;
643 size_t allocated = 0;
644 int r;
645
646 assert(b);
647 assert(p);
648 assert(*p);
649 assert(guid);
650
651 while (**p != 0 && **p != ';') {
652 r = parse_address_key(p, "guid", guid);
653 if (r < 0)
654 goto fail;
655 else if (r > 0)
656 continue;
657
658 r = parse_address_key(p, "path", &path);
659 if (r < 0)
660 goto fail;
661 else if (r > 0)
662 continue;
663
664 if (startswith(*p, "argv")) {
665 unsigned ul;
666
667 errno = 0;
668 ul = strtoul(*p + 4, (char**) p, 10);
669 if (errno > 0 || **p != '=' || ul > 256) {
670 r = -EINVAL;
671 goto fail;
672 }
673
674 (*p) ++;
675
676 if (ul >= n_argv) {
677 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
678 r = -ENOMEM;
679 goto fail;
680 }
681
682 n_argv = ul + 1;
683 }
684
685 r = parse_address_key(p, NULL, argv + ul);
686 if (r < 0)
687 goto fail;
688
689 continue;
690 }
691
692 skip_address_key(p);
693 }
694
695 if (!path) {
696 r = -EINVAL;
697 goto fail;
698 }
699
700 /* Make sure there are no holes in the array, with the
701 * exception of argv[0] */
702 for (j = 1; j < n_argv; j++)
703 if (!argv[j]) {
704 r = -EINVAL;
705 goto fail;
706 }
707
708 if (argv && argv[0] == NULL) {
709 argv[0] = strdup(path);
710 if (!argv[0]) {
711 r = -ENOMEM;
712 goto fail;
713 }
714 }
715
716 b->exec_path = path;
717 b->exec_argv = argv;
718 return 0;
719
720 fail:
721 for (j = 0; j < n_argv; j++)
722 free(argv[j]);
723
724 free(argv);
725 free(path);
726 return r;
727 }
728
729 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
730 _cleanup_free_ char *path = NULL;
731 int r;
732
733 assert(b);
734 assert(p);
735 assert(*p);
736 assert(guid);
737
738 while (**p != 0 && **p != ';') {
739 r = parse_address_key(p, "guid", guid);
740 if (r < 0)
741 return r;
742 else if (r > 0)
743 continue;
744
745 r = parse_address_key(p, "path", &path);
746 if (r < 0)
747 return r;
748 else if (r > 0)
749 continue;
750
751 skip_address_key(p);
752 }
753
754 if (!path)
755 return -EINVAL;
756
757 free(b->kernel);
758 b->kernel = path;
759 path = NULL;
760
761 return 0;
762 }
763
764 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
765 _cleanup_free_ char *machine = NULL;
766 int r;
767
768 assert(b);
769 assert(p);
770 assert(*p);
771 assert(guid);
772
773 while (**p != 0 && **p != ';') {
774 r = parse_address_key(p, "guid", guid);
775 if (r < 0)
776 return r;
777 else if (r > 0)
778 continue;
779
780 r = parse_address_key(p, "machine", &machine);
781 if (r < 0)
782 return r;
783 else if (r > 0)
784 continue;
785
786 skip_address_key(p);
787 }
788
789 if (!machine)
790 return -EINVAL;
791
792 if (!filename_is_safe(machine))
793 return -EINVAL;
794
795 free(b->machine);
796 b->machine = machine;
797 machine = NULL;
798
799 b->sockaddr.un.sun_family = AF_UNIX;
800 strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
801 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
802
803 return 0;
804 }
805
806 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
807 _cleanup_free_ char *machine = NULL;
808 int r;
809
810 assert(b);
811 assert(p);
812 assert(*p);
813 assert(guid);
814
815 while (**p != 0 && **p != ';') {
816 r = parse_address_key(p, "guid", guid);
817 if (r < 0)
818 return r;
819 else if (r > 0)
820 continue;
821
822 r = parse_address_key(p, "machine", &machine);
823 if (r < 0)
824 return r;
825 else if (r > 0)
826 continue;
827
828 skip_address_key(p);
829 }
830
831 if (!machine)
832 return -EINVAL;
833
834 if (!filename_is_safe(machine))
835 return -EINVAL;
836
837 free(b->machine);
838 b->machine = machine;
839 machine = NULL;
840
841 free(b->kernel);
842 b->kernel = strdup("/dev/kdbus/0-system/bus");
843 if (!b->kernel)
844 return -ENOMEM;
845
846 return 0;
847 }
848
849 static void bus_reset_parsed_address(sd_bus *b) {
850 assert(b);
851
852 zero(b->sockaddr);
853 b->sockaddr_size = 0;
854 strv_free(b->exec_argv);
855 free(b->exec_path);
856 b->exec_path = NULL;
857 b->exec_argv = NULL;
858 b->server_id = SD_ID128_NULL;
859 free(b->kernel);
860 b->kernel = NULL;
861 free(b->machine);
862 b->machine = NULL;
863 }
864
865 static int bus_parse_next_address(sd_bus *b) {
866 _cleanup_free_ char *guid = NULL;
867 const char *a;
868 int r;
869
870 assert(b);
871
872 if (!b->address)
873 return 0;
874 if (b->address[b->address_index] == 0)
875 return 0;
876
877 bus_reset_parsed_address(b);
878
879 a = b->address + b->address_index;
880
881 while (*a != 0) {
882
883 if (*a == ';') {
884 a++;
885 continue;
886 }
887
888 if (startswith(a, "unix:")) {
889 a += 5;
890
891 r = parse_unix_address(b, &a, &guid);
892 if (r < 0)
893 return r;
894 break;
895
896 } else if (startswith(a, "tcp:")) {
897
898 a += 4;
899 r = parse_tcp_address(b, &a, &guid);
900 if (r < 0)
901 return r;
902
903 break;
904
905 } else if (startswith(a, "unixexec:")) {
906
907 a += 9;
908 r = parse_exec_address(b, &a, &guid);
909 if (r < 0)
910 return r;
911
912 break;
913
914 } else if (startswith(a, "kernel:")) {
915
916 a += 7;
917 r = parse_kernel_address(b, &a, &guid);
918 if (r < 0)
919 return r;
920
921 break;
922 } else if (startswith(a, "x-container-unix:")) {
923
924 a += 17;
925 r = parse_container_unix_address(b, &a, &guid);
926 if (r < 0)
927 return r;
928
929 break;
930 } else if (startswith(a, "x-container-kernel:")) {
931
932 a += 19;
933 r = parse_container_kernel_address(b, &a, &guid);
934 if (r < 0)
935 return r;
936
937 break;
938 }
939
940 a = strchr(a, ';');
941 if (!a)
942 return 0;
943 }
944
945 if (guid) {
946 r = sd_id128_from_string(guid, &b->server_id);
947 if (r < 0)
948 return r;
949 }
950
951 b->address_index = a - b->address;
952 return 1;
953 }
954
955 static int bus_start_address(sd_bus *b) {
956 int r;
957
958 assert(b);
959
960 for (;;) {
961 bool skipped = false;
962
963 bus_close_fds(b);
964
965 if (b->exec_path)
966 r = bus_socket_exec(b);
967 else if (b->machine && b->kernel)
968 r = bus_container_connect_kernel(b);
969 else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC)
970 r = bus_container_connect_socket(b);
971 else if (b->kernel)
972 r = bus_kernel_connect(b);
973 else if (b->sockaddr.sa.sa_family != AF_UNSPEC)
974 r = bus_socket_connect(b);
975 else
976 skipped = true;
977
978 if (!skipped) {
979 if (r >= 0) {
980 r = attach_io_events(b);
981 if (r >= 0)
982 return r;
983 }
984
985 b->last_connect_error = -r;
986 }
987
988 r = bus_parse_next_address(b);
989 if (r < 0)
990 return r;
991 if (r == 0)
992 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
993 }
994 }
995
996 int bus_next_address(sd_bus *b) {
997 assert(b);
998
999 bus_reset_parsed_address(b);
1000 return bus_start_address(b);
1001 }
1002
1003 static int bus_start_fd(sd_bus *b) {
1004 struct stat st;
1005 int r;
1006
1007 assert(b);
1008 assert(b->input_fd >= 0);
1009 assert(b->output_fd >= 0);
1010
1011 r = fd_nonblock(b->input_fd, true);
1012 if (r < 0)
1013 return r;
1014
1015 r = fd_cloexec(b->input_fd, true);
1016 if (r < 0)
1017 return r;
1018
1019 if (b->input_fd != b->output_fd) {
1020 r = fd_nonblock(b->output_fd, true);
1021 if (r < 0)
1022 return r;
1023
1024 r = fd_cloexec(b->output_fd, true);
1025 if (r < 0)
1026 return r;
1027 }
1028
1029 if (fstat(b->input_fd, &st) < 0)
1030 return -errno;
1031
1032 if (S_ISCHR(b->input_fd))
1033 return bus_kernel_take_fd(b);
1034 else
1035 return bus_socket_take_fd(b);
1036 }
1037
1038 _public_ int sd_bus_start(sd_bus *bus) {
1039 int r;
1040
1041 assert_return(bus, -EINVAL);
1042 assert_return(bus->state == BUS_UNSET, -EPERM);
1043 assert_return(!bus_pid_changed(bus), -ECHILD);
1044
1045 bus->state = BUS_OPENING;
1046
1047 if (bus->is_server && bus->bus_client)
1048 return -EINVAL;
1049
1050 if (bus->input_fd >= 0)
1051 r = bus_start_fd(bus);
1052 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1053 r = bus_start_address(bus);
1054 else
1055 return -EINVAL;
1056
1057 if (r < 0)
1058 return r;
1059
1060 return bus_send_hello(bus);
1061 }
1062
1063 _public_ int sd_bus_open(sd_bus **ret) {
1064 const char *e;
1065 sd_bus *b;
1066 int r;
1067
1068 assert_return(ret, -EINVAL);
1069
1070 /* Let's connect to the starter bus if it is set, and
1071 * otherwise to the bus that is appropropriate for the scope
1072 * we are running in */
1073
1074 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1075 if (e) {
1076 if (streq(e, "system"))
1077 return sd_bus_open_system(ret);
1078 else if (streq(e, "session") || streq(e, "user"))
1079 return sd_bus_open_user(ret);
1080 }
1081
1082 e = secure_getenv("DBUS_STARTER_ADDRESS");
1083 if (!e) {
1084 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1085 return sd_bus_open_user(ret);
1086 else
1087 return sd_bus_open_system(ret);
1088 }
1089
1090 r = sd_bus_new(&b);
1091 if (r < 0)
1092 return r;
1093
1094 r = sd_bus_set_address(b, e);
1095 if (r < 0)
1096 goto fail;
1097
1098 b->bus_client = true;
1099
1100 /* We don't know whether the bus is trusted or not, so better
1101 * be safe, and authenticate everything */
1102 b->trusted = false;
1103 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1104
1105 r = sd_bus_start(b);
1106 if (r < 0)
1107 goto fail;
1108
1109 *ret = b;
1110 return 0;
1111
1112 fail:
1113 bus_free(b);
1114 return r;
1115 }
1116
1117 _public_ int sd_bus_open_system(sd_bus **ret) {
1118 const char *e;
1119 sd_bus *b;
1120 int r;
1121
1122 assert_return(ret, -EINVAL);
1123
1124 r = sd_bus_new(&b);
1125 if (r < 0)
1126 return r;
1127
1128 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1129 if (e)
1130 r = sd_bus_set_address(b, e);
1131 else
1132 r = sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH);
1133 if (r < 0)
1134 goto fail;
1135
1136 b->bus_client = true;
1137 b->is_system = true;
1138
1139 /* Let's do per-method access control on the system bus. We
1140 * need the caller's UID and capability set for that. */
1141 b->trusted = false;
1142 b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1143
1144 r = sd_bus_start(b);
1145 if (r < 0)
1146 goto fail;
1147
1148 *ret = b;
1149 return 0;
1150
1151 fail:
1152 bus_free(b);
1153 return r;
1154 }
1155
1156 _public_ int sd_bus_open_user(sd_bus **ret) {
1157 const char *e;
1158 sd_bus *b;
1159 int r;
1160
1161 assert_return(ret, -EINVAL);
1162
1163 r = sd_bus_new(&b);
1164 if (r < 0)
1165 return r;
1166
1167 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1168 if (e) {
1169 r = sd_bus_set_address(b, e);
1170 if (r < 0)
1171 goto fail;
1172 } else {
1173 e = secure_getenv("XDG_RUNTIME_DIR");
1174 if (e) {
1175 _cleanup_free_ char *ee = NULL;
1176
1177 ee = bus_address_escape(e);
1178 if (!ee) {
1179 r = -ENOMEM;
1180 goto fail;
1181 }
1182
1183 #ifdef ENABLE_KDBUS
1184 asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee);
1185 #else
1186 asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
1187 #endif
1188 } else {
1189 #ifdef ENABLE_KDBUS
1190 asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
1191 #else
1192 return -ECONNREFUSED;
1193 #endif
1194 }
1195
1196 if (!b->address) {
1197 r = -ENOMEM;
1198 goto fail;
1199 }
1200 }
1201
1202 b->bus_client = true;
1203 b->is_user = true;
1204
1205 /* We don't do any per-method access control on the user
1206 * bus. */
1207 b->trusted = true;
1208
1209 r = sd_bus_start(b);
1210 if (r < 0)
1211 goto fail;
1212
1213 *ret = b;
1214 return 0;
1215
1216 fail:
1217 bus_free(b);
1218 return r;
1219 }
1220
1221 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1222 _cleanup_free_ char *e = NULL;
1223 char *p = NULL;
1224 sd_bus *bus;
1225 int r;
1226
1227 assert_return(host, -EINVAL);
1228 assert_return(ret, -EINVAL);
1229
1230 e = bus_address_escape(host);
1231 if (!e)
1232 return -ENOMEM;
1233
1234 p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1235 if (!p)
1236 return -ENOMEM;
1237
1238 r = sd_bus_new(&bus);
1239 if (r < 0) {
1240 free(p);
1241 return r;
1242 }
1243
1244 bus->address = p;
1245 bus->bus_client = true;
1246
1247 r = sd_bus_start(bus);
1248 if (r < 0) {
1249 bus_free(bus);
1250 return r;
1251 }
1252
1253 *ret = bus;
1254 return 0;
1255 }
1256
1257 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1258 _cleanup_free_ char *e = NULL;
1259 sd_bus *bus;
1260 char *p;
1261 int r;
1262
1263 assert_return(machine, -EINVAL);
1264 assert_return(ret, -EINVAL);
1265 assert_return(filename_is_safe(machine), -EINVAL);
1266
1267 e = bus_address_escape(machine);
1268 if (!e)
1269 return -ENOMEM;
1270
1271 #ifdef ENABLE_KDBUS
1272 p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1273 #else
1274 p = strjoin("x-container-unix:machine=", e, NULL);
1275 #endif
1276 if (!p)
1277 return -ENOMEM;
1278
1279 r = sd_bus_new(&bus);
1280 if (r < 0) {
1281 free(p);
1282 return r;
1283 }
1284
1285 bus->address = p;
1286 bus->bus_client = true;
1287
1288 r = sd_bus_start(bus);
1289 if (r < 0) {
1290 bus_free(bus);
1291 return r;
1292 }
1293
1294 *ret = bus;
1295 return 0;
1296 }
1297
1298 _public_ void sd_bus_close(sd_bus *bus) {
1299
1300 if (!bus)
1301 return;
1302 if (bus->state == BUS_CLOSED)
1303 return;
1304 if (bus_pid_changed(bus))
1305 return;
1306
1307 bus->state = BUS_CLOSED;
1308
1309 sd_bus_detach_event(bus);
1310
1311 /* Drop all queued messages so that they drop references to
1312 * the bus object and the bus may be freed */
1313 bus_reset_queues(bus);
1314
1315 if (!bus->is_kernel)
1316 bus_close_fds(bus);
1317
1318 /* We'll leave the fd open in case this is a kernel bus, since
1319 * there might still be memblocks around that reference this
1320 * bus, and they might need to invoke the KDBUS_CMD_FREE
1321 * ioctl on the fd when they are freed. */
1322 }
1323
1324 static void bus_enter_closing(sd_bus *bus) {
1325 assert(bus);
1326
1327 if (bus->state != BUS_OPENING &&
1328 bus->state != BUS_AUTHENTICATING &&
1329 bus->state != BUS_HELLO &&
1330 bus->state != BUS_RUNNING)
1331 return;
1332
1333 bus->state = BUS_CLOSING;
1334 }
1335
1336 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1337 assert_return(bus, NULL);
1338
1339 assert_se(REFCNT_INC(bus->n_ref) >= 2);
1340
1341 return bus;
1342 }
1343
1344 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1345 unsigned i;
1346
1347 if (!bus)
1348 return NULL;
1349
1350 if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) {
1351 bool q = true;
1352
1353 for (i = 0; i < bus->rqueue_size; i++)
1354 if (bus->rqueue[i]->n_ref > 1) {
1355 q = false;
1356 break;
1357 }
1358
1359 if (q) {
1360 for (i = 0; i < bus->wqueue_size; i++)
1361 if (bus->wqueue[i]->n_ref > 1) {
1362 q = false;
1363 break;
1364 }
1365 }
1366
1367 /* We are the only holders on the messages, and the
1368 * messages are the only holders on us, so let's drop
1369 * the messages and thus implicitly also kill our own
1370 * last references */
1371
1372 if (q)
1373 bus_reset_queues(bus);
1374 }
1375
1376 i = REFCNT_DEC(bus->n_ref);
1377 if (i > 0)
1378 return NULL;
1379
1380 bus_free(bus);
1381 return NULL;
1382 }
1383
1384 _public_ int sd_bus_is_open(sd_bus *bus) {
1385
1386 assert_return(bus, -EINVAL);
1387 assert_return(!bus_pid_changed(bus), -ECHILD);
1388
1389 return BUS_IS_OPEN(bus->state);
1390 }
1391
1392 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1393 int r;
1394
1395 assert_return(bus, -EINVAL);
1396 assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1397 assert_return(!bus_pid_changed(bus), -ECHILD);
1398
1399 if (type == SD_BUS_TYPE_UNIX_FD) {
1400 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1401 return 0;
1402
1403 r = bus_ensure_running(bus);
1404 if (r < 0)
1405 return r;
1406
1407 return bus->can_fds;
1408 }
1409
1410 return bus_type_is_valid(type);
1411 }
1412
1413 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1414 int r;
1415
1416 assert_return(bus, -EINVAL);
1417 assert_return(server_id, -EINVAL);
1418 assert_return(!bus_pid_changed(bus), -ECHILD);
1419
1420 r = bus_ensure_running(bus);
1421 if (r < 0)
1422 return r;
1423
1424 *server_id = bus->server_id;
1425 return 0;
1426 }
1427
1428 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1429 assert(b);
1430 assert(m);
1431
1432 if (m->sealed) {
1433 /* If we copy the same message to multiple
1434 * destinations, avoid using the same cookie
1435 * numbers. */
1436 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1437 return 0;
1438 }
1439
1440 if (timeout == 0)
1441 timeout = BUS_DEFAULT_TIMEOUT;
1442
1443 return bus_message_seal(m, ++b->cookie, timeout);
1444 }
1445
1446 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1447 assert(b);
1448
1449 /* Do packet version and endianess already match? */
1450 if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1451 (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1452 return 0;
1453
1454 /* No? Then remarshal! */
1455 return bus_message_remarshal(b, m);
1456 }
1457
1458 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1459 assert(b);
1460 assert(m);
1461
1462 /* The bus specification says the serial number cannot be 0,
1463 * hence let's fill something in for synthetic messages. Since
1464 * synthetic messages might have a fake sender and we don't
1465 * want to interfere with the real sender's serial numbers we
1466 * pick a fixed, artifical one. We use (uint32_t) -1 rather
1467 * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1468 * even though kdbus can do 64bit. */
1469
1470 return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1471 }
1472
1473 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1474 int r;
1475
1476 assert(bus);
1477 assert(m);
1478
1479 if (bus->is_kernel)
1480 r = bus_kernel_write_message(bus, m, hint_sync_call);
1481 else
1482 r = bus_socket_write_message(bus, m, idx);
1483
1484 if (r <= 0)
1485 return r;
1486
1487 if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1488 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
1489 bus_message_type_to_string(m->header->type),
1490 strna(sd_bus_message_get_sender(m)),
1491 strna(sd_bus_message_get_destination(m)),
1492 strna(sd_bus_message_get_path(m)),
1493 strna(sd_bus_message_get_interface(m)),
1494 strna(sd_bus_message_get_member(m)),
1495 (unsigned long) BUS_MESSAGE_COOKIE(m),
1496 (unsigned long) m->reply_cookie,
1497 strna(m->error.message));
1498
1499 return r;
1500 }
1501
1502 static int dispatch_wqueue(sd_bus *bus) {
1503 int r, ret = 0;
1504
1505 assert(bus);
1506 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1507
1508 while (bus->wqueue_size > 0) {
1509
1510 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1511 if (r < 0)
1512 return r;
1513 else if (r == 0)
1514 /* Didn't do anything this time */
1515 return ret;
1516 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1517 /* Fully written. Let's drop the entry from
1518 * the queue.
1519 *
1520 * This isn't particularly optimized, but
1521 * well, this is supposed to be our worst-case
1522 * buffer only, and the socket buffer is
1523 * supposed to be our primary buffer, and if
1524 * it got full, then all bets are off
1525 * anyway. */
1526
1527 bus->wqueue_size --;
1528 sd_bus_message_unref(bus->wqueue[0]);
1529 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1530 bus->windex = 0;
1531
1532 ret = 1;
1533 }
1534 }
1535
1536 return ret;
1537 }
1538
1539 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1540 assert(bus);
1541
1542 if (bus->is_kernel)
1543 return bus_kernel_read_message(bus, hint_priority, priority);
1544 else
1545 return bus_socket_read_message(bus);
1546 }
1547
1548 int bus_rqueue_make_room(sd_bus *bus) {
1549 assert(bus);
1550
1551 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1552 return -ENOBUFS;
1553
1554 if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1555 return -ENOMEM;
1556
1557 return 0;
1558 }
1559
1560 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1561 int r, ret = 0;
1562
1563 assert(bus);
1564 assert(m);
1565 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1566
1567 /* Note that the priority logic is only available on kdbus,
1568 * where the rqueue is unused. We check the rqueue here
1569 * anyway, because it's simple... */
1570
1571 for (;;) {
1572 if (bus->rqueue_size > 0) {
1573 /* Dispatch a queued message */
1574
1575 *m = bus->rqueue[0];
1576 bus->rqueue_size --;
1577 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1578 return 1;
1579 }
1580
1581 /* Try to read a new message */
1582 r = bus_read_message(bus, hint_priority, priority);
1583 if (r < 0)
1584 return r;
1585 if (r == 0)
1586 return ret;
1587
1588 ret = 1;
1589 }
1590 }
1591
1592 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1593 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1594 int r;
1595
1596 assert_return(bus, -EINVAL);
1597 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1598 assert_return(m, -EINVAL);
1599 assert_return(!bus_pid_changed(bus), -ECHILD);
1600
1601 if (m->n_fds > 0) {
1602 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1603 if (r < 0)
1604 return r;
1605 if (r == 0)
1606 return -ENOTSUP;
1607 }
1608
1609 /* If the cookie number isn't kept, then we know that no reply
1610 * is expected */
1611 if (!cookie && !m->sealed)
1612 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1613
1614 r = bus_seal_message(bus, m, 0);
1615 if (r < 0)
1616 return r;
1617
1618 /* Remarshall if we have to. This will possibly unref the
1619 * message and place a replacement in m */
1620 r = bus_remarshal_message(bus, &m);
1621 if (r < 0)
1622 return r;
1623
1624 /* If this is a reply and no reply was requested, then let's
1625 * suppress this, if we can */
1626 if (m->dont_send && !cookie)
1627 return 1;
1628
1629 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1630 size_t idx = 0;
1631
1632 r = bus_write_message(bus, m, hint_sync_call, &idx);
1633 if (r < 0) {
1634 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1635 bus_enter_closing(bus);
1636 return -ECONNRESET;
1637 }
1638
1639 return r;
1640 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1641 /* Wasn't fully written. So let's remember how
1642 * much was written. Note that the first entry
1643 * of the wqueue array is always allocated so
1644 * that we always can remember how much was
1645 * written. */
1646 bus->wqueue[0] = sd_bus_message_ref(m);
1647 bus->wqueue_size = 1;
1648 bus->windex = idx;
1649 }
1650 } else {
1651 /* Just append it to the queue. */
1652
1653 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1654 return -ENOBUFS;
1655
1656 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1657 return -ENOMEM;
1658
1659 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1660 }
1661
1662 if (cookie)
1663 *cookie = BUS_MESSAGE_COOKIE(m);
1664
1665 return 1;
1666 }
1667
1668 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1669 return bus_send_internal(bus, m, cookie, false);
1670 }
1671
1672 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1673 int r;
1674
1675 assert_return(bus, -EINVAL);
1676 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1677 assert_return(m, -EINVAL);
1678 assert_return(!bus_pid_changed(bus), -ECHILD);
1679
1680 if (!streq_ptr(m->destination, destination)) {
1681
1682 if (!destination)
1683 return -EEXIST;
1684
1685 r = sd_bus_message_set_destination(m, destination);
1686 if (r < 0)
1687 return r;
1688 }
1689
1690 return sd_bus_send(bus, m, cookie);
1691 }
1692
1693 static usec_t calc_elapse(uint64_t usec) {
1694 if (usec == (uint64_t) -1)
1695 return 0;
1696
1697 return now(CLOCK_MONOTONIC) + usec;
1698 }
1699
1700 static int timeout_compare(const void *a, const void *b) {
1701 const struct reply_callback *x = a, *y = b;
1702
1703 if (x->timeout != 0 && y->timeout == 0)
1704 return -1;
1705
1706 if (x->timeout == 0 && y->timeout != 0)
1707 return 1;
1708
1709 if (x->timeout < y->timeout)
1710 return -1;
1711
1712 if (x->timeout > y->timeout)
1713 return 1;
1714
1715 return 0;
1716 }
1717
1718 _public_ int sd_bus_call_async(
1719 sd_bus *bus,
1720 sd_bus_message *_m,
1721 sd_bus_message_handler_t callback,
1722 void *userdata,
1723 uint64_t usec,
1724 uint64_t *cookie) {
1725
1726 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1727 struct reply_callback *c;
1728 int r;
1729
1730 assert_return(bus, -EINVAL);
1731 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1732 assert_return(m, -EINVAL);
1733 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1734 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1735 assert_return(callback, -EINVAL);
1736 assert_return(!bus_pid_changed(bus), -ECHILD);
1737
1738 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1739 if (r < 0)
1740 return r;
1741
1742 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1743 if (r < 0)
1744 return r;
1745
1746 r = bus_seal_message(bus, m, usec);
1747 if (r < 0)
1748 return r;
1749
1750 r = bus_remarshal_message(bus, &m);
1751 if (r < 0)
1752 return r;
1753
1754 c = new0(struct reply_callback, 1);
1755 if (!c)
1756 return -ENOMEM;
1757
1758 c->callback = callback;
1759 c->userdata = userdata;
1760 c->cookie = BUS_MESSAGE_COOKIE(m);
1761 c->timeout = calc_elapse(m->timeout);
1762
1763 r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1764 if (r < 0) {
1765 free(c);
1766 return r;
1767 }
1768
1769 if (c->timeout != 0) {
1770 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1771 if (r < 0) {
1772 c->timeout = 0;
1773 sd_bus_call_async_cancel(bus, c->cookie);
1774 return r;
1775 }
1776 }
1777
1778 r = sd_bus_send(bus, m, cookie);
1779 if (r < 0) {
1780 sd_bus_call_async_cancel(bus, c->cookie);
1781 return r;
1782 }
1783
1784 return r;
1785 }
1786
1787 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1788 struct reply_callback *c;
1789
1790 assert_return(bus, -EINVAL);
1791 assert_return(cookie != 0, -EINVAL);
1792 assert_return(!bus_pid_changed(bus), -ECHILD);
1793
1794 c = hashmap_remove(bus->reply_callbacks, &cookie);
1795 if (!c)
1796 return 0;
1797
1798 if (c->timeout != 0)
1799 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1800
1801 free(c);
1802 return 1;
1803 }
1804
1805 int bus_ensure_running(sd_bus *bus) {
1806 int r;
1807
1808 assert(bus);
1809
1810 if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1811 return -ENOTCONN;
1812 if (bus->state == BUS_RUNNING)
1813 return 1;
1814
1815 for (;;) {
1816 r = sd_bus_process(bus, NULL);
1817 if (r < 0)
1818 return r;
1819 if (bus->state == BUS_RUNNING)
1820 return 1;
1821 if (r > 0)
1822 continue;
1823
1824 r = sd_bus_wait(bus, (uint64_t) -1);
1825 if (r < 0)
1826 return r;
1827 }
1828 }
1829
1830 _public_ int sd_bus_call(
1831 sd_bus *bus,
1832 sd_bus_message *_m,
1833 uint64_t usec,
1834 sd_bus_error *error,
1835 sd_bus_message **reply) {
1836
1837 _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1838 usec_t timeout;
1839 uint64_t cookie;
1840 unsigned i;
1841 int r;
1842
1843 assert_return(bus, -EINVAL);
1844 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1845 assert_return(m, -EINVAL);
1846 assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1847 assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1848 assert_return(!bus_error_is_dirty(error), -EINVAL);
1849 assert_return(!bus_pid_changed(bus), -ECHILD);
1850
1851 r = bus_ensure_running(bus);
1852 if (r < 0)
1853 return r;
1854
1855 i = bus->rqueue_size;
1856
1857 r = bus_seal_message(bus, m, usec);
1858 if (r < 0)
1859 return r;
1860
1861 r = bus_remarshal_message(bus, &m);
1862 if (r < 0)
1863 return r;
1864
1865 r = bus_send_internal(bus, m, &cookie, true);
1866 if (r < 0)
1867 return r;
1868
1869 timeout = calc_elapse(m->timeout);
1870
1871 for (;;) {
1872 usec_t left;
1873
1874 while (i < bus->rqueue_size) {
1875 sd_bus_message *incoming = NULL;
1876
1877 incoming = bus->rqueue[i];
1878
1879 if (incoming->reply_cookie == cookie) {
1880 /* Found a match! */
1881
1882 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1883 bus->rqueue_size--;
1884
1885 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1886
1887 if (reply)
1888 *reply = incoming;
1889 else
1890 sd_bus_message_unref(incoming);
1891
1892 return 1;
1893 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1894 r = sd_bus_error_copy(error, &incoming->error);
1895 else
1896 r = -EIO;
1897
1898 sd_bus_message_unref(incoming);
1899 return r;
1900
1901 } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1902 bus->unique_name &&
1903 incoming->sender &&
1904 streq(bus->unique_name, incoming->sender)) {
1905
1906 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1907 bus->rqueue_size--;
1908
1909 /* Our own message? Somebody is trying
1910 * to send its own client a message,
1911 * let's not dead-lock, let's fail
1912 * immediately. */
1913
1914 sd_bus_message_unref(incoming);
1915 return -ELOOP;
1916 }
1917
1918 /* Try to read more, right-away */
1919 i++;
1920 }
1921
1922 r = bus_read_message(bus, false, 0);
1923 if (r < 0) {
1924 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1925 bus_enter_closing(bus);
1926 return -ECONNRESET;
1927 }
1928
1929 return r;
1930 }
1931 if (r > 0)
1932 continue;
1933
1934 if (timeout > 0) {
1935 usec_t n;
1936
1937 n = now(CLOCK_MONOTONIC);
1938 if (n >= timeout)
1939 return -ETIMEDOUT;
1940
1941 left = timeout - n;
1942 } else
1943 left = (uint64_t) -1;
1944
1945 r = bus_poll(bus, true, left);
1946 if (r < 0)
1947 return r;
1948 if (r == 0)
1949 return -ETIMEDOUT;
1950
1951 r = dispatch_wqueue(bus);
1952 if (r < 0) {
1953 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1954 bus_enter_closing(bus);
1955 return -ECONNRESET;
1956 }
1957
1958 return r;
1959 }
1960 }
1961 }
1962
1963 _public_ int sd_bus_get_fd(sd_bus *bus) {
1964
1965 assert_return(bus, -EINVAL);
1966 assert_return(bus->input_fd == bus->output_fd, -EPERM);
1967 assert_return(!bus_pid_changed(bus), -ECHILD);
1968
1969 return bus->input_fd;
1970 }
1971
1972 _public_ int sd_bus_get_events(sd_bus *bus) {
1973 int flags = 0;
1974
1975 assert_return(bus, -EINVAL);
1976 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1977 assert_return(!bus_pid_changed(bus), -ECHILD);
1978
1979 if (bus->state == BUS_OPENING)
1980 flags |= POLLOUT;
1981 else if (bus->state == BUS_AUTHENTICATING) {
1982
1983 if (bus_socket_auth_needs_write(bus))
1984 flags |= POLLOUT;
1985
1986 flags |= POLLIN;
1987
1988 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1989 if (bus->rqueue_size <= 0)
1990 flags |= POLLIN;
1991 if (bus->wqueue_size > 0)
1992 flags |= POLLOUT;
1993 }
1994
1995 return flags;
1996 }
1997
1998 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1999 struct reply_callback *c;
2000
2001 assert_return(bus, -EINVAL);
2002 assert_return(timeout_usec, -EINVAL);
2003 assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
2004 assert_return(!bus_pid_changed(bus), -ECHILD);
2005
2006 if (bus->track_queue) {
2007 *timeout_usec = 0;
2008 return 1;
2009 }
2010
2011 if (bus->state == BUS_CLOSING) {
2012 *timeout_usec = 0;
2013 return 1;
2014 }
2015
2016 if (bus->state == BUS_AUTHENTICATING) {
2017 *timeout_usec = bus->auth_timeout;
2018 return 1;
2019 }
2020
2021 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2022 *timeout_usec = (uint64_t) -1;
2023 return 0;
2024 }
2025
2026 if (bus->rqueue_size > 0) {
2027 *timeout_usec = 0;
2028 return 1;
2029 }
2030
2031 c = prioq_peek(bus->reply_callbacks_prioq);
2032 if (!c) {
2033 *timeout_usec = (uint64_t) -1;
2034 return 0;
2035 }
2036
2037 *timeout_usec = c->timeout;
2038 return 1;
2039 }
2040
2041 static int process_timeout(sd_bus *bus) {
2042 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2043 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2044 struct reply_callback *c;
2045 usec_t n;
2046 int r;
2047
2048 assert(bus);
2049
2050 c = prioq_peek(bus->reply_callbacks_prioq);
2051 if (!c)
2052 return 0;
2053
2054 n = now(CLOCK_MONOTONIC);
2055 if (c->timeout > n)
2056 return 0;
2057
2058 r = bus_message_new_synthetic_error(
2059 bus,
2060 c->cookie,
2061 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2062 &m);
2063 if (r < 0)
2064 return r;
2065
2066 m->sender = "org.freedesktop.DBus";
2067
2068 r = bus_seal_synthetic_message(bus, m);
2069 if (r < 0)
2070 return r;
2071
2072 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2073 hashmap_remove(bus->reply_callbacks, &c->cookie);
2074
2075 bus->current = m;
2076 bus->iteration_counter ++;
2077
2078 r = c->callback(bus, m, c->userdata, &error_buffer);
2079 r = bus_maybe_reply_error(m, r, &error_buffer);
2080 free(c);
2081
2082 bus->current = NULL;
2083
2084 return r;
2085 }
2086
2087 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2088 assert(bus);
2089 assert(m);
2090
2091 if (bus->state != BUS_HELLO)
2092 return 0;
2093
2094 /* Let's make sure the first message on the bus is the HELLO
2095 * reply. But note that we don't actually parse the message
2096 * here (we leave that to the usual handling), we just verify
2097 * we don't let any earlier msg through. */
2098
2099 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2100 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2101 return -EIO;
2102
2103 if (m->reply_cookie != bus->hello_cookie)
2104 return -EIO;
2105
2106 return 0;
2107 }
2108
2109 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2110 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2111 struct reply_callback *c;
2112 int r;
2113
2114 assert(bus);
2115 assert(m);
2116
2117 if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2118 m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2119 return 0;
2120
2121 c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2122 if (!c)
2123 return 0;
2124
2125 if (c->timeout != 0)
2126 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2127
2128 r = sd_bus_message_rewind(m, true);
2129 if (r < 0)
2130 return r;
2131
2132 r = c->callback(bus, m, c->userdata, &error_buffer);
2133 r = bus_maybe_reply_error(m, r, &error_buffer);
2134 free(c);
2135
2136 return r;
2137 }
2138
2139 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2140 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2141 struct filter_callback *l;
2142 int r;
2143
2144 assert(bus);
2145 assert(m);
2146
2147 do {
2148 bus->filter_callbacks_modified = false;
2149
2150 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2151
2152 if (bus->filter_callbacks_modified)
2153 break;
2154
2155 /* Don't run this more than once per iteration */
2156 if (l->last_iteration == bus->iteration_counter)
2157 continue;
2158
2159 l->last_iteration = bus->iteration_counter;
2160
2161 r = sd_bus_message_rewind(m, true);
2162 if (r < 0)
2163 return r;
2164
2165 r = l->callback(bus, m, l->userdata, &error_buffer);
2166 r = bus_maybe_reply_error(m, r, &error_buffer);
2167 if (r != 0)
2168 return r;
2169
2170 }
2171
2172 } while (bus->filter_callbacks_modified);
2173
2174 return 0;
2175 }
2176
2177 static int process_match(sd_bus *bus, sd_bus_message *m) {
2178 int r;
2179
2180 assert(bus);
2181 assert(m);
2182
2183 do {
2184 bus->match_callbacks_modified = false;
2185
2186 r = bus_match_run(bus, &bus->match_callbacks, m);
2187 if (r != 0)
2188 return r;
2189
2190 } while (bus->match_callbacks_modified);
2191
2192 return 0;
2193 }
2194
2195 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2196 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2197 int r;
2198
2199 assert(bus);
2200 assert(m);
2201
2202 if (bus->manual_peer_interface)
2203 return 0;
2204
2205 if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2206 return 0;
2207
2208 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2209 return 0;
2210
2211 if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2212 return 1;
2213
2214 if (streq_ptr(m->member, "Ping"))
2215 r = sd_bus_message_new_method_return(m, &reply);
2216 else if (streq_ptr(m->member, "GetMachineId")) {
2217 sd_id128_t id;
2218 char sid[33];
2219
2220 r = sd_id128_get_machine(&id);
2221 if (r < 0)
2222 return r;
2223
2224 r = sd_bus_message_new_method_return(m, &reply);
2225 if (r < 0)
2226 return r;
2227
2228 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2229 } else {
2230 r = sd_bus_message_new_method_errorf(
2231 m, &reply,
2232 SD_BUS_ERROR_UNKNOWN_METHOD,
2233 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2234 }
2235
2236 if (r < 0)
2237 return r;
2238
2239 r = sd_bus_send(bus, reply, NULL);
2240 if (r < 0)
2241 return r;
2242
2243 return 1;
2244 }
2245
2246 static int process_message(sd_bus *bus, sd_bus_message *m) {
2247 int r;
2248
2249 assert(bus);
2250 assert(m);
2251
2252 bus->current = m;
2253 bus->iteration_counter++;
2254
2255 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2256 bus_message_type_to_string(m->header->type),
2257 strna(sd_bus_message_get_sender(m)),
2258 strna(sd_bus_message_get_destination(m)),
2259 strna(sd_bus_message_get_path(m)),
2260 strna(sd_bus_message_get_interface(m)),
2261 strna(sd_bus_message_get_member(m)),
2262 (unsigned long) BUS_MESSAGE_COOKIE(m),
2263 (unsigned long) m->reply_cookie,
2264 strna(m->error.message));
2265
2266 r = process_hello(bus, m);
2267 if (r != 0)
2268 goto finish;
2269
2270 r = process_reply(bus, m);
2271 if (r != 0)
2272 goto finish;
2273
2274 r = process_filter(bus, m);
2275 if (r != 0)
2276 goto finish;
2277
2278 r = process_match(bus, m);
2279 if (r != 0)
2280 goto finish;
2281
2282 r = process_builtin(bus, m);
2283 if (r != 0)
2284 goto finish;
2285
2286 r = bus_process_object(bus, m);
2287
2288 finish:
2289 bus->current = NULL;
2290 return r;
2291 }
2292
2293 static int dispatch_track(sd_bus *bus) {
2294 assert(bus);
2295
2296 if (!bus->track_queue)
2297 return 0;
2298
2299 bus_track_dispatch(bus->track_queue);
2300 return 1;
2301 }
2302
2303 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2304 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2305 int r;
2306
2307 assert(bus);
2308 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2309
2310 r = process_timeout(bus);
2311 if (r != 0)
2312 goto null_message;
2313
2314 r = dispatch_wqueue(bus);
2315 if (r != 0)
2316 goto null_message;
2317
2318 r = dispatch_track(bus);
2319 if (r != 0)
2320 goto null_message;
2321
2322 r = dispatch_rqueue(bus, hint_priority, priority, &m);
2323 if (r < 0)
2324 return r;
2325 if (!m)
2326 goto null_message;
2327
2328 r = process_message(bus, m);
2329 if (r != 0)
2330 goto null_message;
2331
2332 if (ret) {
2333 r = sd_bus_message_rewind(m, true);
2334 if (r < 0)
2335 return r;
2336
2337 *ret = m;
2338 m = NULL;
2339 return 1;
2340 }
2341
2342 if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2343
2344 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2345 strna(sd_bus_message_get_sender(m)),
2346 strna(sd_bus_message_get_path(m)),
2347 strna(sd_bus_message_get_interface(m)),
2348 strna(sd_bus_message_get_member(m)));
2349
2350 r = sd_bus_reply_method_errorf(
2351 m,
2352 SD_BUS_ERROR_UNKNOWN_OBJECT,
2353 "Unknown object '%s'.", m->path);
2354 if (r < 0)
2355 return r;
2356 }
2357
2358 return 1;
2359
2360 null_message:
2361 if (r >= 0 && ret)
2362 *ret = NULL;
2363
2364 return r;
2365 }
2366
2367 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2368 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2369 struct reply_callback *c;
2370 int r;
2371
2372 assert(bus);
2373 assert(bus->state == BUS_CLOSING);
2374
2375 c = hashmap_first(bus->reply_callbacks);
2376 if (c) {
2377 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2378
2379 /* First, fail all outstanding method calls */
2380 r = bus_message_new_synthetic_error(
2381 bus,
2382 c->cookie,
2383 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2384 &m);
2385 if (r < 0)
2386 return r;
2387
2388 r = bus_seal_synthetic_message(bus, m);
2389 if (r < 0)
2390 return r;
2391
2392 if (c->timeout != 0)
2393 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2394
2395 hashmap_remove(bus->reply_callbacks, &c->cookie);
2396
2397 bus->current = m;
2398 bus->iteration_counter++;
2399
2400 r = c->callback(bus, m, c->userdata, &error_buffer);
2401 r = bus_maybe_reply_error(m, r, &error_buffer);
2402 free(c);
2403
2404 goto finish;
2405 }
2406
2407 /* Then, synthesize a Disconnected message */
2408 r = sd_bus_message_new_signal(
2409 bus,
2410 &m,
2411 "/org/freedesktop/DBus/Local",
2412 "org.freedesktop.DBus.Local",
2413 "Disconnected");
2414 if (r < 0)
2415 return r;
2416
2417 m->sender = "org.freedesktop.DBus.Local";
2418
2419 r = bus_seal_synthetic_message(bus, m);
2420 if (r < 0)
2421 return r;
2422
2423 sd_bus_close(bus);
2424
2425 bus->current = m;
2426 bus->iteration_counter++;
2427
2428 r = process_filter(bus, m);
2429 if (r != 0)
2430 goto finish;
2431
2432 r = process_match(bus, m);
2433 if (r != 0)
2434 goto finish;
2435
2436 if (ret) {
2437 *ret = m;
2438 m = NULL;
2439 }
2440
2441 r = 1;
2442
2443 finish:
2444 bus->current = NULL;
2445 return r;
2446 }
2447
2448 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2449 BUS_DONT_DESTROY(bus);
2450 int r;
2451
2452 /* Returns 0 when we didn't do anything. This should cause the
2453 * caller to invoke sd_bus_wait() before returning the next
2454 * time. Returns > 0 when we did something, which possibly
2455 * means *ret is filled in with an unprocessed message. */
2456
2457 assert_return(bus, -EINVAL);
2458 assert_return(!bus_pid_changed(bus), -ECHILD);
2459
2460 /* We don't allow recursively invoking sd_bus_process(). */
2461 assert_return(!bus->current, -EBUSY);
2462
2463 switch (bus->state) {
2464
2465 case BUS_UNSET:
2466 return -ENOTCONN;
2467
2468 case BUS_CLOSED:
2469 return -ECONNRESET;
2470
2471 case BUS_OPENING:
2472 r = bus_socket_process_opening(bus);
2473 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2474 bus_enter_closing(bus);
2475 r = 1;
2476 } else if (r < 0)
2477 return r;
2478 if (ret)
2479 *ret = NULL;
2480 return r;
2481
2482 case BUS_AUTHENTICATING:
2483 r = bus_socket_process_authenticating(bus);
2484 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2485 bus_enter_closing(bus);
2486 r = 1;
2487 } else if (r < 0)
2488 return r;
2489
2490 if (ret)
2491 *ret = NULL;
2492
2493 return r;
2494
2495 case BUS_RUNNING:
2496 case BUS_HELLO:
2497 r = process_running(bus, hint_priority, priority, ret);
2498 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2499 bus_enter_closing(bus);
2500 r = 1;
2501
2502 if (ret)
2503 *ret = NULL;
2504 }
2505
2506 return r;
2507
2508 case BUS_CLOSING:
2509 return process_closing(bus, ret);
2510 }
2511
2512 assert_not_reached("Unknown state");
2513 }
2514
2515 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2516 return bus_process_internal(bus, false, 0, ret);
2517 }
2518
2519 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2520 return bus_process_internal(bus, true, priority, ret);
2521 }
2522
2523 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2524 struct pollfd p[2] = {};
2525 int r, e, n;
2526 struct timespec ts;
2527 usec_t m = (usec_t) -1;
2528
2529 assert(bus);
2530
2531 if (bus->state == BUS_CLOSING)
2532 return 1;
2533
2534 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2535
2536 e = sd_bus_get_events(bus);
2537 if (e < 0)
2538 return e;
2539
2540 if (need_more)
2541 /* The caller really needs some more data, he doesn't
2542 * care about what's already read, or any timeouts
2543 * except its own.*/
2544 e |= POLLIN;
2545 else {
2546 usec_t until;
2547 /* The caller wants to process if there's something to
2548 * process, but doesn't care otherwise */
2549
2550 r = sd_bus_get_timeout(bus, &until);
2551 if (r < 0)
2552 return r;
2553 if (r > 0) {
2554 usec_t nw;
2555 nw = now(CLOCK_MONOTONIC);
2556 m = until > nw ? until - nw : 0;
2557 }
2558 }
2559
2560 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2561 m = timeout_usec;
2562
2563 p[0].fd = bus->input_fd;
2564 if (bus->output_fd == bus->input_fd) {
2565 p[0].events = e;
2566 n = 1;
2567 } else {
2568 p[0].events = e & POLLIN;
2569 p[1].fd = bus->output_fd;
2570 p[1].events = e & POLLOUT;
2571 n = 2;
2572 }
2573
2574 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2575 if (r < 0)
2576 return -errno;
2577
2578 return r > 0 ? 1 : 0;
2579 }
2580
2581 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2582
2583 assert_return(bus, -EINVAL);
2584 assert_return(!bus_pid_changed(bus), -ECHILD);
2585
2586 if (bus->state == BUS_CLOSING)
2587 return 0;
2588
2589 assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2590
2591 if (bus->rqueue_size > 0)
2592 return 0;
2593
2594 return bus_poll(bus, false, timeout_usec);
2595 }
2596
2597 _public_ int sd_bus_flush(sd_bus *bus) {
2598 int r;
2599
2600 assert_return(bus, -EINVAL);
2601 assert_return(!bus_pid_changed(bus), -ECHILD);
2602
2603 if (bus->state == BUS_CLOSING)
2604 return 0;
2605
2606 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2607
2608 r = bus_ensure_running(bus);
2609 if (r < 0)
2610 return r;
2611
2612 if (bus->wqueue_size <= 0)
2613 return 0;
2614
2615 for (;;) {
2616 r = dispatch_wqueue(bus);
2617 if (r < 0) {
2618 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2619 bus_enter_closing(bus);
2620 return -ECONNRESET;
2621 }
2622
2623 return r;
2624 }
2625
2626 if (bus->wqueue_size <= 0)
2627 return 0;
2628
2629 r = bus_poll(bus, false, (uint64_t) -1);
2630 if (r < 0)
2631 return r;
2632 }
2633 }
2634
2635 _public_ int sd_bus_add_filter(sd_bus *bus,
2636 sd_bus_message_handler_t callback,
2637 void *userdata) {
2638
2639 struct filter_callback *f;
2640
2641 assert_return(bus, -EINVAL);
2642 assert_return(callback, -EINVAL);
2643 assert_return(!bus_pid_changed(bus), -ECHILD);
2644
2645 f = new0(struct filter_callback, 1);
2646 if (!f)
2647 return -ENOMEM;
2648 f->callback = callback;
2649 f->userdata = userdata;
2650
2651 bus->filter_callbacks_modified = true;
2652 LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2653 return 0;
2654 }
2655
2656 _public_ int sd_bus_remove_filter(sd_bus *bus,
2657 sd_bus_message_handler_t callback,
2658 void *userdata) {
2659
2660 struct filter_callback *f;
2661
2662 assert_return(bus, -EINVAL);
2663 assert_return(callback, -EINVAL);
2664 assert_return(!bus_pid_changed(bus), -ECHILD);
2665
2666 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2667 if (f->callback == callback && f->userdata == userdata) {
2668 bus->filter_callbacks_modified = true;
2669 LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2670 free(f);
2671 return 1;
2672 }
2673 }
2674
2675 return 0;
2676 }
2677
2678 _public_ int sd_bus_add_match(sd_bus *bus,
2679 const char *match,
2680 sd_bus_message_handler_t callback,
2681 void *userdata) {
2682
2683 struct bus_match_component *components = NULL;
2684 unsigned n_components = 0;
2685 uint64_t cookie = 0;
2686 int r = 0;
2687
2688 assert_return(bus, -EINVAL);
2689 assert_return(match, -EINVAL);
2690 assert_return(!bus_pid_changed(bus), -ECHILD);
2691
2692 r = bus_match_parse(match, &components, &n_components);
2693 if (r < 0)
2694 goto finish;
2695
2696 if (bus->bus_client) {
2697 cookie = ++bus->match_cookie;
2698
2699 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2700 if (r < 0)
2701 goto finish;
2702 }
2703
2704 bus->match_callbacks_modified = true;
2705 r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2706 if (r < 0) {
2707 if (bus->bus_client)
2708 bus_remove_match_internal(bus, match, cookie);
2709 }
2710
2711 finish:
2712 bus_match_parse_free(components, n_components);
2713 return r;
2714 }
2715
2716 _public_ int sd_bus_remove_match(sd_bus *bus,
2717 const char *match,
2718 sd_bus_message_handler_t callback,
2719 void *userdata) {
2720
2721 struct bus_match_component *components = NULL;
2722 unsigned n_components = 0;
2723 int r = 0, q = 0;
2724 uint64_t cookie = 0;
2725
2726 assert_return(bus, -EINVAL);
2727 assert_return(match, -EINVAL);
2728 assert_return(!bus_pid_changed(bus), -ECHILD);
2729
2730 r = bus_match_parse(match, &components, &n_components);
2731 if (r < 0)
2732 return r;
2733
2734 bus->match_callbacks_modified = true;
2735 r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2736
2737 if (bus->bus_client)
2738 q = bus_remove_match_internal(bus, match, cookie);
2739
2740 bus_match_parse_free(components, n_components);
2741
2742 return r < 0 ? r : q;
2743 }
2744
2745 bool bus_pid_changed(sd_bus *bus) {
2746 assert(bus);
2747
2748 /* We don't support people creating a bus connection and
2749 * keeping it around over a fork(). Let's complain. */
2750
2751 return bus->original_pid != getpid();
2752 }
2753
2754 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2755 sd_bus *bus = userdata;
2756 int r;
2757
2758 assert(bus);
2759
2760 r = sd_bus_process(bus, NULL);
2761 if (r < 0)
2762 return r;
2763
2764 return 1;
2765 }
2766
2767 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2768 sd_bus *bus = userdata;
2769 int r;
2770
2771 assert(bus);
2772
2773 r = sd_bus_process(bus, NULL);
2774 if (r < 0)
2775 return r;
2776
2777 return 1;
2778 }
2779
2780 static int prepare_callback(sd_event_source *s, void *userdata) {
2781 sd_bus *bus = userdata;
2782 int r, e;
2783 usec_t until;
2784
2785 assert(s);
2786 assert(bus);
2787
2788 e = sd_bus_get_events(bus);
2789 if (e < 0)
2790 return e;
2791
2792 if (bus->output_fd != bus->input_fd) {
2793
2794 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2795 if (r < 0)
2796 return r;
2797
2798 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2799 if (r < 0)
2800 return r;
2801 } else {
2802 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2803 if (r < 0)
2804 return r;
2805 }
2806
2807 r = sd_bus_get_timeout(bus, &until);
2808 if (r < 0)
2809 return r;
2810 if (r > 0) {
2811 int j;
2812
2813 j = sd_event_source_set_time(bus->time_event_source, until);
2814 if (j < 0)
2815 return j;
2816 }
2817
2818 r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2819 if (r < 0)
2820 return r;
2821
2822 return 1;
2823 }
2824
2825 static int quit_callback(sd_event_source *event, void *userdata) {
2826 sd_bus *bus = userdata;
2827
2828 assert(event);
2829
2830 sd_bus_flush(bus);
2831
2832 return 1;
2833 }
2834
2835 static int attach_io_events(sd_bus *bus) {
2836 int r;
2837
2838 assert(bus);
2839
2840 if (bus->input_fd < 0)
2841 return 0;
2842
2843 if (!bus->event)
2844 return 0;
2845
2846 if (!bus->input_io_event_source) {
2847 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2848 if (r < 0)
2849 return r;
2850
2851 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2852 if (r < 0)
2853 return r;
2854
2855 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2856 } else
2857 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2858
2859 if (r < 0)
2860 return r;
2861
2862 if (bus->output_fd != bus->input_fd) {
2863 assert(bus->output_fd >= 0);
2864
2865 if (!bus->output_io_event_source) {
2866 r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
2867 if (r < 0)
2868 return r;
2869
2870 r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2871 } else
2872 r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2873
2874 if (r < 0)
2875 return r;
2876 }
2877
2878 return 0;
2879 }
2880
2881 static void detach_io_events(sd_bus *bus) {
2882 assert(bus);
2883
2884 if (bus->input_io_event_source) {
2885 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2886 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2887 }
2888
2889 if (bus->output_io_event_source) {
2890 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2891 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2892 }
2893 }
2894
2895 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2896 int r;
2897
2898 assert_return(bus, -EINVAL);
2899 assert_return(!bus->event, -EBUSY);
2900
2901 assert(!bus->input_io_event_source);
2902 assert(!bus->output_io_event_source);
2903 assert(!bus->time_event_source);
2904
2905 if (event)
2906 bus->event = sd_event_ref(event);
2907 else {
2908 r = sd_event_default(&bus->event);
2909 if (r < 0)
2910 return r;
2911 }
2912
2913 bus->event_priority = priority;
2914
2915 r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus);
2916 if (r < 0)
2917 goto fail;
2918
2919 r = sd_event_source_set_priority(bus->time_event_source, priority);
2920 if (r < 0)
2921 goto fail;
2922
2923 r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
2924 if (r < 0)
2925 goto fail;
2926
2927 r = attach_io_events(bus);
2928 if (r < 0)
2929 goto fail;
2930
2931 return 0;
2932
2933 fail:
2934 sd_bus_detach_event(bus);
2935 return r;
2936 }
2937
2938 _public_ int sd_bus_detach_event(sd_bus *bus) {
2939 assert_return(bus, -EINVAL);
2940
2941 if (!bus->event)
2942 return 0;
2943
2944 detach_io_events(bus);
2945
2946 if (bus->time_event_source) {
2947 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2948 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2949 }
2950
2951 if (bus->quit_event_source) {
2952 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2953 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2954 }
2955
2956 if (bus->event)
2957 bus->event = sd_event_unref(bus->event);
2958
2959 return 1;
2960 }
2961
2962 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2963 assert_return(bus, NULL);
2964
2965 return bus->event;
2966 }
2967
2968 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2969 assert_return(bus, NULL);
2970
2971 return bus->current;
2972 }
2973
2974 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2975 sd_bus *b = NULL;
2976 int r;
2977
2978 assert(bus_open);
2979 assert(default_bus);
2980
2981 if (!ret)
2982 return !!*default_bus;
2983
2984 if (*default_bus) {
2985 *ret = sd_bus_ref(*default_bus);
2986 return 0;
2987 }
2988
2989 r = bus_open(&b);
2990 if (r < 0)
2991 return r;
2992
2993 b->default_bus_ptr = default_bus;
2994 b->tid = gettid();
2995 *default_bus = b;
2996
2997 *ret = b;
2998 return 1;
2999 }
3000
3001 _public_ int sd_bus_default_system(sd_bus **ret) {
3002 static thread_local sd_bus *default_system_bus = NULL;
3003
3004 return bus_default(sd_bus_open_system, &default_system_bus, ret);
3005 }
3006
3007 _public_ int sd_bus_default_user(sd_bus **ret) {
3008 static thread_local sd_bus *default_user_bus = NULL;
3009
3010 return bus_default(sd_bus_open_user, &default_user_bus, ret);
3011 }
3012
3013 _public_ int sd_bus_default(sd_bus **ret) {
3014
3015 const char *e;
3016
3017 /* Let's try our best to reuse another cached connection. If
3018 * the starter bus type is set, connect via our normal
3019 * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3020 * we can share the connection with the user/system default
3021 * bus. */
3022
3023 e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3024 if (e) {
3025 if (streq(e, "system"))
3026 return sd_bus_default_system(ret);
3027 else if (streq(e, "user") || streq(e, "session"))
3028 return sd_bus_default_user(ret);
3029 }
3030
3031 /* No type is specified, so we have not other option than to
3032 * use the starter address if it is set. */
3033
3034 e = secure_getenv("DBUS_STARTER_ADDRESS");
3035 if (e) {
3036 static thread_local sd_bus *default_starter_bus = NULL;
3037
3038 return bus_default(sd_bus_open, &default_starter_bus, ret);
3039 }
3040
3041 /* Finally, if nothing is set use the cached connection for
3042 * the right scope */
3043
3044 if (cg_pid_get_owner_uid(0, NULL) >= 0)
3045 return sd_bus_default_user(ret);
3046 else
3047 return sd_bus_default_system(ret);
3048 }
3049
3050 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3051 assert_return(b, -EINVAL);
3052 assert_return(tid, -EINVAL);
3053 assert_return(!bus_pid_changed(b), -ECHILD);
3054
3055 if (b->tid != 0) {
3056 *tid = b->tid;
3057 return 0;
3058 }
3059
3060 if (b->event)
3061 return sd_event_get_tid(b->event, tid);
3062
3063 return -ENXIO;
3064 }
3065
3066 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3067 _cleanup_free_ char *e = NULL;
3068 char *ret;
3069
3070 assert_return(object_path_is_valid(prefix), -EINVAL);
3071 assert_return(external_id, -EINVAL);
3072 assert_return(ret_path, -EINVAL);
3073
3074 e = bus_label_escape(external_id);
3075 if (!e)
3076 return -ENOMEM;
3077
3078 ret = strjoin(prefix, "/", e, NULL);
3079 if (!ret)
3080 return -ENOMEM;
3081
3082 *ret_path = ret;
3083 return 0;
3084 }
3085
3086 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3087 const char *e;
3088 char *ret;
3089
3090 assert_return(object_path_is_valid(path), -EINVAL);
3091 assert_return(object_path_is_valid(prefix), -EINVAL);
3092 assert_return(external_id, -EINVAL);
3093
3094 e = object_path_startswith(path, prefix);
3095 if (!e) {
3096 *external_id = NULL;
3097 return 0;
3098 }
3099
3100 ret = bus_label_unescape(e);
3101 if (!ret)
3102 return -ENOMEM;
3103
3104 *external_id = ret;
3105 return 1;
3106 }
3107
3108 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3109 sd_bus_creds *c;
3110 pid_t pid = 0;
3111 int r;
3112
3113 assert_return(bus, -EINVAL);
3114 assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3115 assert_return(ret, -EINVAL);
3116 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3117 assert_return(!bus_pid_changed(bus), -ECHILD);
3118 assert_return(!bus->is_kernel, -ENOTSUP);
3119
3120 if (!bus->ucred_valid && !isempty(bus->label))
3121 return -ENODATA;
3122
3123 c = bus_creds_new();
3124 if (!c)
3125 return -ENOMEM;
3126
3127 if (bus->ucred_valid) {
3128 pid = c->pid = bus->ucred.pid;
3129 c->uid = bus->ucred.uid;
3130 c->gid = bus->ucred.gid;
3131
3132 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3133 }
3134
3135 if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3136 c->label = strdup(bus->label);
3137 if (!c->label) {
3138 sd_bus_creds_unref(c);
3139 return -ENOMEM;
3140 }
3141
3142 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3143 }
3144
3145 r = bus_creds_add_more(c, mask, pid, 0);
3146 if (r < 0)
3147 return r;
3148
3149 *ret = c;
3150 return 0;
3151 }
3152
3153 _public_ int sd_bus_try_close(sd_bus *bus) {
3154 int r;
3155
3156 assert_return(bus, -EINVAL);
3157 assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3158 assert_return(!bus_pid_changed(bus), -ECHILD);
3159 assert_return(bus->is_kernel, -ENOTSUP);
3160
3161 if (bus->rqueue_size > 0)
3162 return -EBUSY;
3163
3164 if (bus->wqueue_size > 0)
3165 return -EBUSY;
3166
3167 r = bus_kernel_try_close(bus);
3168 if (r < 0)
3169 return r;
3170
3171 sd_bus_close(bus);
3172 return 0;
3173 }
3174
3175 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3176 assert_return(bus, -EINVAL);
3177 assert_return(name, -EINVAL);
3178 assert_return(!bus_pid_changed(bus), -ECHILD);
3179
3180 *name = bus->connection_name;
3181 return 0;
3182 }
Unnamed repository; edit this file 'description' to name the repository.