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