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