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