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