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