src/libelogind/sd-bus/sd-bus.c

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