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