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

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