]> 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
bus: synthesize timeout message errors instead of returning error codes
[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
30 #include "util.h"
31 #include "macro.h"
32 #include "strv.h"
33 #include "set.h"
34 #include "missing.h"
35
36 #include "sd-bus.h"
37 #include "bus-internal.h"
38 #include "bus-message.h"
39 #include "bus-type.h"
40 #include "bus-socket.h"
41 #include "bus-kernel.h"
42 #include "bus-control.h"
43
44 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
45
46 static void bus_free(sd_bus *b) {
47 struct filter_callback *f;
48 struct object_callback *c;
49 unsigned i;
50
51 assert(b);
52
53 sd_bus_close(b);
54
55 free(b->rbuffer);
56 free(b->unique_name);
57 free(b->auth_buffer);
58 free(b->address);
59 free(b->kernel);
60
61 free(b->exec_path);
62 strv_free(b->exec_argv);
63
64 close_many(b->fds, b->n_fds);
65 free(b->fds);
66
67 for (i = 0; i < b->rqueue_size; i++)
68 sd_bus_message_unref(b->rqueue[i]);
69 free(b->rqueue);
70
71 for (i = 0; i < b->wqueue_size; i++)
72 sd_bus_message_unref(b->wqueue[i]);
73 free(b->wqueue);
74
75 hashmap_free_free(b->reply_callbacks);
76 prioq_free(b->reply_callbacks_prioq);
77
78 while ((f = b->filter_callbacks)) {
79 LIST_REMOVE(struct filter_callback, callbacks, b->filter_callbacks, f);
80 free(f);
81 }
82
83 while ((c = hashmap_steal_first(b->object_callbacks))) {
84 free(c->path);
85 free(c);
86 }
87
88 hashmap_free(b->object_callbacks);
89 bus_match_free(&b->match_callbacks);
90
91 bus_kernel_flush_memfd(b);
92
93 free(b);
94 }
95
96 int sd_bus_new(sd_bus **ret) {
97 sd_bus *r;
98
99 if (!ret)
100 return -EINVAL;
101
102 r = new0(sd_bus, 1);
103 if (!r)
104 return -ENOMEM;
105
106 r->n_ref = 1;
107 r->input_fd = r->output_fd = -1;
108 r->message_version = 1;
109 r->negotiate_fds = true;
110
111 /* We guarantee that wqueue always has space for at least one
112 * entry */
113 r->wqueue = new(sd_bus_message*, 1);
114 if (!r->wqueue) {
115 free(r);
116 return -ENOMEM;
117 }
118
119 *ret = r;
120 return 0;
121 }
122
123 int sd_bus_set_address(sd_bus *bus, const char *address) {
124 char *a;
125
126 if (!bus)
127 return -EINVAL;
128 if (bus->state != BUS_UNSET)
129 return -EPERM;
130 if (!address)
131 return -EINVAL;
132
133 a = strdup(address);
134 if (!a)
135 return -ENOMEM;
136
137 free(bus->address);
138 bus->address = a;
139
140 return 0;
141 }
142
143 int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
144 if (!bus)
145 return -EINVAL;
146 if (bus->state != BUS_UNSET)
147 return -EPERM;
148 if (input_fd < 0)
149 return -EINVAL;
150 if (output_fd < 0)
151 return -EINVAL;
152
153 bus->input_fd = input_fd;
154 bus->output_fd = output_fd;
155 return 0;
156 }
157
158 int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
159 char *p, **a;
160
161 if (!bus)
162 return -EINVAL;
163 if (bus->state != BUS_UNSET)
164 return -EPERM;
165 if (!path)
166 return -EINVAL;
167 if (strv_isempty(argv))
168 return -EINVAL;
169
170 p = strdup(path);
171 if (!p)
172 return -ENOMEM;
173
174 a = strv_copy(argv);
175 if (!a) {
176 free(p);
177 return -ENOMEM;
178 }
179
180 free(bus->exec_path);
181 strv_free(bus->exec_argv);
182
183 bus->exec_path = p;
184 bus->exec_argv = a;
185
186 return 0;
187 }
188
189 int sd_bus_set_bus_client(sd_bus *bus, int b) {
190 if (!bus)
191 return -EINVAL;
192 if (bus->state != BUS_UNSET)
193 return -EPERM;
194
195 bus->bus_client = !!b;
196 return 0;
197 }
198
199 int sd_bus_set_negotiate_fds(sd_bus *bus, int b) {
200 if (!bus)
201 return -EINVAL;
202 if (bus->state != BUS_UNSET)
203 return -EPERM;
204
205 bus->negotiate_fds = !!b;
206 return 0;
207 }
208
209 int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
210 if (!bus)
211 return -EINVAL;
212 if (!b && !sd_id128_equal(server_id, SD_ID128_NULL))
213 return -EINVAL;
214 if (bus->state != BUS_UNSET)
215 return -EPERM;
216
217 bus->is_server = !!b;
218 bus->server_id = server_id;
219 return 0;
220 }
221
222 int sd_bus_set_anonymous(sd_bus *bus, int b) {
223 if (!bus)
224 return -EINVAL;
225 if (bus->state != BUS_UNSET)
226 return -EPERM;
227
228 bus->anonymous_auth = !!b;
229 return 0;
230 }
231
232 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata) {
233 const char *s;
234 int r;
235
236 assert(bus);
237 assert(bus->state == BUS_HELLO);
238 assert(reply);
239
240 r = bus_message_to_errno(reply);
241 if (r < 0)
242 return r;
243
244 r = sd_bus_message_read(reply, "s", &s);
245 if (r < 0)
246 return r;
247
248 if (!service_name_is_valid(s) || s[0] != ':')
249 return -EBADMSG;
250
251 bus->unique_name = strdup(s);
252 if (!bus->unique_name)
253 return -ENOMEM;
254
255 bus->state = BUS_RUNNING;
256
257 return 1;
258 }
259
260 static int bus_send_hello(sd_bus *bus) {
261 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
262 int r;
263
264 assert(bus);
265
266 if (!bus->bus_client || bus->is_kernel)
267 return 0;
268
269 r = sd_bus_message_new_method_call(
270 bus,
271 "org.freedesktop.DBus",
272 "/",
273 "org.freedesktop.DBus",
274 "Hello",
275 &m);
276 if (r < 0)
277 return r;
278
279 return sd_bus_send_with_reply(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
280 }
281
282 int bus_start_running(sd_bus *bus) {
283 assert(bus);
284
285 if (bus->bus_client && !bus->is_kernel) {
286 bus->state = BUS_HELLO;
287 return 1;
288 }
289
290 bus->state = BUS_RUNNING;
291 return 1;
292 }
293
294 static int parse_address_key(const char **p, const char *key, char **value) {
295 size_t l, n = 0;
296 const char *a;
297 char *r = NULL;
298
299 assert(p);
300 assert(*p);
301 assert(value);
302
303 if (key) {
304 l = strlen(key);
305 if (strncmp(*p, key, l) != 0)
306 return 0;
307
308 if ((*p)[l] != '=')
309 return 0;
310
311 if (*value)
312 return -EINVAL;
313
314 a = *p + l + 1;
315 } else
316 a = *p;
317
318 while (*a != ';' && *a != ',' && *a != 0) {
319 char c, *t;
320
321 if (*a == '%') {
322 int x, y;
323
324 x = unhexchar(a[1]);
325 if (x < 0) {
326 free(r);
327 return x;
328 }
329
330 y = unhexchar(a[2]);
331 if (y < 0) {
332 free(r);
333 return y;
334 }
335
336 c = (char) ((x << 4) | y);
337 a += 3;
338 } else {
339 c = *a;
340 a++;
341 }
342
343 t = realloc(r, n + 2);
344 if (!t) {
345 free(r);
346 return -ENOMEM;
347 }
348
349 r = t;
350 r[n++] = c;
351 }
352
353 if (!r) {
354 r = strdup("");
355 if (!r)
356 return -ENOMEM;
357 } else
358 r[n] = 0;
359
360 if (*a == ',')
361 a++;
362
363 *p = a;
364
365 free(*value);
366 *value = r;
367
368 return 1;
369 }
370
371 static void skip_address_key(const char **p) {
372 assert(p);
373 assert(*p);
374
375 *p += strcspn(*p, ",");
376
377 if (**p == ',')
378 (*p) ++;
379 }
380
381 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
382 _cleanup_free_ char *path = NULL, *abstract = NULL;
383 size_t l;
384 int r;
385
386 assert(b);
387 assert(p);
388 assert(*p);
389 assert(guid);
390
391 while (**p != 0 && **p != ';') {
392 r = parse_address_key(p, "guid", guid);
393 if (r < 0)
394 return r;
395 else if (r > 0)
396 continue;
397
398 r = parse_address_key(p, "path", &path);
399 if (r < 0)
400 return r;
401 else if (r > 0)
402 continue;
403
404 r = parse_address_key(p, "abstract", &abstract);
405 if (r < 0)
406 return r;
407 else if (r > 0)
408 continue;
409
410 skip_address_key(p);
411 }
412
413 if (!path && !abstract)
414 return -EINVAL;
415
416 if (path && abstract)
417 return -EINVAL;
418
419 if (path) {
420 l = strlen(path);
421 if (l > sizeof(b->sockaddr.un.sun_path))
422 return -E2BIG;
423
424 b->sockaddr.un.sun_family = AF_UNIX;
425 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
426 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
427 } else if (abstract) {
428 l = strlen(abstract);
429 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
430 return -E2BIG;
431
432 b->sockaddr.un.sun_family = AF_UNIX;
433 b->sockaddr.un.sun_path[0] = 0;
434 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
435 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
436 }
437
438 return 0;
439 }
440
441 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
442 _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
443 int r;
444 struct addrinfo *result, hints = {
445 .ai_socktype = SOCK_STREAM,
446 .ai_flags = AI_ADDRCONFIG,
447 };
448
449 assert(b);
450 assert(p);
451 assert(*p);
452 assert(guid);
453
454 while (**p != 0 && **p != ';') {
455 r = parse_address_key(p, "guid", guid);
456 if (r < 0)
457 return r;
458 else if (r > 0)
459 continue;
460
461 r = parse_address_key(p, "host", &host);
462 if (r < 0)
463 return r;
464 else if (r > 0)
465 continue;
466
467 r = parse_address_key(p, "port", &port);
468 if (r < 0)
469 return r;
470 else if (r > 0)
471 continue;
472
473 r = parse_address_key(p, "family", &family);
474 if (r < 0)
475 return r;
476 else if (r > 0)
477 continue;
478
479 skip_address_key(p);
480 }
481
482 if (!host || !port)
483 return -EINVAL;
484
485 if (family) {
486 if (streq(family, "ipv4"))
487 hints.ai_family = AF_INET;
488 else if (streq(family, "ipv6"))
489 hints.ai_family = AF_INET6;
490 else
491 return -EINVAL;
492 }
493
494 r = getaddrinfo(host, port, &hints, &result);
495 if (r == EAI_SYSTEM)
496 return -errno;
497 else if (r != 0)
498 return -EADDRNOTAVAIL;
499
500 memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
501 b->sockaddr_size = result->ai_addrlen;
502
503 freeaddrinfo(result);
504
505 return 0;
506 }
507
508 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
509 char *path = NULL;
510 unsigned n_argv = 0, j;
511 char **argv = NULL;
512 int r;
513
514 assert(b);
515 assert(p);
516 assert(*p);
517 assert(guid);
518
519 while (**p != 0 && **p != ';') {
520 r = parse_address_key(p, "guid", guid);
521 if (r < 0)
522 goto fail;
523 else if (r > 0)
524 continue;
525
526 r = parse_address_key(p, "path", &path);
527 if (r < 0)
528 goto fail;
529 else if (r > 0)
530 continue;
531
532 if (startswith(*p, "argv")) {
533 unsigned ul;
534
535 errno = 0;
536 ul = strtoul(*p + 4, (char**) p, 10);
537 if (errno > 0 || **p != '=' || ul > 256) {
538 r = -EINVAL;
539 goto fail;
540 }
541
542 (*p) ++;
543
544 if (ul >= n_argv) {
545 char **x;
546
547 x = realloc(argv, sizeof(char*) * (ul + 2));
548 if (!x) {
549 r = -ENOMEM;
550 goto fail;
551 }
552
553 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
554
555 argv = x;
556 n_argv = ul + 1;
557 }
558
559 r = parse_address_key(p, NULL, argv + ul);
560 if (r < 0)
561 goto fail;
562
563 continue;
564 }
565
566 skip_address_key(p);
567 }
568
569 if (!path) {
570 r = -EINVAL;
571 goto fail;
572 }
573
574 /* Make sure there are no holes in the array, with the
575 * exception of argv[0] */
576 for (j = 1; j < n_argv; j++)
577 if (!argv[j]) {
578 r = -EINVAL;
579 goto fail;
580 }
581
582 if (argv && argv[0] == NULL) {
583 argv[0] = strdup(path);
584 if (!argv[0]) {
585 r = -ENOMEM;
586 goto fail;
587 }
588 }
589
590 b->exec_path = path;
591 b->exec_argv = argv;
592 return 0;
593
594 fail:
595 for (j = 0; j < n_argv; j++)
596 free(argv[j]);
597
598 free(argv);
599 free(path);
600 return r;
601 }
602
603 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
604 _cleanup_free_ char *path = NULL;
605 int r;
606
607 assert(b);
608 assert(p);
609 assert(*p);
610 assert(guid);
611
612 while (**p != 0 && **p != ';') {
613 r = parse_address_key(p, "guid", guid);
614 if (r < 0)
615 return r;
616 else if (r > 0)
617 continue;
618
619 r = parse_address_key(p, "path", &path);
620 if (r < 0)
621 return r;
622 else if (r > 0)
623 continue;
624
625 skip_address_key(p);
626 }
627
628 if (!path)
629 return -EINVAL;
630
631 free(b->kernel);
632 b->kernel = path;
633 path = NULL;
634
635 return 0;
636 }
637
638 static void bus_reset_parsed_address(sd_bus *b) {
639 assert(b);
640
641 zero(b->sockaddr);
642 b->sockaddr_size = 0;
643 strv_free(b->exec_argv);
644 free(b->exec_path);
645 b->exec_path = NULL;
646 b->exec_argv = NULL;
647 b->server_id = SD_ID128_NULL;
648 free(b->kernel);
649 b->kernel = NULL;
650 }
651
652 static int bus_parse_next_address(sd_bus *b) {
653 _cleanup_free_ char *guid = NULL;
654 const char *a;
655 int r;
656
657 assert(b);
658
659 if (!b->address)
660 return 0;
661 if (b->address[b->address_index] == 0)
662 return 0;
663
664 bus_reset_parsed_address(b);
665
666 a = b->address + b->address_index;
667
668 while (*a != 0) {
669
670 if (*a == ';') {
671 a++;
672 continue;
673 }
674
675 if (startswith(a, "unix:")) {
676 a += 5;
677
678 r = parse_unix_address(b, &a, &guid);
679 if (r < 0)
680 return r;
681 break;
682
683 } else if (startswith(a, "tcp:")) {
684
685 a += 4;
686 r = parse_tcp_address(b, &a, &guid);
687 if (r < 0)
688 return r;
689
690 break;
691
692 } else if (startswith(a, "unixexec:")) {
693
694 a += 9;
695 r = parse_exec_address(b, &a, &guid);
696 if (r < 0)
697 return r;
698
699 break;
700
701 } else if (startswith(a, "kernel:")) {
702
703 a += 7;
704 r = parse_kernel_address(b, &a, &guid);
705 if (r < 0)
706 return r;
707
708 break;
709 }
710
711 a = strchr(a, ';');
712 if (!a)
713 return 0;
714 }
715
716 if (guid) {
717 r = sd_id128_from_string(guid, &b->server_id);
718 if (r < 0)
719 return r;
720 }
721
722 b->address_index = a - b->address;
723 return 1;
724 }
725
726 static int bus_start_address(sd_bus *b) {
727 int r;
728
729 assert(b);
730
731 for (;;) {
732 sd_bus_close(b);
733
734 if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
735
736 r = bus_socket_connect(b);
737 if (r >= 0)
738 return r;
739
740 b->last_connect_error = -r;
741
742 } else if (b->exec_path) {
743
744 r = bus_socket_exec(b);
745 if (r >= 0)
746 return r;
747
748 b->last_connect_error = -r;
749 } else if (b->kernel) {
750
751 r = bus_kernel_connect(b);
752 if (r >= 0)
753 return r;
754
755 b->last_connect_error = -r;
756 }
757
758 r = bus_parse_next_address(b);
759 if (r < 0)
760 return r;
761 if (r == 0)
762 return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
763 }
764 }
765
766 int bus_next_address(sd_bus *b) {
767 assert(b);
768
769 bus_reset_parsed_address(b);
770 return bus_start_address(b);
771 }
772
773 static int bus_start_fd(sd_bus *b) {
774 struct stat st;
775 int r;
776
777 assert(b);
778 assert(b->input_fd >= 0);
779 assert(b->output_fd >= 0);
780
781 r = fd_nonblock(b->input_fd, true);
782 if (r < 0)
783 return r;
784
785 r = fd_cloexec(b->input_fd, true);
786 if (r < 0)
787 return r;
788
789 if (b->input_fd != b->output_fd) {
790 r = fd_nonblock(b->output_fd, true);
791 if (r < 0)
792 return r;
793
794 r = fd_cloexec(b->output_fd, true);
795 if (r < 0)
796 return r;
797 }
798
799 if (fstat(b->input_fd, &st) < 0)
800 return -errno;
801
802 if (S_ISCHR(b->input_fd))
803 return bus_kernel_take_fd(b);
804 else
805 return bus_socket_take_fd(b);
806 }
807
808 int sd_bus_start(sd_bus *bus) {
809 int r;
810
811 if (!bus)
812 return -EINVAL;
813 if (bus->state != BUS_UNSET)
814 return -EPERM;
815
816 bus->state = BUS_OPENING;
817
818 if (bus->is_server && bus->bus_client)
819 return -EINVAL;
820
821 if (bus->input_fd >= 0)
822 r = bus_start_fd(bus);
823 else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel)
824 r = bus_start_address(bus);
825 else
826 return -EINVAL;
827
828 if (r < 0)
829 return r;
830
831 return bus_send_hello(bus);
832 }
833
834 int sd_bus_open_system(sd_bus **ret) {
835 const char *e;
836 sd_bus *b;
837 int r;
838
839 if (!ret)
840 return -EINVAL;
841
842 r = sd_bus_new(&b);
843 if (r < 0)
844 return r;
845
846 e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
847 if (e) {
848 r = sd_bus_set_address(b, e);
849 if (r < 0)
850 goto fail;
851 } else {
852 b->sockaddr.un.sun_family = AF_UNIX;
853 strncpy(b->sockaddr.un.sun_path, "/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
854 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/dbus/system_bus_socket") - 1;
855 }
856
857 b->bus_client = true;
858
859 r = sd_bus_start(b);
860 if (r < 0)
861 goto fail;
862
863 *ret = b;
864 return 0;
865
866 fail:
867 bus_free(b);
868 return r;
869 }
870
871 int sd_bus_open_user(sd_bus **ret) {
872 const char *e;
873 sd_bus *b;
874 size_t l;
875 int r;
876
877 if (!ret)
878 return -EINVAL;
879
880 r = sd_bus_new(&b);
881 if (r < 0)
882 return r;
883
884 e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
885 if (e) {
886 r = sd_bus_set_address(b, e);
887 if (r < 0)
888 goto fail;
889 } else {
890 e = secure_getenv("XDG_RUNTIME_DIR");
891 if (!e) {
892 r = -ENOENT;
893 goto fail;
894 }
895
896 l = strlen(e);
897 if (l + 4 > sizeof(b->sockaddr.un.sun_path)) {
898 r = -E2BIG;
899 goto fail;
900 }
901
902 b->sockaddr.un.sun_family = AF_UNIX;
903 memcpy(mempcpy(b->sockaddr.un.sun_path, e, l), "/bus", 4);
904 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l + 4;
905 }
906
907 b->bus_client = true;
908
909 r = sd_bus_start(b);
910 if (r < 0)
911 goto fail;
912
913 *ret = b;
914 return 0;
915
916 fail:
917 bus_free(b);
918 return r;
919 }
920
921 void sd_bus_close(sd_bus *bus) {
922 if (!bus)
923 return;
924
925 if (bus->input_fd >= 0)
926 close_nointr_nofail(bus->input_fd);
927 if (bus->output_fd >= 0 && bus->output_fd != bus->input_fd)
928 close_nointr_nofail(bus->output_fd);
929
930 bus->input_fd = bus->output_fd = -1;
931 }
932
933 sd_bus *sd_bus_ref(sd_bus *bus) {
934 if (!bus)
935 return NULL;
936
937 assert(bus->n_ref > 0);
938
939 bus->n_ref++;
940 return bus;
941 }
942
943 sd_bus *sd_bus_unref(sd_bus *bus) {
944 if (!bus)
945 return NULL;
946
947 assert(bus->n_ref > 0);
948 bus->n_ref--;
949
950 if (bus->n_ref <= 0)
951 bus_free(bus);
952
953 return NULL;
954 }
955
956 int sd_bus_is_open(sd_bus *bus) {
957 if (!bus)
958 return -EINVAL;
959
960 return bus->state != BUS_UNSET && bus->input_fd >= 0;
961 }
962
963 int sd_bus_can_send(sd_bus *bus, char type) {
964 int r;
965
966 if (!bus)
967 return -EINVAL;
968 if (bus->output_fd < 0)
969 return -ENOTCONN;
970
971 if (type == SD_BUS_TYPE_UNIX_FD) {
972 if (!bus->negotiate_fds)
973 return 0;
974
975 r = bus_ensure_running(bus);
976 if (r < 0)
977 return r;
978
979 return bus->can_fds;
980 }
981
982 return bus_type_is_valid(type);
983 }
984
985 int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
986 int r;
987
988 if (!bus)
989 return -EINVAL;
990 if (!server_id)
991 return -EINVAL;
992
993 r = bus_ensure_running(bus);
994 if (r < 0)
995 return r;
996
997 *server_id = bus->server_id;
998 return 0;
999 }
1000
1001 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1002 assert(m);
1003
1004 if (m->header->version > b->message_version)
1005 return -EPERM;
1006
1007 if (m->sealed)
1008 return 0;
1009
1010 return bus_message_seal(m, ++b->serial);
1011 }
1012
1013 static int dispatch_wqueue(sd_bus *bus) {
1014 int r, ret = 0;
1015
1016 assert(bus);
1017 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1018
1019 if (bus->output_fd < 0)
1020 return -ENOTCONN;
1021
1022 while (bus->wqueue_size > 0) {
1023
1024 if (bus->is_kernel)
1025 r = bus_kernel_write_message(bus, bus->wqueue[0]);
1026 else
1027 r = bus_socket_write_message(bus, bus->wqueue[0], &bus->windex);
1028
1029 if (r < 0) {
1030 sd_bus_close(bus);
1031 return r;
1032 } else if (r == 0)
1033 /* Didn't do anything this time */
1034 return ret;
1035 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1036 /* Fully written. Let's drop the entry from
1037 * the queue.
1038 *
1039 * This isn't particularly optimized, but
1040 * well, this is supposed to be our worst-case
1041 * buffer only, and the socket buffer is
1042 * supposed to be our primary buffer, and if
1043 * it got full, then all bets are off
1044 * anyway. */
1045
1046 sd_bus_message_unref(bus->wqueue[0]);
1047 bus->wqueue_size --;
1048 memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1049 bus->windex = 0;
1050
1051 ret = 1;
1052 }
1053 }
1054
1055 return ret;
1056 }
1057
1058 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1059 sd_bus_message *z = NULL;
1060 int r, ret = 0;
1061
1062 assert(bus);
1063 assert(m);
1064 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1065
1066 if (bus->input_fd < 0)
1067 return -ENOTCONN;
1068
1069 if (bus->rqueue_size > 0) {
1070 /* Dispatch a queued message */
1071
1072 *m = bus->rqueue[0];
1073 bus->rqueue_size --;
1074 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1075 return 1;
1076 }
1077
1078 /* Try to read a new message */
1079 do {
1080 if (bus->is_kernel)
1081 r = bus_kernel_read_message(bus, &z);
1082 else
1083 r = bus_socket_read_message(bus, &z);
1084
1085 if (r < 0) {
1086 sd_bus_close(bus);
1087 return r;
1088 }
1089 if (r == 0)
1090 return ret;
1091
1092 r = 1;
1093 } while (!z);
1094
1095 *m = z;
1096 return 1;
1097 }
1098
1099 int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1100 int r;
1101
1102 if (!bus)
1103 return -EINVAL;
1104 if (bus->state == BUS_UNSET)
1105 return -ENOTCONN;
1106 if (bus->output_fd < 0)
1107 return -ENOTCONN;
1108 if (!m)
1109 return -EINVAL;
1110
1111 if (m->n_fds > 0) {
1112 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1113 if (r < 0)
1114 return r;
1115 if (r == 0)
1116 return -ENOTSUP;
1117 }
1118
1119 /* If the serial number isn't kept, then we know that no reply
1120 * is expected */
1121 if (!serial && !m->sealed)
1122 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1123
1124 r = bus_seal_message(bus, m);
1125 if (r < 0)
1126 return r;
1127
1128 /* If this is a reply and no reply was requested, then let's
1129 * suppress this, if we can */
1130 if (m->dont_send && !serial)
1131 return 0;
1132
1133 if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1134 size_t idx = 0;
1135
1136 if (bus->is_kernel)
1137 r = bus_kernel_write_message(bus, m);
1138 else
1139 r = bus_socket_write_message(bus, m, &idx);
1140
1141 if (r < 0) {
1142 sd_bus_close(bus);
1143 return r;
1144 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m)) {
1145 /* Wasn't fully written. So let's remember how
1146 * much was written. Note that the first entry
1147 * of the wqueue array is always allocated so
1148 * that we always can remember how much was
1149 * written. */
1150 bus->wqueue[0] = sd_bus_message_ref(m);
1151 bus->wqueue_size = 1;
1152 bus->windex = idx;
1153 }
1154 } else {
1155 sd_bus_message **q;
1156
1157 /* Just append it to the queue. */
1158
1159 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1160 return -ENOBUFS;
1161
1162 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1163 if (!q)
1164 return -ENOMEM;
1165
1166 bus->wqueue = q;
1167 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1168 }
1169
1170 if (serial)
1171 *serial = BUS_MESSAGE_SERIAL(m);
1172
1173 return 0;
1174 }
1175
1176 static usec_t calc_elapse(uint64_t usec) {
1177 if (usec == (uint64_t) -1)
1178 return 0;
1179
1180 if (usec == 0)
1181 usec = BUS_DEFAULT_TIMEOUT;
1182
1183 return now(CLOCK_MONOTONIC) + usec;
1184 }
1185
1186 static int timeout_compare(const void *a, const void *b) {
1187 const struct reply_callback *x = a, *y = b;
1188
1189 if (x->timeout != 0 && y->timeout == 0)
1190 return -1;
1191
1192 if (x->timeout == 0 && y->timeout != 0)
1193 return 1;
1194
1195 if (x->timeout < y->timeout)
1196 return -1;
1197
1198 if (x->timeout > y->timeout)
1199 return 1;
1200
1201 return 0;
1202 }
1203
1204 int sd_bus_send_with_reply(
1205 sd_bus *bus,
1206 sd_bus_message *m,
1207 sd_bus_message_handler_t callback,
1208 void *userdata,
1209 uint64_t usec,
1210 uint64_t *serial) {
1211
1212 struct reply_callback *c;
1213 int r;
1214
1215 if (!bus)
1216 return -EINVAL;
1217 if (bus->state == BUS_UNSET)
1218 return -ENOTCONN;
1219 if (bus->output_fd < 0)
1220 return -ENOTCONN;
1221 if (!m)
1222 return -EINVAL;
1223 if (!callback)
1224 return -EINVAL;
1225 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1226 return -EINVAL;
1227 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1228 return -EINVAL;
1229
1230 r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1231 if (r < 0)
1232 return r;
1233
1234 if (usec != (uint64_t) -1) {
1235 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1236 if (r < 0)
1237 return r;
1238 }
1239
1240 r = bus_seal_message(bus, m);
1241 if (r < 0)
1242 return r;
1243
1244 c = new0(struct reply_callback, 1);
1245 if (!c)
1246 return -ENOMEM;
1247
1248 c->callback = callback;
1249 c->userdata = userdata;
1250 c->serial = BUS_MESSAGE_SERIAL(m);
1251 c->timeout = calc_elapse(usec);
1252
1253 r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1254 if (r < 0) {
1255 free(c);
1256 return r;
1257 }
1258
1259 if (c->timeout != 0) {
1260 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1261 if (r < 0) {
1262 c->timeout = 0;
1263 sd_bus_send_with_reply_cancel(bus, c->serial);
1264 return r;
1265 }
1266 }
1267
1268 r = sd_bus_send(bus, m, serial);
1269 if (r < 0) {
1270 sd_bus_send_with_reply_cancel(bus, c->serial);
1271 return r;
1272 }
1273
1274 return r;
1275 }
1276
1277 int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
1278 struct reply_callback *c;
1279
1280 if (!bus)
1281 return -EINVAL;
1282 if (serial == 0)
1283 return -EINVAL;
1284
1285 c = hashmap_remove(bus->reply_callbacks, &serial);
1286 if (!c)
1287 return 0;
1288
1289 if (c->timeout != 0)
1290 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1291
1292 free(c);
1293 return 1;
1294 }
1295
1296 int bus_ensure_running(sd_bus *bus) {
1297 int r;
1298
1299 assert(bus);
1300
1301 if (bus->input_fd < 0)
1302 return -ENOTCONN;
1303 if (bus->state == BUS_UNSET)
1304 return -ENOTCONN;
1305
1306 if (bus->state == BUS_RUNNING)
1307 return 1;
1308
1309 for (;;) {
1310 r = sd_bus_process(bus, NULL);
1311 if (r < 0)
1312 return r;
1313 if (bus->state == BUS_RUNNING)
1314 return 1;
1315 if (r > 0)
1316 continue;
1317
1318 r = sd_bus_wait(bus, (uint64_t) -1);
1319 if (r < 0)
1320 return r;
1321 }
1322 }
1323
1324 int sd_bus_send_with_reply_and_block(
1325 sd_bus *bus,
1326 sd_bus_message *m,
1327 uint64_t usec,
1328 sd_bus_error *error,
1329 sd_bus_message **reply) {
1330
1331 int r;
1332 usec_t timeout;
1333 uint64_t serial;
1334 bool room = false;
1335
1336 if (!bus)
1337 return -EINVAL;
1338 if (bus->output_fd < 0)
1339 return -ENOTCONN;
1340 if (bus->state == BUS_UNSET)
1341 return -ENOTCONN;
1342 if (!m)
1343 return -EINVAL;
1344 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1345 return -EINVAL;
1346 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1347 return -EINVAL;
1348 if (bus_error_is_dirty(error))
1349 return -EINVAL;
1350
1351 r = bus_ensure_running(bus);
1352 if (r < 0)
1353 return r;
1354
1355 r = sd_bus_send(bus, m, &serial);
1356 if (r < 0)
1357 return r;
1358
1359 timeout = calc_elapse(usec);
1360
1361 for (;;) {
1362 usec_t left;
1363 sd_bus_message *incoming = NULL;
1364
1365 if (!room) {
1366 sd_bus_message **q;
1367
1368 if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1369 return -ENOBUFS;
1370
1371 /* Make sure there's room for queuing this
1372 * locally, before we read the message */
1373
1374 q = realloc(bus->rqueue, (bus->rqueue_size + 1) * sizeof(sd_bus_message*));
1375 if (!q)
1376 return -ENOMEM;
1377
1378 bus->rqueue = q;
1379 room = true;
1380 }
1381
1382 if (bus->is_kernel)
1383 r = bus_kernel_read_message(bus, &incoming);
1384 else
1385 r = bus_socket_read_message(bus, &incoming);
1386 if (r < 0)
1387 return r;
1388 if (incoming) {
1389
1390 if (incoming->reply_serial == serial) {
1391 /* Found a match! */
1392
1393 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_RETURN) {
1394
1395 if (reply)
1396 *reply = incoming;
1397 else
1398 sd_bus_message_unref(incoming);
1399
1400 return 0;
1401 }
1402
1403 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR) {
1404 int k;
1405
1406 r = sd_bus_error_copy(error, &incoming->error);
1407 if (r < 0) {
1408 sd_bus_message_unref(incoming);
1409 return r;
1410 }
1411
1412 k = bus_error_to_errno(&incoming->error);
1413 sd_bus_message_unref(incoming);
1414 return k;
1415 }
1416
1417 sd_bus_message_unref(incoming);
1418 return -EIO;
1419 }
1420
1421 /* There's already guaranteed to be room for
1422 * this, so need to resize things here */
1423 bus->rqueue[bus->rqueue_size ++] = incoming;
1424 room = false;
1425
1426 /* Try to read more, right-away */
1427 continue;
1428 }
1429 if (r != 0)
1430 continue;
1431
1432 if (timeout > 0) {
1433 usec_t n;
1434
1435 n = now(CLOCK_MONOTONIC);
1436 if (n >= timeout)
1437 return -ETIMEDOUT;
1438
1439 left = timeout - n;
1440 } else
1441 left = (uint64_t) -1;
1442
1443 r = bus_poll(bus, true, left);
1444 if (r < 0)
1445 return r;
1446
1447 r = dispatch_wqueue(bus);
1448 if (r < 0)
1449 return r;
1450 }
1451 }
1452
1453 int sd_bus_get_fd(sd_bus *bus) {
1454 if (!bus)
1455 return -EINVAL;
1456 if (bus->input_fd < 0)
1457 return -ENOTCONN;
1458 if (bus->input_fd != bus->output_fd)
1459 return -EPERM;
1460
1461 return bus->input_fd;
1462 }
1463
1464 int sd_bus_get_events(sd_bus *bus) {
1465 int flags = 0;
1466
1467 if (!bus)
1468 return -EINVAL;
1469 if (bus->state == BUS_UNSET)
1470 return -ENOTCONN;
1471 if (bus->input_fd < 0)
1472 return -ENOTCONN;
1473
1474 if (bus->state == BUS_OPENING)
1475 flags |= POLLOUT;
1476 else if (bus->state == BUS_AUTHENTICATING) {
1477
1478 if (bus_socket_auth_needs_write(bus))
1479 flags |= POLLOUT;
1480
1481 flags |= POLLIN;
1482
1483 } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1484 if (bus->rqueue_size <= 0)
1485 flags |= POLLIN;
1486 if (bus->wqueue_size > 0)
1487 flags |= POLLOUT;
1488 }
1489
1490 return flags;
1491 }
1492
1493 int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1494 struct reply_callback *c;
1495
1496 if (!bus)
1497 return -EINVAL;
1498 if (!timeout_usec)
1499 return -EINVAL;
1500 if (bus->state == BUS_UNSET)
1501 return -ENOTCONN;
1502 if (bus->input_fd < 0)
1503 return -ENOTCONN;
1504
1505 if (bus->state == BUS_AUTHENTICATING) {
1506 *timeout_usec = bus->auth_timeout;
1507 return 1;
1508 }
1509
1510 if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1511 *timeout_usec = (uint64_t) -1;
1512 return 0;
1513 }
1514
1515 c = prioq_peek(bus->reply_callbacks_prioq);
1516 if (!c) {
1517 *timeout_usec = (uint64_t) -1;
1518 return 0;
1519 }
1520
1521 *timeout_usec = c->timeout;
1522 return 1;
1523 }
1524
1525 static int process_timeout(sd_bus *bus) {
1526 _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1527 struct reply_callback *c;
1528 usec_t n;
1529 int r;
1530
1531 assert(bus);
1532
1533 c = prioq_peek(bus->reply_callbacks_prioq);
1534 if (!c)
1535 return 0;
1536
1537 n = now(CLOCK_MONOTONIC);
1538 if (c->timeout > n)
1539 return 0;
1540
1541 r = bus_message_new_synthetic_error(
1542 bus,
1543 c->serial,
1544 &SD_BUS_ERROR_MAKE("org.freedesktop.DBus.Error.Timeout", "Timed out"),
1545 &m);
1546 if (r < 0)
1547 return r;
1548
1549 assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1550 hashmap_remove(bus->reply_callbacks, &c->serial);
1551
1552 r = c->callback(bus, m, c->userdata);
1553 free(c);
1554
1555 return r < 0 ? r : 1;
1556 }
1557
1558 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1559 assert(bus);
1560 assert(m);
1561
1562 if (bus->state != BUS_HELLO)
1563 return 0;
1564
1565 /* Let's make sure the first message on the bus is the HELLO
1566 * reply. But note that we don't actually parse the message
1567 * here (we leave that to the usual handling), we just verify
1568 * we don't let any earlier msg through. */
1569
1570 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1571 m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1572 return -EIO;
1573
1574 if (m->reply_serial != bus->hello_serial)
1575 return -EIO;
1576
1577 return 0;
1578 }
1579
1580 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1581 struct reply_callback *c;
1582 int r;
1583
1584 assert(bus);
1585 assert(m);
1586
1587 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1588 m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1589 return 0;
1590
1591 c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1592 if (!c)
1593 return 0;
1594
1595 if (c->timeout != 0)
1596 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1597
1598 r = sd_bus_message_rewind(m, true);
1599 if (r < 0)
1600 return r;
1601
1602 r = c->callback(bus, m, c->userdata);
1603 free(c);
1604
1605 return r;
1606 }
1607
1608 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1609 struct filter_callback *l;
1610 int r;
1611
1612 assert(bus);
1613 assert(m);
1614
1615 do {
1616 bus->filter_callbacks_modified = false;
1617
1618 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1619
1620 if (bus->filter_callbacks_modified)
1621 break;
1622
1623 /* Don't run this more than once per iteration */
1624 if (l->last_iteration == bus->iteration_counter)
1625 continue;
1626
1627 l->last_iteration = bus->iteration_counter;
1628
1629 r = sd_bus_message_rewind(m, true);
1630 if (r < 0)
1631 return r;
1632
1633 r = l->callback(bus, m, l->userdata);
1634 if (r != 0)
1635 return r;
1636
1637 }
1638
1639 } while (bus->filter_callbacks_modified);
1640
1641 return 0;
1642 }
1643
1644 static int process_match(sd_bus *bus, sd_bus_message *m) {
1645 int r;
1646
1647 assert(bus);
1648 assert(m);
1649
1650 do {
1651 bus->match_callbacks_modified = false;
1652
1653 r = bus_match_run(bus, &bus->match_callbacks, m);
1654 if (r != 0)
1655 return r;
1656
1657 } while (bus->match_callbacks_modified);
1658
1659 return 0;
1660 }
1661
1662 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1663 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1664 int r;
1665
1666 assert(bus);
1667 assert(m);
1668
1669 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1670 return 0;
1671
1672 if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
1673 return 0;
1674
1675 if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1676 return 1;
1677
1678 if (streq_ptr(m->member, "Ping"))
1679 r = sd_bus_message_new_method_return(bus, m, &reply);
1680 else if (streq_ptr(m->member, "GetMachineId")) {
1681 sd_id128_t id;
1682 char sid[33];
1683
1684 r = sd_id128_get_machine(&id);
1685 if (r < 0)
1686 return r;
1687
1688 r = sd_bus_message_new_method_return(bus, m, &reply);
1689 if (r < 0)
1690 return r;
1691
1692 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
1693 } else {
1694 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1695
1696 sd_bus_error_set(&error,
1697 "org.freedesktop.DBus.Error.UnknownMethod",
1698 "Unknown method '%s' on interface '%s'.", m->member, m->interface);
1699
1700 r = sd_bus_message_new_method_error(bus, m, &error, &reply);
1701 }
1702
1703 if (r < 0)
1704 return r;
1705
1706 r = sd_bus_send(bus, reply, NULL);
1707 if (r < 0)
1708 return r;
1709
1710 return 1;
1711 }
1712
1713 static int process_object(sd_bus *bus, sd_bus_message *m) {
1714 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1715 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1716 struct object_callback *c;
1717 int r;
1718 bool found = false;
1719 size_t pl;
1720
1721 assert(bus);
1722 assert(m);
1723
1724 if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1725 return 0;
1726
1727 if (hashmap_isempty(bus->object_callbacks))
1728 return 0;
1729
1730 pl = strlen(m->path);
1731
1732 do {
1733 char p[pl+1];
1734
1735 bus->object_callbacks_modified = false;
1736
1737 c = hashmap_get(bus->object_callbacks, m->path);
1738 if (c && c->last_iteration != bus->iteration_counter) {
1739
1740 c->last_iteration = bus->iteration_counter;
1741
1742 r = sd_bus_message_rewind(m, true);
1743 if (r < 0)
1744 return r;
1745
1746 r = c->callback(bus, m, c->userdata);
1747 if (r != 0)
1748 return r;
1749
1750 found = true;
1751 }
1752
1753 /* Look for fallback prefixes */
1754 strcpy(p, m->path);
1755 for (;;) {
1756 char *e;
1757
1758 if (bus->object_callbacks_modified)
1759 break;
1760
1761 e = strrchr(p, '/');
1762 if (e == p || !e)
1763 break;
1764
1765 *e = 0;
1766
1767 c = hashmap_get(bus->object_callbacks, p);
1768 if (c && c->last_iteration != bus->iteration_counter && c->is_fallback) {
1769
1770 c->last_iteration = bus->iteration_counter;
1771
1772 r = sd_bus_message_rewind(m, true);
1773 if (r < 0)
1774 return r;
1775
1776 r = c->callback(bus, m, c->userdata);
1777 if (r != 0)
1778 return r;
1779
1780 found = true;
1781 }
1782 }
1783
1784 } while (bus->object_callbacks_modified);
1785
1786 /* We found some handlers but none wanted to take this, then
1787 * return this -- with one exception, we can handle
1788 * introspection minimally ourselves */
1789 if (!found || sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect"))
1790 return 0;
1791
1792 sd_bus_error_set(&error,
1793 "org.freedesktop.DBus.Error.UnknownMethod",
1794 "Unknown method '%s' or interface '%s'.", m->member, m->interface);
1795
1796 r = sd_bus_message_new_method_error(bus, m, &error, &reply);
1797 if (r < 0)
1798 return r;
1799
1800 r = sd_bus_send(bus, reply, NULL);
1801 if (r < 0)
1802 return r;
1803
1804 return 1;
1805 }
1806
1807 static int process_introspect(sd_bus *bus, sd_bus_message *m) {
1808 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1809 _cleanup_free_ char *introspection = NULL;
1810 _cleanup_set_free_free_ Set *s = NULL;
1811 _cleanup_fclose_ FILE *f = NULL;
1812 struct object_callback *c;
1813 Iterator i;
1814 size_t size = 0;
1815 char *node;
1816 int r;
1817
1818 assert(bus);
1819 assert(m);
1820
1821 if (!sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect"))
1822 return 0;
1823
1824 if (!m->path)
1825 return 0;
1826
1827 s = set_new(string_hash_func, string_compare_func);
1828 if (!s)
1829 return -ENOMEM;
1830
1831 HASHMAP_FOREACH(c, bus->object_callbacks, i) {
1832 const char *e;
1833 char *a, *p;
1834
1835 if (streq(c->path, "/"))
1836 continue;
1837
1838 if (streq(m->path, "/"))
1839 e = c->path;
1840 else {
1841 e = startswith(c->path, m->path);
1842 if (!e || *e != '/')
1843 continue;
1844 }
1845
1846 a = strdup(e+1);
1847 if (!a)
1848 return -ENOMEM;
1849
1850 p = strchr(a, '/');
1851 if (p)
1852 *p = 0;
1853
1854 r = set_consume(s, a);
1855 if (r < 0 && r != -EEXIST)
1856 return r;
1857 }
1858
1859 f = open_memstream(&introspection, &size);
1860 if (!f)
1861 return -ENOMEM;
1862
1863 fputs(SD_BUS_INTROSPECT_DOCTYPE, f);
1864 fputs("<node>\n", f);
1865 fputs(SD_BUS_INTROSPECT_INTERFACE_PEER, f);
1866 fputs(SD_BUS_INTROSPECT_INTERFACE_INTROSPECTABLE, f);
1867
1868 while ((node = set_steal_first(s))) {
1869 fprintf(f, " <node name=\"%s\"/>\n", node);
1870 free(node);
1871 }
1872
1873 fputs("</node>\n", f);
1874
1875 fflush(f);
1876
1877 if (ferror(f))
1878 return -ENOMEM;
1879
1880 r = sd_bus_message_new_method_return(bus, m, &reply);
1881 if (r < 0)
1882 return r;
1883
1884 r = sd_bus_message_append(reply, "s", introspection);
1885 if (r < 0)
1886 return r;
1887
1888 r = sd_bus_send(bus, reply, NULL);
1889 if (r < 0)
1890 return r;
1891
1892 return 1;
1893 }
1894
1895 static int process_message(sd_bus *bus, sd_bus_message *m) {
1896 int r;
1897
1898 assert(bus);
1899 assert(m);
1900
1901 bus->iteration_counter++;
1902
1903 r = process_hello(bus, m);
1904 if (r != 0)
1905 return r;
1906
1907 r = process_reply(bus, m);
1908 if (r != 0)
1909 return r;
1910
1911 r = process_filter(bus, m);
1912 if (r != 0)
1913 return r;
1914
1915 r = process_match(bus, m);
1916 if (r != 0)
1917 return r;
1918
1919 r = process_builtin(bus, m);
1920 if (r != 0)
1921 return r;
1922
1923 r = process_object(bus, m);
1924 if (r != 0)
1925 return r;
1926
1927 return process_introspect(bus, m);
1928 }
1929
1930 static int process_running(sd_bus *bus, sd_bus_message **ret) {
1931 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1932 int r;
1933
1934 assert(bus);
1935 assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1936
1937 r = process_timeout(bus);
1938 if (r != 0)
1939 goto null_message;
1940
1941 r = dispatch_wqueue(bus);
1942 if (r != 0)
1943 goto null_message;
1944
1945 r = dispatch_rqueue(bus, &m);
1946 if (r < 0)
1947 return r;
1948 if (!m)
1949 goto null_message;
1950
1951 r = process_message(bus, m);
1952 if (r != 0)
1953 goto null_message;
1954
1955 if (ret) {
1956 r = sd_bus_message_rewind(m, true);
1957 if (r < 0)
1958 return r;
1959
1960 *ret = m;
1961 m = NULL;
1962 return 1;
1963 }
1964
1965 if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL) {
1966 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1967 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1968
1969 sd_bus_error_set(&error, "org.freedesktop.DBus.Error.UnknownObject", "Unknown object '%s'.", m->path);
1970
1971 r = sd_bus_message_new_method_error(bus, m, &error, &reply);
1972 if (r < 0)
1973 return r;
1974
1975 r = sd_bus_send(bus, reply, NULL);
1976 if (r < 0)
1977 return r;
1978 }
1979
1980 return 1;
1981
1982 null_message:
1983 if (r >= 0 && ret)
1984 *ret = NULL;
1985
1986 return r;
1987 }
1988
1989 int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
1990 int r;
1991
1992 /* Returns 0 when we didn't do anything. This should cause the
1993 * caller to invoke sd_bus_wait() before returning the next
1994 * time. Returns > 0 when we did something, which possibly
1995 * means *ret is filled in with an unprocessed message. */
1996
1997 if (!bus)
1998 return -EINVAL;
1999 if (bus->input_fd < 0)
2000 return -ENOTCONN;
2001
2002 /* We don't allow recursively invoking sd_bus_process(). */
2003 if (bus->processing)
2004 return -EBUSY;
2005
2006 switch (bus->state) {
2007
2008 case BUS_UNSET:
2009 return -ENOTCONN;
2010
2011 case BUS_OPENING:
2012 r = bus_socket_process_opening(bus);
2013 if (r < 0)
2014 return r;
2015 if (ret)
2016 *ret = NULL;
2017 return r;
2018
2019 case BUS_AUTHENTICATING:
2020
2021 r = bus_socket_process_authenticating(bus);
2022 if (r < 0)
2023 return r;
2024 if (ret)
2025 *ret = NULL;
2026 return r;
2027
2028 case BUS_RUNNING:
2029 case BUS_HELLO:
2030
2031 bus->processing = true;
2032 r = process_running(bus, ret);
2033 bus->processing = false;
2034
2035 return r;
2036 }
2037
2038 assert_not_reached("Unknown state");
2039 }
2040
2041 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2042 struct pollfd p[2] = {};
2043 int r, e, n;
2044 struct timespec ts;
2045 usec_t until, m;
2046
2047 assert(bus);
2048
2049 if (bus->input_fd < 0)
2050 return -ENOTCONN;
2051
2052 e = sd_bus_get_events(bus);
2053 if (e < 0)
2054 return e;
2055
2056 if (need_more)
2057 e |= POLLIN;
2058
2059 r = sd_bus_get_timeout(bus, &until);
2060 if (r < 0)
2061 return r;
2062 if (r == 0)
2063 m = (uint64_t) -1;
2064 else {
2065 usec_t nw;
2066 nw = now(CLOCK_MONOTONIC);
2067 m = until > nw ? until - nw : 0;
2068 }
2069
2070 if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2071 m = timeout_usec;
2072
2073 p[0].fd = bus->input_fd;
2074 if (bus->output_fd == bus->input_fd) {
2075 p[0].events = e;
2076 n = 1;
2077 } else {
2078 p[0].events = e & POLLIN;
2079 p[1].fd = bus->output_fd;
2080 p[1].events = e & POLLOUT;
2081 n = 2;
2082 }
2083
2084 r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2085 if (r < 0)
2086 return -errno;
2087
2088 return r > 0 ? 1 : 0;
2089 }
2090
2091 int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2092
2093 if (!bus)
2094 return -EINVAL;
2095 if (bus->state == BUS_UNSET)
2096 return -ENOTCONN;
2097 if (bus->input_fd < 0)
2098 return -ENOTCONN;
2099 if (bus->rqueue_size > 0)
2100 return 0;
2101
2102 return bus_poll(bus, false, timeout_usec);
2103 }
2104
2105 int sd_bus_flush(sd_bus *bus) {
2106 int r;
2107
2108 if (!bus)
2109 return -EINVAL;
2110 if (bus->state == BUS_UNSET)
2111 return -ENOTCONN;
2112 if (bus->output_fd < 0)
2113 return -ENOTCONN;
2114
2115 r = bus_ensure_running(bus);
2116 if (r < 0)
2117 return r;
2118
2119 if (bus->wqueue_size <= 0)
2120 return 0;
2121
2122 for (;;) {
2123 r = dispatch_wqueue(bus);
2124 if (r < 0)
2125 return r;
2126
2127 if (bus->wqueue_size <= 0)
2128 return 0;
2129
2130 r = bus_poll(bus, false, (uint64_t) -1);
2131 if (r < 0)
2132 return r;
2133 }
2134 }
2135
2136 int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
2137 struct filter_callback *f;
2138
2139 if (!bus)
2140 return -EINVAL;
2141 if (!callback)
2142 return -EINVAL;
2143
2144 f = new0(struct filter_callback, 1);
2145 if (!f)
2146 return -ENOMEM;
2147 f->callback = callback;
2148 f->userdata = userdata;
2149
2150 bus->filter_callbacks_modified = true;
2151 LIST_PREPEND(struct filter_callback, callbacks, bus->filter_callbacks, f);
2152 return 0;
2153 }
2154
2155 int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
2156 struct filter_callback *f;
2157
2158 if (!bus)
2159 return -EINVAL;
2160 if (!callback)
2161 return -EINVAL;
2162
2163 LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2164 if (f->callback == callback && f->userdata == userdata) {
2165 bus->filter_callbacks_modified = true;
2166 LIST_REMOVE(struct filter_callback, callbacks, bus->filter_callbacks, f);
2167 free(f);
2168 return 1;
2169 }
2170 }
2171
2172 return 0;
2173 }
2174
2175 static int bus_add_object(
2176 sd_bus *bus,
2177 bool fallback,
2178 const char *path,
2179 sd_bus_message_handler_t callback,
2180 void *userdata) {
2181
2182 struct object_callback *c;
2183 int r;
2184
2185 if (!bus)
2186 return -EINVAL;
2187 if (!path)
2188 return -EINVAL;
2189 if (!callback)
2190 return -EINVAL;
2191
2192 r = hashmap_ensure_allocated(&bus->object_callbacks, string_hash_func, string_compare_func);
2193 if (r < 0)
2194 return r;
2195
2196 c = new0(struct object_callback, 1);
2197 if (!c)
2198 return -ENOMEM;
2199
2200 c->path = strdup(path);
2201 if (!c->path) {
2202 free(c);
2203 return -ENOMEM;
2204 }
2205
2206 c->callback = callback;
2207 c->userdata = userdata;
2208 c->is_fallback = fallback;
2209
2210 bus->object_callbacks_modified = true;
2211 r = hashmap_put(bus->object_callbacks, c->path, c);
2212 if (r < 0) {
2213 free(c->path);
2214 free(c);
2215 return r;
2216 }
2217
2218 return 0;
2219 }
2220
2221 static int bus_remove_object(
2222 sd_bus *bus,
2223 bool fallback,
2224 const char *path,
2225 sd_bus_message_handler_t callback,
2226 void *userdata) {
2227
2228 struct object_callback *c;
2229
2230 if (!bus)
2231 return -EINVAL;
2232 if (!path)
2233 return -EINVAL;
2234 if (!callback)
2235 return -EINVAL;
2236
2237 c = hashmap_get(bus->object_callbacks, path);
2238 if (!c)
2239 return 0;
2240
2241 if (c->callback != callback || c->userdata != userdata || c->is_fallback != fallback)
2242 return 0;
2243
2244 bus->object_callbacks_modified = true;
2245 assert_se(c == hashmap_remove(bus->object_callbacks, c->path));
2246
2247 free(c->path);
2248 free(c);
2249
2250 return 1;
2251 }
2252
2253 int sd_bus_add_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
2254 return bus_add_object(bus, false, path, callback, userdata);
2255 }
2256
2257 int sd_bus_remove_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
2258 return bus_remove_object(bus, false, path, callback, userdata);
2259 }
2260
2261 int sd_bus_add_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
2262 return bus_add_object(bus, true, prefix, callback, userdata);
2263 }
2264
2265 int sd_bus_remove_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
2266 return bus_remove_object(bus, true, prefix, callback, userdata);
2267 }
2268
2269 int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
2270 int r = 0;
2271
2272 if (!bus)
2273 return -EINVAL;
2274 if (!match)
2275 return -EINVAL;
2276
2277 if (bus->bus_client) {
2278 r = bus_add_match_internal(bus, match);
2279 if (r < 0)
2280 return r;
2281 }
2282
2283 if (callback) {
2284 bus->match_callbacks_modified = true;
2285 r = bus_match_add(&bus->match_callbacks, match, callback, userdata, NULL);
2286 if (r < 0) {
2287
2288 if (bus->bus_client)
2289 bus_remove_match_internal(bus, match);
2290 }
2291 }
2292
2293 return r;
2294 }
2295
2296 int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
2297 int r = 0, q = 0;
2298
2299 if (!bus)
2300 return -EINVAL;
2301 if (!match)
2302 return -EINVAL;
2303
2304 if (bus->bus_client)
2305 r = bus_remove_match_internal(bus, match);
2306
2307 if (callback) {
2308 bus->match_callbacks_modified = true;
2309 q = bus_match_remove(&bus->match_callbacks, match, callback, userdata);
2310 }
2311
2312 if (r < 0)
2313 return r;
2314 return q;
2315 }
2316
2317 int sd_bus_emit_signal(
2318 sd_bus *bus,
2319 const char *path,
2320 const char *interface,
2321 const char *member,
2322 const char *types, ...) {
2323
2324 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2325 va_list ap;
2326 int r;
2327
2328 if (!bus)
2329 return -EINVAL;
2330
2331 r = sd_bus_message_new_signal(bus, path, interface, member, &m);
2332 if (r < 0)
2333 return r;
2334
2335 va_start(ap, types);
2336 r = bus_message_append_ap(m, types, ap);
2337 va_end(ap);
2338 if (r < 0)
2339 return r;
2340
2341 return sd_bus_send(bus, m, NULL);
2342 }
2343
2344 int sd_bus_call_method(
2345 sd_bus *bus,
2346 const char *destination,
2347 const char *path,
2348 const char *interface,
2349 const char *member,
2350 sd_bus_error *error,
2351 sd_bus_message **reply,
2352 const char *types, ...) {
2353
2354 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2355 va_list ap;
2356 int r;
2357
2358 if (!bus)
2359 return -EINVAL;
2360
2361 r = sd_bus_message_new_method_call(bus, destination, path, interface, member, &m);
2362 if (r < 0)
2363 return r;
2364
2365 va_start(ap, types);
2366 r = bus_message_append_ap(m, types, ap);
2367 va_end(ap);
2368 if (r < 0)
2369 return r;
2370
2371 return sd_bus_send_with_reply_and_block(bus, m, 0, error, reply);
2372 }
2373
2374 int sd_bus_reply_method_return(
2375 sd_bus *bus,
2376 sd_bus_message *call,
2377 const char *types, ...) {
2378
2379 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2380 va_list ap;
2381 int r;
2382
2383 if (!bus)
2384 return -EINVAL;
2385 if (!call)
2386 return -EINVAL;
2387 if (!call->sealed)
2388 return -EPERM;
2389 if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
2390 return -EINVAL;
2391
2392 if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
2393 return 0;
2394
2395 r = sd_bus_message_new_method_return(bus, call, &m);
2396 if (r < 0)
2397 return r;
2398
2399 va_start(ap, types);
2400 r = bus_message_append_ap(m, types, ap);
2401 va_end(ap);
2402 if (r < 0)
2403 return r;
2404
2405 return sd_bus_send(bus, m, NULL);
2406 }
2407
2408 int sd_bus_reply_method_error(
2409 sd_bus *bus,
2410 sd_bus_message *call,
2411 const sd_bus_error *e) {
2412
2413 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2414 int r;
2415
2416 if (!bus)
2417 return -EINVAL;
2418 if (!call)
2419 return -EINVAL;
2420 if (!call->sealed)
2421 return -EPERM;
2422 if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
2423 return -EINVAL;
2424 if (!sd_bus_error_is_set(e))
2425 return -EINVAL;
2426
2427 if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
2428 return 0;
2429
2430 r = sd_bus_message_new_method_error(bus, call, e, &m);
2431 if (r < 0)
2432 return r;
2433
2434 return sd_bus_send(bus, m, NULL);
2435 }
Unnamed repository; edit this file 'description' to name the repository.