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