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