src/libelogind/sd-bus/sd-bus.c

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