]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd-bus/sd-bus.c
projects / thirdparty / systemd.git / blob
? search:


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