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