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

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