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