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