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