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