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