src/libsystemd/sd-bus/sd-bus.c

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