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 = s;
1354         s = NULL;
1355
1356         return 0;
1357 }
1358 #endif // 0
1359
1360 _public_ int sd_bus_open_user(sd_bus **ret) {
1361 #if 0 /// elogind does not support user buses
1362         sd_bus *b;
1363         int r;
1364
1365         assert_return(ret, -EINVAL);
1366
1367         r = sd_bus_new(&b);
1368         if (r < 0)
1369                 return r;
1370
1371         r = bus_set_address_user(b);
1372         if (r < 0)
1373                 goto fail;
1374
1375         b->bus_client = true;
1376         b->is_user = true;
1377
1378         /* We don't do any per-method access control on the user
1379          * bus. */
1380         b->trusted = true;
1381         b->is_local = true;
1382
1383         r = sd_bus_start(b);
1384         if (r < 0)
1385                 goto fail;
1386
1387         *ret = b;
1388         return 0;
1389
1390 fail:
1391         bus_free(b);
1392         return r;
1393 #else
1394         return sd_bus_open_system(ret);
1395 #endif // 0
1396 }
1397
1398 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1399         _cleanup_free_ char *e = NULL;
1400         char *m = NULL, *c = NULL, *a;
1401
1402         assert(b);
1403         assert(host);
1404
1405         /* Let's see if we shall enter some container */
1406         m = strchr(host, ':');
1407         if (m) {
1408                 m++;
1409
1410                 /* Let's make sure this is not a port of some kind,
1411                  * and is a valid machine name. */
1412                 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1413                         char *t;
1414
1415                         /* Cut out the host part */
1416                         t = strndupa(host, m - host - 1);
1417                         e = bus_address_escape(t);
1418                         if (!e)
1419                                 return -ENOMEM;
1420
1421                         c = strjoina(",argv5=--machine=", m);
1422                 }
1423         }
1424
1425         if (!e) {
1426                 e = bus_address_escape(host);
1427                 if (!e)
1428                         return -ENOMEM;
1429         }
1430
1431         a = strjoin("unixexec:path=ssh,argv1=-xT,argv2=--,argv3=", e, ",argv4=elogind-stdio-bridge", c);
1432         if (!a)
1433                 return -ENOMEM;
1434
1435         free_and_replace(b->address, a);
1436
1437         return 0;
1438  }
1439
1440 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1441         sd_bus *bus;
1442         int r;
1443
1444         assert_return(host, -EINVAL);
1445         assert_return(ret, -EINVAL);
1446
1447         r = sd_bus_new(&bus);
1448         if (r < 0)
1449                 return r;
1450
1451         r = bus_set_address_system_remote(bus, host);
1452         if (r < 0)
1453                 goto fail;
1454
1455         bus->bus_client = true;
1456         bus->trusted = false;
1457         bus->is_system = true;
1458         bus->is_local = false;
1459
1460         r = sd_bus_start(bus);
1461         if (r < 0)
1462                 goto fail;
1463
1464         *ret = bus;
1465         return 0;
1466
1467 fail:
1468         bus_free(bus);
1469         return r;
1470 }
1471
1472 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1473         _cleanup_free_ char *e = NULL;
1474         char *a;
1475
1476         assert(b);
1477         assert(machine);
1478
1479         e = bus_address_escape(machine);
1480         if (!e)
1481                 return -ENOMEM;
1482
1483         a = strjoin("x-machine-unix:machine=", e);
1484         if (!a)
1485                 return -ENOMEM;
1486
1487         free_and_replace(b->address, a);
1488
1489         return 0;
1490 }
1491
1492 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1493         sd_bus *bus;
1494         int r;
1495
1496         assert_return(machine, -EINVAL);
1497         assert_return(ret, -EINVAL);
1498         assert_return(machine_name_is_valid(machine), -EINVAL);
1499
1500         r = sd_bus_new(&bus);
1501         if (r < 0)
1502                 return r;
1503
1504         r = bus_set_address_system_machine(bus, machine);
1505         if (r < 0)
1506                 goto fail;
1507
1508         bus->bus_client = true;
1509         bus->trusted = false;
1510         bus->is_system = true;
1511         bus->is_local = false;
1512
1513         r = sd_bus_start(bus);
1514         if (r < 0)
1515                 goto fail;
1516
1517         *ret = bus;
1518         return 0;
1519
1520 fail:
1521         bus_free(bus);
1522         return r;
1523 }
1524
1525 _public_ void sd_bus_close(sd_bus *bus) {
1526
1527         if (!bus)
1528                 return;
1529         if (bus->state == BUS_CLOSED)
1530                 return;
1531         if (bus_pid_changed(bus))
1532                 return;
1533
1534         /* Don't leave ssh hanging around */
1535         bus_kill_exec(bus);
1536
1537         bus_set_state(bus, BUS_CLOSED);
1538
1539         sd_bus_detach_event(bus);
1540
1541         /* Drop all queued messages so that they drop references to
1542          * the bus object and the bus may be freed */
1543         bus_reset_queues(bus);
1544
1545         bus_close_io_fds(bus);
1546         bus_close_inotify_fd(bus);
1547 }
1548
1549 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1550
1551         if (!bus)
1552                 return NULL;
1553
1554         /* Have to do this before flush() to prevent hang */
1555         bus_kill_exec(bus);
1556
1557         sd_bus_flush(bus);
1558         sd_bus_close(bus);
1559
1560         return sd_bus_unref(bus);
1561 }
1562
1563 void bus_enter_closing(sd_bus *bus) {
1564         assert(bus);
1565
1566         if (!IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING))
1567                 return;
1568
1569         bus_set_state(bus, BUS_CLOSING);
1570 }
1571
1572 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1573
1574         if (!bus)
1575                 return NULL;
1576
1577         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1578
1579         return bus;
1580 }
1581
1582 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1583         unsigned i;
1584
1585         if (!bus)
1586                 return NULL;
1587
1588         i = REFCNT_DEC(bus->n_ref);
1589         if (i > 0)
1590                 return NULL;
1591
1592         bus_free(bus);
1593         return NULL;
1594 }
1595
1596 _public_ int sd_bus_is_open(sd_bus *bus) {
1597
1598         assert_return(bus, -EINVAL);
1599         assert_return(bus = bus_resolve(bus), -ENOPKG);
1600         assert_return(!bus_pid_changed(bus), -ECHILD);
1601
1602         return BUS_IS_OPEN(bus->state);
1603 }
1604
1605 _public_ int sd_bus_is_ready(sd_bus *bus) {
1606         assert_return(bus, -EINVAL);
1607         assert_return(bus = bus_resolve(bus), -ENOPKG);
1608         assert_return(!bus_pid_changed(bus), -ECHILD);
1609
1610         return bus->state == BUS_RUNNING;
1611 }
1612
1613 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1614         int r;
1615
1616         assert_return(bus, -EINVAL);
1617         assert_return(bus = bus_resolve(bus), -ENOPKG);
1618         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1619         assert_return(!bus_pid_changed(bus), -ECHILD);
1620
1621         if (bus->is_monitor)
1622                 return 0;
1623
1624         if (type == SD_BUS_TYPE_UNIX_FD) {
1625                 if (!bus->accept_fd)
1626                         return 0;
1627
1628                 r = bus_ensure_running(bus);
1629                 if (r < 0)
1630                         return r;
1631
1632                 return bus->can_fds;
1633         }
1634
1635         return bus_type_is_valid(type);
1636 }
1637
1638 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1639         int r;
1640
1641         assert_return(bus, -EINVAL);
1642         assert_return(bus = bus_resolve(bus), -ENOPKG);
1643         assert_return(id, -EINVAL);
1644         assert_return(!bus_pid_changed(bus), -ECHILD);
1645
1646         r = bus_ensure_running(bus);
1647         if (r < 0)
1648                 return r;
1649
1650         *id = bus->server_id;
1651         return 0;
1652 }
1653
1654 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1655         int r;
1656
1657         assert(b);
1658         assert(m);
1659
1660         if (m->sealed) {
1661                 /* If we copy the same message to multiple
1662                  * destinations, avoid using the same cookie
1663                  * numbers. */
1664                 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1665                 return 0;
1666         }
1667
1668         if (timeout == 0)
1669                 timeout = BUS_DEFAULT_TIMEOUT;
1670
1671         if (!m->sender && b->patch_sender) {
1672                 r = sd_bus_message_set_sender(m, b->patch_sender);
1673                 if (r < 0)
1674                         return r;
1675         }
1676
1677         return sd_bus_message_seal(m, ++b->cookie, timeout);
1678 }
1679
1680 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1681         bool remarshal = false;
1682
1683         assert(b);
1684
1685         /* wrong packet version */
1686         if (b->message_version != 0 && b->message_version != (*m)->header->version)
1687                 remarshal = true;
1688
1689         /* wrong packet endianness */
1690         if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1691                 remarshal = true;
1692
1693         return remarshal ? bus_message_remarshal(b, m) : 0;
1694 }
1695
1696 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1697         assert(b);
1698         assert(m);
1699
1700         /* Fake some timestamps, if they were requested, and not
1701          * already initialized */
1702         if (b->attach_timestamp) {
1703                 if (m->realtime <= 0)
1704                         m->realtime = now(CLOCK_REALTIME);
1705
1706                 if (m->monotonic <= 0)
1707                         m->monotonic = now(CLOCK_MONOTONIC);
1708         }
1709
1710         /* The bus specification says the serial number cannot be 0,
1711          * hence let's fill something in for synthetic messages. Since
1712          * synthetic messages might have a fake sender and we don't
1713          * want to interfere with the real sender's serial numbers we
1714          * pick a fixed, artificial one. We use (uint32_t) -1 rather
1715          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1716          * even though kdbus can do 64bit. */
1717         return sd_bus_message_seal(m, 0xFFFFFFFFULL, 0);
1718 }
1719
1720 static int bus_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
1721         int r;
1722
1723         assert(bus);
1724         assert(m);
1725
1726         r = bus_socket_write_message(bus, m, idx);
1727         if (r <= 0)
1728                 return r;
1729
1730         if (*idx >= BUS_MESSAGE_SIZE(m))
1731                 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",
1732                           bus_message_type_to_string(m->header->type),
1733                           strna(sd_bus_message_get_sender(m)),
1734                           strna(sd_bus_message_get_destination(m)),
1735                           strna(sd_bus_message_get_path(m)),
1736                           strna(sd_bus_message_get_interface(m)),
1737                           strna(sd_bus_message_get_member(m)),
1738                           BUS_MESSAGE_COOKIE(m),
1739                           m->reply_cookie,
1740                           strna(m->root_container.signature),
1741                           strna(m->error.name),
1742                           strna(m->error.message));
1743
1744         return r;
1745 }
1746
1747 static int dispatch_wqueue(sd_bus *bus) {
1748         int r, ret = 0;
1749
1750         assert(bus);
1751         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1752
1753         while (bus->wqueue_size > 0) {
1754
1755                 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1756                 if (r < 0)
1757                         return r;
1758                 else if (r == 0)
1759                         /* Didn't do anything this time */
1760                         return ret;
1761                 else if (bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1762                         /* Fully written. Let's drop the entry from
1763                          * the queue.
1764                          *
1765                          * This isn't particularly optimized, but
1766                          * well, this is supposed to be our worst-case
1767                          * buffer only, and the socket buffer is
1768                          * supposed to be our primary buffer, and if
1769                          * it got full, then all bets are off
1770                          * anyway. */
1771
1772                         bus->wqueue_size--;
1773                         sd_bus_message_unref(bus->wqueue[0]);
1774                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1775                         bus->windex = 0;
1776
1777                         ret = 1;
1778                 }
1779         }
1780
1781         return ret;
1782 }
1783
1784 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1785         assert(bus);
1786
1787         return bus_socket_read_message(bus);
1788 }
1789
1790 int bus_rqueue_make_room(sd_bus *bus) {
1791         assert(bus);
1792
1793         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1794                 return -ENOBUFS;
1795
1796         if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1797                 return -ENOMEM;
1798
1799         return 0;
1800 }
1801
1802 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1803         int r, ret = 0;
1804
1805         assert(bus);
1806         assert(m);
1807         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1808
1809         /* Note that the priority logic is only available on kdbus,
1810          * where the rqueue is unused. We check the rqueue here
1811          * anyway, because it's simple... */
1812
1813         for (;;) {
1814                 if (bus->rqueue_size > 0) {
1815                         /* Dispatch a queued message */
1816
1817                         *m = bus->rqueue[0];
1818                         bus->rqueue_size--;
1819                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1820                         return 1;
1821                 }
1822
1823                 /* Try to read a new message */
1824                 r = bus_read_message(bus, hint_priority, priority);
1825                 if (r < 0)
1826                         return r;
1827                 if (r == 0)
1828                         return ret;
1829
1830                 ret = 1;
1831         }
1832 }
1833
1834 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie) {
1835         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1836         int r;
1837
1838         assert_return(m, -EINVAL);
1839
1840         if (!bus)
1841                 bus = m->bus;
1842
1843         assert_return(!bus_pid_changed(bus), -ECHILD);
1844
1845         if (!BUS_IS_OPEN(bus->state))
1846                 return -ENOTCONN;
1847
1848         if (m->n_fds > 0) {
1849                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1850                 if (r < 0)
1851                         return r;
1852                 if (r == 0)
1853                         return -EOPNOTSUPP;
1854         }
1855
1856         /* If the cookie number isn't kept, then we know that no reply
1857          * is expected */
1858         if (!cookie && !m->sealed)
1859                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1860
1861         r = bus_seal_message(bus, m, 0);
1862         if (r < 0)
1863                 return r;
1864
1865         /* Remarshall if we have to. This will possibly unref the
1866          * message and place a replacement in m */
1867         r = bus_remarshal_message(bus, &m);
1868         if (r < 0)
1869                 return r;
1870
1871         /* If this is a reply and no reply was requested, then let's
1872          * suppress this, if we can */
1873         if (m->dont_send)
1874                 goto finish;
1875
1876         if (IN_SET(bus->state, BUS_RUNNING, BUS_HELLO) && bus->wqueue_size <= 0) {
1877                 size_t idx = 0;
1878
1879                 r = bus_write_message(bus, m, &idx);
1880                 if (r < 0) {
1881                         if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
1882                                 bus_enter_closing(bus);
1883                                 return -ECONNRESET;
1884                         }
1885
1886                         return r;
1887                 }
1888
1889                 if (idx < BUS_MESSAGE_SIZE(m))  {
1890                         /* Wasn't fully written. So let's remember how
1891                          * much was written. Note that the first entry
1892                          * of the wqueue array is always allocated so
1893                          * that we always can remember how much was
1894                          * written. */
1895                         bus->wqueue[0] = sd_bus_message_ref(m);
1896                         bus->wqueue_size = 1;
1897                         bus->windex = idx;
1898                 }
1899
1900         } else {
1901                 /* Just append it to the queue. */
1902
1903                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1904                         return -ENOBUFS;
1905
1906                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1907                         return -ENOMEM;
1908
1909                 bus->wqueue[bus->wqueue_size++] = sd_bus_message_ref(m);
1910         }
1911
1912 finish:
1913         if (cookie)
1914                 *cookie = BUS_MESSAGE_COOKIE(m);
1915
1916         return 1;
1917 }
1918
1919 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1920         int r;
1921
1922         assert_return(m, -EINVAL);
1923
1924         if (!bus)
1925                 bus = m->bus;
1926
1927         assert_return(!bus_pid_changed(bus), -ECHILD);
1928
1929         if (!BUS_IS_OPEN(bus->state))
1930                 return -ENOTCONN;
1931
1932         if (!streq_ptr(m->destination, destination)) {
1933
1934                 if (!destination)
1935                         return -EEXIST;
1936
1937                 r = sd_bus_message_set_destination(m, destination);
1938                 if (r < 0)
1939                         return r;
1940         }
1941
1942         return sd_bus_send(bus, m, cookie);
1943 }
1944
1945 static usec_t calc_elapse(sd_bus *bus, uint64_t usec) {
1946         assert(bus);
1947
1948         if (usec == (uint64_t) -1)
1949                 return 0;
1950
1951         /* We start all timeouts the instant we enter BUS_HELLO/BUS_RUNNING state, so that the don't run in parallel
1952          * with any connection setup states. Hence, if a method callback is started earlier than that we just store the
1953          * relative timestamp, and afterwards the absolute one. */
1954
1955         if (IN_SET(bus->state, BUS_WATCH_BIND, BUS_OPENING, BUS_AUTHENTICATING))
1956                 return usec;
1957         else
1958                 return now(CLOCK_MONOTONIC) + usec;
1959 }
1960
1961 static int timeout_compare(const void *a, const void *b) {
1962         const struct reply_callback *x = a, *y = b;
1963
1964         if (x->timeout_usec != 0 && y->timeout_usec == 0)
1965                 return -1;
1966
1967         if (x->timeout_usec == 0 && y->timeout_usec != 0)
1968                 return 1;
1969
1970         if (x->timeout_usec < y->timeout_usec)
1971                 return -1;
1972
1973         if (x->timeout_usec > y->timeout_usec)
1974                 return 1;
1975
1976         return 0;
1977 }
1978
1979 _public_ int sd_bus_call_async(
1980                 sd_bus *bus,
1981                 sd_bus_slot **slot,
1982                 sd_bus_message *_m,
1983                 sd_bus_message_handler_t callback,
1984                 void *userdata,
1985                 uint64_t usec) {
1986
1987         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
1988         _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *s = NULL;
1989         int r;
1990
1991         assert_return(m, -EINVAL);
1992         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1993         assert_return(!m->sealed || (!!callback == !(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)), -EINVAL);
1994
1995         if (!bus)
1996                 bus = m->bus;
1997
1998         assert_return(!bus_pid_changed(bus), -ECHILD);
1999
2000         if (!BUS_IS_OPEN(bus->state))
2001                 return -ENOTCONN;
2002
2003         /* If no callback is specified and there's no interest in a slot, then there's no reason to ask for a reply */
2004         if (!callback && !slot && !m->sealed)
2005                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
2006
2007         r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
2008         if (r < 0)
2009                 return r;
2010
2011         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
2012         if (r < 0)
2013                 return r;
2014
2015         r = bus_seal_message(bus, m, usec);
2016         if (r < 0)
2017                 return r;
2018
2019         r = bus_remarshal_message(bus, &m);
2020         if (r < 0)
2021                 return r;
2022
2023         if (slot || callback) {
2024                 s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
2025                 if (!s)
2026                         return -ENOMEM;
2027
2028                 s->reply_callback.callback = callback;
2029
2030                 s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
2031                 r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
2032                 if (r < 0) {
2033                         s->reply_callback.cookie = 0;
2034                         return r;
2035                 }
2036
2037                 s->reply_callback.timeout_usec = calc_elapse(bus, m->timeout);
2038                 if (s->reply_callback.timeout_usec != 0) {
2039                         r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
2040                         if (r < 0) {
2041                                 s->reply_callback.timeout_usec = 0;
2042                                 return r;
2043                         }
2044                 }
2045         }
2046
2047         r = sd_bus_send(bus, m, s ? &s->reply_callback.cookie : NULL);
2048         if (r < 0)
2049                 return r;
2050
2051         if (slot)
2052                 *slot = s;
2053         s = NULL;
2054
2055         return r;
2056 }
2057
2058 int bus_ensure_running(sd_bus *bus) {
2059         int r;
2060
2061         assert(bus);
2062
2063         if (IN_SET(bus->state, BUS_UNSET, BUS_CLOSED, BUS_CLOSING))
2064                 return -ENOTCONN;
2065         if (bus->state == BUS_RUNNING)
2066                 return 1;
2067
2068         for (;;) {
2069                 r = sd_bus_process(bus, NULL);
2070                 if (r < 0)
2071                         return r;
2072                 if (bus->state == BUS_RUNNING)
2073                         return 1;
2074                 if (r > 0)
2075                         continue;
2076
2077                 r = sd_bus_wait(bus, (uint64_t) -1);
2078                 if (r < 0)
2079                         return r;
2080         }
2081 }
2082
2083 _public_ int sd_bus_call(
2084                 sd_bus *bus,
2085                 sd_bus_message *_m,
2086                 uint64_t usec,
2087                 sd_bus_error *error,
2088                 sd_bus_message **reply) {
2089
2090         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = sd_bus_message_ref(_m);
2091         usec_t timeout;
2092         uint64_t cookie;
2093         unsigned i;
2094         int r;
2095
2096         bus_assert_return(m, -EINVAL, error);
2097         bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2098         bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2099         bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2100
2101         if (!bus)
2102                 bus = m->bus;
2103
2104         bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2105
2106         if (!BUS_IS_OPEN(bus->state)) {
2107                 r = -ENOTCONN;
2108                 goto fail;
2109         }
2110
2111         r = bus_ensure_running(bus);
2112         if (r < 0)
2113                 goto fail;
2114
2115         i = bus->rqueue_size;
2116
2117         r = bus_seal_message(bus, m, usec);
2118         if (r < 0)
2119                 goto fail;
2120
2121         r = bus_remarshal_message(bus, &m);
2122         if (r < 0)
2123                 goto fail;
2124
2125         r = sd_bus_send(bus, m, &cookie);
2126         if (r < 0)
2127                 goto fail;
2128
2129         timeout = calc_elapse(bus, m->timeout);
2130
2131         for (;;) {
2132                 usec_t left;
2133
2134                 while (i < bus->rqueue_size) {
2135                         sd_bus_message *incoming = NULL;
2136
2137                         incoming = bus->rqueue[i];
2138
2139                         if (incoming->reply_cookie == cookie) {
2140                                 /* Found a match! */
2141
2142                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2143                                 bus->rqueue_size--;
2144                                 log_debug_bus_message(incoming);
2145
2146                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2147
2148                                         if (incoming->n_fds <= 0 || bus->accept_fd) {
2149                                                 if (reply)
2150                                                         *reply = incoming;
2151                                                 else
2152                                                         sd_bus_message_unref(incoming);
2153
2154                                                 return 1;
2155                                         }
2156
2157                                         r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2158                                         sd_bus_message_unref(incoming);
2159                                         return r;
2160
2161                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2162                                         r = sd_bus_error_copy(error, &incoming->error);
2163                                         sd_bus_message_unref(incoming);
2164                                         return r;
2165                                 } else {
2166                                         r = -EIO;
2167                                         goto fail;
2168                                 }
2169
2170                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2171                                    bus->unique_name &&
2172                                    incoming->sender &&
2173                                    streq(bus->unique_name, incoming->sender)) {
2174
2175                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2176                                 bus->rqueue_size--;
2177
2178                                 /* Our own message? Somebody is trying
2179                                  * to send its own client a message,
2180                                  * let's not dead-lock, let's fail
2181                                  * immediately. */
2182
2183                                 sd_bus_message_unref(incoming);
2184                                 r = -ELOOP;
2185                                 goto fail;
2186                         }
2187
2188                         /* Try to read more, right-away */
2189                         i++;
2190                 }
2191
2192                 r = bus_read_message(bus, false, 0);
2193                 if (r < 0) {
2194                         if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2195                                 bus_enter_closing(bus);
2196                                 r = -ECONNRESET;
2197                         }
2198
2199                         goto fail;
2200                 }
2201                 if (r > 0)
2202                         continue;
2203
2204                 if (timeout > 0) {
2205                         usec_t n;
2206
2207                         n = now(CLOCK_MONOTONIC);
2208                         if (n >= timeout) {
2209                                 r = -ETIMEDOUT;
2210                                 goto fail;
2211                         }
2212
2213                         left = timeout - n;
2214                 } else
2215                         left = (uint64_t) -1;
2216
2217                 r = bus_poll(bus, true, left);
2218                 if (r < 0)
2219                         goto fail;
2220                 if (r == 0) {
2221                         r = -ETIMEDOUT;
2222                         goto fail;
2223                 }
2224
2225                 r = dispatch_wqueue(bus);
2226                 if (r < 0) {
2227                         if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2228                                 bus_enter_closing(bus);
2229                                 r = -ECONNRESET;
2230                         }
2231
2232                         goto fail;
2233                 }
2234         }
2235
2236 fail:
2237         return sd_bus_error_set_errno(error, r);
2238 }
2239
2240 _public_ int sd_bus_get_fd(sd_bus *bus) {
2241
2242         assert_return(bus, -EINVAL);
2243         assert_return(bus = bus_resolve(bus), -ENOPKG);
2244         assert_return(bus->input_fd == bus->output_fd, -EPERM);
2245         assert_return(!bus_pid_changed(bus), -ECHILD);
2246
2247         if (bus->state == BUS_CLOSED)
2248                 return -ENOTCONN;
2249
2250         if (bus->inotify_fd >= 0)
2251                 return bus->inotify_fd;
2252
2253         if (bus->input_fd >= 0)
2254                 return bus->input_fd;
2255
2256         return -ENOTCONN;
2257 }
2258
2259 _public_ int sd_bus_get_events(sd_bus *bus) {
2260         int flags = 0;
2261
2262         assert_return(bus, -EINVAL);
2263         assert_return(bus = bus_resolve(bus), -ENOPKG);
2264         assert_return(!bus_pid_changed(bus), -ECHILD);
2265
2266         switch (bus->state) {
2267
2268         case BUS_UNSET:
2269         case BUS_CLOSED:
2270                 return -ENOTCONN;
2271
2272         case BUS_WATCH_BIND:
2273                 flags |= POLLIN;
2274                 break;
2275
2276         case BUS_OPENING:
2277                 flags |= POLLOUT;
2278                 break;
2279
2280         case BUS_AUTHENTICATING:
2281                 if (bus_socket_auth_needs_write(bus))
2282                         flags |= POLLOUT;
2283
2284                 flags |= POLLIN;
2285                 break;
2286
2287         case BUS_RUNNING:
2288         case BUS_HELLO:
2289                 if (bus->rqueue_size <= 0)
2290                         flags |= POLLIN;
2291                 if (bus->wqueue_size > 0)
2292                         flags |= POLLOUT;
2293                 break;
2294
2295         case BUS_CLOSING:
2296                 break;
2297
2298         default:
2299                 assert_not_reached("Unknown state");
2300         }
2301
2302         return flags;
2303 }
2304
2305 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2306         struct reply_callback *c;
2307
2308         assert_return(bus, -EINVAL);
2309         assert_return(bus = bus_resolve(bus), -ENOPKG);
2310         assert_return(timeout_usec, -EINVAL);
2311         assert_return(!bus_pid_changed(bus), -ECHILD);
2312
2313         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2314                 return -ENOTCONN;
2315
2316         if (bus->track_queue) {
2317                 *timeout_usec = 0;
2318                 return 1;
2319         }
2320
2321         switch (bus->state) {
2322
2323         case BUS_AUTHENTICATING:
2324                 *timeout_usec = bus->auth_timeout;
2325                 return 1;
2326
2327         case BUS_RUNNING:
2328         case BUS_HELLO:
2329                 if (bus->rqueue_size > 0) {
2330                         *timeout_usec = 0;
2331                         return 1;
2332                 }
2333
2334                 c = prioq_peek(bus->reply_callbacks_prioq);
2335                 if (!c) {
2336                         *timeout_usec = (uint64_t) -1;
2337                         return 0;
2338                 }
2339
2340                 if (c->timeout_usec == 0) {
2341                         *timeout_usec = (uint64_t) -1;
2342                         return 0;
2343                 }
2344
2345                 *timeout_usec = c->timeout_usec;
2346                 return 1;
2347
2348         case BUS_CLOSING:
2349                 *timeout_usec = 0;
2350                 return 1;
2351
2352         case BUS_WATCH_BIND:
2353         case BUS_OPENING:
2354                 *timeout_usec = (uint64_t) -1;
2355                 return 0;
2356
2357         default:
2358                 assert_not_reached("Unknown or unexpected stat");
2359         }
2360 }
2361
2362 static int process_timeout(sd_bus *bus) {
2363         _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2364         _cleanup_(sd_bus_message_unrefp) sd_bus_message* m = NULL;
2365         struct reply_callback *c;
2366         sd_bus_slot *slot;
2367         bool is_hello;
2368         usec_t n;
2369         int r;
2370
2371         assert(bus);
2372         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2373
2374         c = prioq_peek(bus->reply_callbacks_prioq);
2375         if (!c)
2376                 return 0;
2377
2378         n = now(CLOCK_MONOTONIC);
2379         if (c->timeout_usec > n)
2380                 return 0;
2381
2382         r = bus_message_new_synthetic_error(
2383                         bus,
2384                         c->cookie,
2385                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2386                         &m);
2387         if (r < 0)
2388                 return r;
2389
2390         r = bus_seal_synthetic_message(bus, m);
2391         if (r < 0)
2392                 return r;
2393
2394         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2395         c->timeout_usec = 0;
2396
2397         ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2398         c->cookie = 0;
2399
2400         slot = container_of(c, sd_bus_slot, reply_callback);
2401
2402         bus->iteration_counter++;
2403
2404         is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2405
2406         bus->current_message = m;
2407         bus->current_slot = sd_bus_slot_ref(slot);
2408         bus->current_handler = c->callback;
2409         bus->current_userdata = slot->userdata;
2410         r = c->callback(m, slot->userdata, &error_buffer);
2411         bus->current_userdata = NULL;
2412         bus->current_handler = NULL;
2413         bus->current_slot = NULL;
2414         bus->current_message = NULL;
2415
2416         if (slot->floating) {
2417                 bus_slot_disconnect(slot);
2418                 sd_bus_slot_unref(slot);
2419         }
2420
2421         sd_bus_slot_unref(slot);
2422
2423         /* When this is the hello message and it timed out, then make sure to propagate the error up, don't just log
2424          * and ignore the callback handler's return value. */
2425         if (is_hello)
2426                 return r;
2427
2428         return bus_maybe_reply_error(m, r, &error_buffer);
2429 }
2430
2431 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2432         assert(bus);
2433         assert(m);
2434
2435         if (bus->state != BUS_HELLO)
2436                 return 0;
2437
2438         /* Let's make sure the first message on the bus is the HELLO
2439          * reply. But note that we don't actually parse the message
2440          * here (we leave that to the usual handling), we just verify
2441          * we don't let any earlier msg through. */
2442
2443         if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2444                 return -EIO;
2445
2446         if (m->reply_cookie != 1)
2447                 return -EIO;
2448
2449         return 0;
2450 }
2451
2452 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2453         _cleanup_(sd_bus_message_unrefp) sd_bus_message *synthetic_reply = NULL;
2454         _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2455         struct reply_callback *c;
2456         sd_bus_slot *slot;
2457         bool is_hello;
2458         int r;
2459
2460         assert(bus);
2461         assert(m);
2462
2463         if (!IN_SET(m->header->type, SD_BUS_MESSAGE_METHOD_RETURN, SD_BUS_MESSAGE_METHOD_ERROR))
2464                 return 0;
2465
2466         if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2467                 return 0;
2468
2469         c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2470         if (!c)
2471                 return 0;
2472
2473         c->cookie = 0;
2474
2475         slot = container_of(c, sd_bus_slot, reply_callback);
2476
2477         if (m->n_fds > 0 && !bus->accept_fd) {
2478
2479                 /* If the reply contained a file descriptor which we
2480                  * didn't want we pass an error instead. */
2481
2482                 r = bus_message_new_synthetic_error(
2483                                 bus,
2484                                 m->reply_cookie,
2485                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2486                                 &synthetic_reply);
2487                 if (r < 0)
2488                         return r;
2489
2490                 /* Copy over original timestamp */
2491                 synthetic_reply->realtime = m->realtime;
2492                 synthetic_reply->monotonic = m->monotonic;
2493                 synthetic_reply->seqnum = m->seqnum;
2494
2495                 r = bus_seal_synthetic_message(bus, synthetic_reply);
2496                 if (r < 0)
2497                         return r;
2498
2499                 m = synthetic_reply;
2500         } else {
2501                 r = sd_bus_message_rewind(m, true);
2502                 if (r < 0)
2503                         return r;
2504         }
2505
2506         if (c->timeout_usec != 0) {
2507                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2508                 c->timeout_usec = 0;
2509         }
2510
2511         is_hello = bus->state == BUS_HELLO && c->callback == hello_callback;
2512
2513         bus->current_slot = sd_bus_slot_ref(slot);
2514         bus->current_handler = c->callback;
2515         bus->current_userdata = slot->userdata;
2516         r = c->callback(m, slot->userdata, &error_buffer);
2517         bus->current_userdata = NULL;
2518         bus->current_handler = NULL;
2519         bus->current_slot = NULL;
2520
2521         if (slot->floating) {
2522                 bus_slot_disconnect(slot);
2523                 sd_bus_slot_unref(slot);
2524         }
2525
2526         sd_bus_slot_unref(slot);
2527
2528         /* When this is the hello message and it failed, then make sure to propagate the error up, don't just log and
2529          * ignore the callback handler's return value. */
2530         if (is_hello)
2531                 return r;
2532
2533         return bus_maybe_reply_error(m, r, &error_buffer);
2534 }
2535
2536 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2537         _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2538         struct filter_callback *l;
2539         int r;
2540
2541         assert(bus);
2542         assert(m);
2543
2544         do {
2545                 bus->filter_callbacks_modified = false;
2546
2547                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2548                         sd_bus_slot *slot;
2549
2550                         if (bus->filter_callbacks_modified)
2551                                 break;
2552
2553                         /* Don't run this more than once per iteration */
2554                         if (l->last_iteration == bus->iteration_counter)
2555                                 continue;
2556
2557                         l->last_iteration = bus->iteration_counter;
2558
2559                         r = sd_bus_message_rewind(m, true);
2560                         if (r < 0)
2561                                 return r;
2562
2563                         slot = container_of(l, sd_bus_slot, filter_callback);
2564
2565                         bus->current_slot = sd_bus_slot_ref(slot);
2566                         bus->current_handler = l->callback;
2567                         bus->current_userdata = slot->userdata;
2568                         r = l->callback(m, slot->userdata, &error_buffer);
2569                         bus->current_userdata = NULL;
2570                         bus->current_handler = NULL;
2571                         bus->current_slot = sd_bus_slot_unref(slot);
2572
2573                         r = bus_maybe_reply_error(m, r, &error_buffer);
2574                         if (r != 0)
2575                                 return r;
2576
2577                 }
2578
2579         } while (bus->filter_callbacks_modified);
2580
2581         return 0;
2582 }
2583
2584 static int process_match(sd_bus *bus, sd_bus_message *m) {
2585         int r;
2586
2587         assert(bus);
2588         assert(m);
2589
2590         do {
2591                 bus->match_callbacks_modified = false;
2592
2593                 r = bus_match_run(bus, &bus->match_callbacks, m);
2594                 if (r != 0)
2595                         return r;
2596
2597         } while (bus->match_callbacks_modified);
2598
2599         return 0;
2600 }
2601
2602 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2603         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2604         int r;
2605
2606         assert(bus);
2607         assert(m);
2608
2609         if (bus->is_monitor)
2610                 return 0;
2611
2612         if (bus->manual_peer_interface)
2613                 return 0;
2614
2615         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2616                 return 0;
2617
2618         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2619                 return 0;
2620
2621         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2622                 return 1;
2623
2624         if (streq_ptr(m->member, "Ping"))
2625                 r = sd_bus_message_new_method_return(m, &reply);
2626         else if (streq_ptr(m->member, "GetMachineId")) {
2627                 sd_id128_t id;
2628                 char sid[33];
2629
2630                 r = sd_id128_get_machine(&id);
2631                 if (r < 0)
2632                         return r;
2633
2634                 r = sd_bus_message_new_method_return(m, &reply);
2635                 if (r < 0)
2636                         return r;
2637
2638                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2639         } else {
2640                 r = sd_bus_message_new_method_errorf(
2641                                 m, &reply,
2642                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2643                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2644         }
2645
2646         if (r < 0)
2647                 return r;
2648
2649         r = sd_bus_send(bus, reply, NULL);
2650         if (r < 0)
2651                 return r;
2652
2653         return 1;
2654 }
2655
2656 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2657         assert(bus);
2658         assert(m);
2659
2660         /* If we got a message with a file descriptor which we didn't
2661          * want to accept, then let's drop it. How can this even
2662          * happen? For example, when the kernel queues a message into
2663          * an activatable names's queue which allows fds, and then is
2664          * delivered to us later even though we ourselves did not
2665          * negotiate it. */
2666
2667         if (bus->is_monitor)
2668                 return 0;
2669
2670         if (m->n_fds <= 0)
2671                 return 0;
2672
2673         if (bus->accept_fd)
2674                 return 0;
2675
2676         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2677                 return 1; /* just eat it up */
2678
2679         return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2680 }
2681
2682 static int process_message(sd_bus *bus, sd_bus_message *m) {
2683         int r;
2684
2685         assert(bus);
2686         assert(m);
2687
2688         bus->current_message = m;
2689         bus->iteration_counter++;
2690
2691         log_debug_bus_message(m);
2692
2693         r = process_hello(bus, m);
2694         if (r != 0)
2695                 goto finish;
2696
2697         r = process_reply(bus, m);
2698         if (r != 0)
2699                 goto finish;
2700
2701         r = process_fd_check(bus, m);
2702         if (r != 0)
2703                 goto finish;
2704
2705         r = process_filter(bus, m);
2706         if (r != 0)
2707                 goto finish;
2708
2709         r = process_match(bus, m);
2710         if (r != 0)
2711                 goto finish;
2712
2713         r = process_builtin(bus, m);
2714         if (r != 0)
2715                 goto finish;
2716
2717         r = bus_process_object(bus, m);
2718
2719 finish:
2720         bus->current_message = NULL;
2721         return r;
2722 }
2723
2724 static int dispatch_track(sd_bus *bus) {
2725         assert(bus);
2726
2727         if (!bus->track_queue)
2728                 return 0;
2729
2730         bus_track_dispatch(bus->track_queue);
2731         return 1;
2732 }
2733
2734 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2735         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2736         int r;
2737
2738         assert(bus);
2739         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
2740
2741         r = process_timeout(bus);
2742         if (r != 0)
2743                 goto null_message;
2744
2745         r = dispatch_wqueue(bus);
2746         if (r != 0)
2747                 goto null_message;
2748
2749         r = dispatch_track(bus);
2750         if (r != 0)
2751                 goto null_message;
2752
2753         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2754         if (r < 0)
2755                 return r;
2756         if (!m)
2757                 goto null_message;
2758
2759         r = process_message(bus, m);
2760         if (r != 0)
2761                 goto null_message;
2762
2763         if (ret) {
2764                 r = sd_bus_message_rewind(m, true);
2765                 if (r < 0)
2766                         return r;
2767
2768                 *ret = m;
2769                 m = NULL;
2770                 return 1;
2771         }
2772
2773         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2774
2775                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2776                           strna(sd_bus_message_get_sender(m)),
2777                           strna(sd_bus_message_get_path(m)),
2778                           strna(sd_bus_message_get_interface(m)),
2779                           strna(sd_bus_message_get_member(m)));
2780
2781                 r = sd_bus_reply_method_errorf(
2782                                 m,
2783                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2784                                 "Unknown object '%s'.", m->path);
2785                 if (r < 0)
2786                         return r;
2787         }
2788
2789         return 1;
2790
2791 null_message:
2792         if (r >= 0 && ret)
2793                 *ret = NULL;
2794
2795         return r;
2796 }
2797
2798 static int bus_exit_now(sd_bus *bus) {
2799         assert(bus);
2800
2801         /* Exit due to close, if this is requested. If this is bus object is attached to an event source, invokes
2802          * sd_event_exit(), otherwise invokes libc exit(). */
2803
2804         if (bus->exited) /* did we already exit? */
2805                 return 0;
2806         if (!bus->exit_triggered) /* was the exit condition triggered? */
2807                 return 0;
2808         if (!bus->exit_on_disconnect) /* Shall we actually exit on disconnection? */
2809                 return 0;
2810
2811         bus->exited = true; /* never exit more than once */
2812
2813         log_debug("Bus connection disconnected, exiting.");
2814
2815         if (bus->event)
2816                 return sd_event_exit(bus->event, EXIT_FAILURE);
2817         else
2818                 exit(EXIT_FAILURE);
2819
2820         assert_not_reached("exit() didn't exit?");
2821 }
2822
2823 static int process_closing_reply_callback(sd_bus *bus, struct reply_callback *c) {
2824         _cleanup_(sd_bus_error_free) sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2825         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2826         sd_bus_slot *slot;
2827         int r;
2828
2829         assert(bus);
2830         assert(c);
2831
2832         r = bus_message_new_synthetic_error(
2833                         bus,
2834                         c->cookie,
2835                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2836                         &m);
2837         if (r < 0)
2838                 return r;
2839
2840         r = bus_seal_synthetic_message(bus, m);
2841         if (r < 0)
2842                 return r;
2843
2844         if (c->timeout_usec != 0) {
2845                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2846                 c->timeout_usec = 0;
2847         }
2848
2849         ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2850         c->cookie = 0;
2851
2852         slot = container_of(c, sd_bus_slot, reply_callback);
2853
2854         bus->iteration_counter++;
2855
2856         bus->current_message = m;
2857         bus->current_slot = sd_bus_slot_ref(slot);
2858         bus->current_handler = c->callback;
2859         bus->current_userdata = slot->userdata;
2860         r = c->callback(m, slot->userdata, &error_buffer);
2861         bus->current_userdata = NULL;
2862         bus->current_handler = NULL;
2863         bus->current_slot = NULL;
2864         bus->current_message = NULL;
2865
2866         if (slot->floating) {
2867                 bus_slot_disconnect(slot);
2868                 sd_bus_slot_unref(slot);
2869         }
2870
2871         sd_bus_slot_unref(slot);
2872
2873         return bus_maybe_reply_error(m, r, &error_buffer);
2874 }
2875
2876 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2877         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2878         struct reply_callback *c;
2879         int r;
2880
2881         assert(bus);
2882         assert(bus->state == BUS_CLOSING);
2883
2884         /* First, fail all outstanding method calls */
2885         c = ordered_hashmap_first(bus->reply_callbacks);
2886         if (c)
2887                 return process_closing_reply_callback(bus, c);
2888
2889         /* Then, fake-drop all remaining bus tracking references */
2890         if (bus->tracks) {
2891                 bus_track_close(bus->tracks);
2892                 return 1;
2893         }
2894
2895         /* Then, synthesize a Disconnected message */
2896         r = sd_bus_message_new_signal(
2897                         bus,
2898                         &m,
2899                         "/org/freedesktop/DBus/Local",
2900                         "org.freedesktop.DBus.Local",
2901                         "Disconnected");
2902         if (r < 0)
2903                 return r;
2904
2905         bus_message_set_sender_local(bus, m);
2906
2907         r = bus_seal_synthetic_message(bus, m);
2908         if (r < 0)
2909                 return r;
2910
2911         sd_bus_close(bus);
2912
2913         bus->current_message = m;
2914         bus->iteration_counter++;
2915
2916         r = process_filter(bus, m);
2917         if (r != 0)
2918                 goto finish;
2919
2920         r = process_match(bus, m);
2921         if (r != 0)
2922                 goto finish;
2923
2924         /* Nothing else to do, exit now, if the condition holds */
2925         bus->exit_triggered = true;
2926         (void) bus_exit_now(bus);
2927
2928         if (ret) {
2929                 *ret = m;
2930                 m = NULL;
2931         }
2932
2933         r = 1;
2934
2935 finish:
2936         bus->current_message = NULL;
2937
2938         return r;
2939 }
2940
2941 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2942         BUS_DONT_DESTROY(bus);
2943         int r;
2944
2945         /* Returns 0 when we didn't do anything. This should cause the
2946          * caller to invoke sd_bus_wait() before returning the next
2947          * time. Returns > 0 when we did something, which possibly
2948          * means *ret is filled in with an unprocessed message. */
2949
2950         assert_return(bus, -EINVAL);
2951         assert_return(bus = bus_resolve(bus), -ENOPKG);
2952         assert_return(!bus_pid_changed(bus), -ECHILD);
2953
2954         /* We don't allow recursively invoking sd_bus_process(). */
2955         assert_return(!bus->current_message, -EBUSY);
2956         assert(!bus->current_slot);
2957
2958         switch (bus->state) {
2959
2960         case BUS_UNSET:
2961                 return -ENOTCONN;
2962
2963         case BUS_CLOSED:
2964                 return -ECONNRESET;
2965
2966         case BUS_WATCH_BIND:
2967                 r = bus_socket_process_watch_bind(bus);
2968                 break;
2969
2970         case BUS_OPENING:
2971                 r = bus_socket_process_opening(bus);
2972                 break;
2973
2974         case BUS_AUTHENTICATING:
2975                 r = bus_socket_process_authenticating(bus);
2976                 break;
2977
2978         case BUS_RUNNING:
2979         case BUS_HELLO:
2980                 r = process_running(bus, hint_priority, priority, ret);
2981                 if (r >= 0)
2982                         return r;
2983
2984                 /* This branch initializes *ret, hence we don't use the generic error checking below */
2985                 break;
2986
2987         case BUS_CLOSING:
2988                 return process_closing(bus, ret);
2989
2990         default:
2991                 assert_not_reached("Unknown state");
2992         }
2993
2994         if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
2995                 bus_enter_closing(bus);
2996                 r = 1;
2997         } else if (r < 0)
2998                 return r;
2999
3000         if (ret)
3001                 *ret = NULL;
3002
3003         return r;
3004 }
3005
3006 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
3007         return bus_process_internal(bus, false, 0, ret);
3008 }
3009
3010 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
3011         return bus_process_internal(bus, true, priority, ret);
3012 }
3013
3014 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
3015         struct pollfd p[2] = {};
3016         int r, n;
3017         struct timespec ts;
3018         usec_t m = USEC_INFINITY;
3019
3020         assert(bus);
3021
3022         if (bus->state == BUS_CLOSING)
3023                 return 1;
3024
3025         if (!BUS_IS_OPEN(bus->state))
3026                 return -ENOTCONN;
3027
3028         if (bus->state == BUS_WATCH_BIND) {
3029                 assert(bus->inotify_fd >= 0);
3030
3031                 p[0].events = POLLIN;
3032                 p[0].fd = bus->inotify_fd;
3033                 n = 1;
3034         } else {
3035                 int e;
3036
3037                 e = sd_bus_get_events(bus);
3038                 if (e < 0)
3039                         return e;
3040
3041                 if (need_more)
3042                         /* The caller really needs some more data, he doesn't
3043                          * care about what's already read, or any timeouts
3044                          * except its own. */
3045                         e |= POLLIN;
3046                 else {
3047                         usec_t until;
3048                         /* The caller wants to process if there's something to
3049                          * process, but doesn't care otherwise */
3050
3051                         r = sd_bus_get_timeout(bus, &until);
3052                         if (r < 0)
3053                                 return r;
3054                         if (r > 0)
3055                                 m = usec_sub_unsigned(until, now(CLOCK_MONOTONIC));
3056                 }
3057
3058                 p[0].fd = bus->input_fd;
3059                 if (bus->output_fd == bus->input_fd) {
3060                         p[0].events = e;
3061                         n = 1;
3062                 } else {
3063                         p[0].events = e & POLLIN;
3064                         p[1].fd = bus->output_fd;
3065                         p[1].events = e & POLLOUT;
3066                         n = 2;
3067                 }
3068         }
3069
3070         if (timeout_usec != (uint64_t) -1 && (m == USEC_INFINITY || timeout_usec < m))
3071                 m = timeout_usec;
3072
3073         r = ppoll(p, n, m == USEC_INFINITY ? NULL : timespec_store(&ts, m), NULL);
3074         if (r < 0)
3075                 return -errno;
3076
3077         return r > 0 ? 1 : 0;
3078 }
3079
3080 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
3081
3082         assert_return(bus, -EINVAL);
3083         assert_return(bus = bus_resolve(bus), -ENOPKG);
3084         assert_return(!bus_pid_changed(bus), -ECHILD);
3085
3086         if (bus->state == BUS_CLOSING)
3087                 return 0;
3088
3089         if (!BUS_IS_OPEN(bus->state))
3090                 return -ENOTCONN;
3091
3092         if (bus->rqueue_size > 0)
3093                 return 0;
3094
3095         return bus_poll(bus, false, timeout_usec);
3096 }
3097
3098 _public_ int sd_bus_flush(sd_bus *bus) {
3099         int r;
3100
3101         assert_return(bus, -EINVAL);
3102         assert_return(bus = bus_resolve(bus), -ENOPKG);
3103         assert_return(!bus_pid_changed(bus), -ECHILD);
3104
3105         if (bus->state == BUS_CLOSING)
3106                 return 0;
3107
3108         if (!BUS_IS_OPEN(bus->state))
3109                 return -ENOTCONN;
3110
3111         /* We never were connected? Don't hang in inotify for good, as there's no timeout set for it */
3112         if (bus->state == BUS_WATCH_BIND)
3113                 return -EUNATCH;
3114
3115         r = bus_ensure_running(bus);
3116         if (r < 0)
3117                 return r;
3118
3119         if (bus->wqueue_size <= 0)
3120                 return 0;
3121
3122         for (;;) {
3123                 r = dispatch_wqueue(bus);
3124                 if (r < 0) {
3125                         if (IN_SET(r, -ENOTCONN, -ECONNRESET, -EPIPE, -ESHUTDOWN)) {
3126                                 bus_enter_closing(bus);
3127                                 return -ECONNRESET;
3128                         }
3129
3130                         return r;
3131                 }
3132
3133                 if (bus->wqueue_size <= 0)
3134                         return 0;
3135
3136                 r = bus_poll(bus, false, (uint64_t) -1);
3137                 if (r < 0)
3138                         return r;
3139         }
3140 }
3141
3142 _public_ int sd_bus_add_filter(
3143                 sd_bus *bus,
3144                 sd_bus_slot **slot,
3145                 sd_bus_message_handler_t callback,
3146                 void *userdata) {
3147
3148         sd_bus_slot *s;
3149
3150         assert_return(bus, -EINVAL);
3151         assert_return(bus = bus_resolve(bus), -ENOPKG);
3152         assert_return(callback, -EINVAL);
3153         assert_return(!bus_pid_changed(bus), -ECHILD);
3154
3155         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
3156         if (!s)
3157                 return -ENOMEM;
3158
3159         s->filter_callback.callback = callback;
3160
3161         bus->filter_callbacks_modified = true;
3162         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
3163
3164         if (slot)
3165                 *slot = s;
3166
3167         return 0;
3168 }
3169
3170 static int add_match_callback(
3171                 sd_bus_message *m,
3172                 void *userdata,
3173                 sd_bus_error *ret_error) {
3174
3175         sd_bus_slot *match_slot = userdata;
3176         bool failed = false;
3177         int r;
3178
3179         assert(m);
3180         assert(match_slot);
3181
3182         sd_bus_slot_ref(match_slot);
3183
3184         if (sd_bus_message_is_method_error(m, NULL)) {
3185                 log_debug_errno(sd_bus_message_get_errno(m),
3186                                 "Unable to add match %s, failing connection: %s",
3187                                 match_slot->match_callback.match_string,
3188                                 sd_bus_message_get_error(m)->message);
3189
3190                 failed = true;
3191         } else
3192                 log_debug("Match %s successfully installed.", match_slot->match_callback.match_string);
3193
3194         if (match_slot->match_callback.install_callback) {
3195                 sd_bus *bus;
3196
3197                 bus = sd_bus_message_get_bus(m);
3198
3199                 /* This function has been called as slot handler, and we want to call another slot handler. Let's
3200                  * update the slot callback metadata temporarily with our own data, and then revert back to the old
3201                  * values. */
3202
3203                 assert(bus->current_slot == match_slot->match_callback.install_slot);
3204                 assert(bus->current_handler == add_match_callback);
3205                 assert(bus->current_userdata == userdata);
3206
3207                 bus->current_slot = match_slot;
3208                 bus->current_handler = match_slot->match_callback.install_callback;
3209                 bus->current_userdata = match_slot->userdata;
3210
3211                 r = match_slot->match_callback.install_callback(m, match_slot->userdata, ret_error);
3212
3213                 bus->current_slot = match_slot->match_callback.install_slot;
3214                 bus->current_handler = add_match_callback;
3215                 bus->current_userdata = userdata;
3216
3217                 match_slot->match_callback.install_slot = sd_bus_slot_unref(match_slot->match_callback.install_slot);
3218         } else {
3219                 if (failed) /* Generic failure handling: destroy the connection */
3220                         bus_enter_closing(sd_bus_message_get_bus(m));
3221
3222                 r = 1;
3223         }
3224
3225         if (failed && match_slot->floating) {
3226                 bus_slot_disconnect(match_slot);
3227                 sd_bus_slot_unref(match_slot);
3228         }
3229
3230         sd_bus_slot_unref(match_slot);
3231
3232         return r;
3233 }
3234
3235 static int bus_add_match_full(
3236                 sd_bus *bus,
3237                 sd_bus_slot **slot,
3238                 bool asynchronous,
3239                 const char *match,
3240                 sd_bus_message_handler_t callback,
3241                 sd_bus_message_handler_t install_callback,
3242                 void *userdata) {
3243
3244         struct bus_match_component *components = NULL;
3245         unsigned n_components = 0;
3246         sd_bus_slot *s = NULL;
3247         int r = 0;
3248
3249         assert_return(bus, -EINVAL);
3250         assert_return(bus = bus_resolve(bus), -ENOPKG);
3251         assert_return(match, -EINVAL);
3252         assert_return(!bus_pid_changed(bus), -ECHILD);
3253
3254         r = bus_match_parse(match, &components, &n_components);
3255         if (r < 0)
3256                 goto finish;
3257
3258         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3259         if (!s) {
3260                 r = -ENOMEM;
3261                 goto finish;
3262         }
3263
3264         s->match_callback.callback = callback;
3265         s->match_callback.install_callback = install_callback;
3266
3267         if (bus->bus_client) {
3268                 enum bus_match_scope scope;
3269
3270                 scope = bus_match_get_scope(components, n_components);
3271
3272                 /* Do not install server-side matches for matches against the local service, interface or bus path. */
3273                 if (scope != BUS_MATCH_LOCAL) {
3274
3275                         /* We store the original match string, so that we can use it to remove the match again. */
3276
3277                         s->match_callback.match_string = strdup(match);
3278                         if (!s->match_callback.match_string) {
3279                                 r = -ENOMEM;
3280                                 goto finish;
3281                         }
3282
3283                         if (asynchronous)
3284                                 r = bus_add_match_internal_async(bus,
3285                                                                  &s->match_callback.install_slot,
3286                                                                  s->match_callback.match_string,
3287                                                                  add_match_callback,
3288                                                                  s);
3289                         else
3290                                 r = bus_add_match_internal(bus, s->match_callback.match_string);
3291                         if (r < 0)
3292                                 goto finish;
3293
3294                         s->match_added = true;
3295                 }
3296         }
3297
3298         bus->match_callbacks_modified = true;
3299         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3300         if (r < 0)
3301                 goto finish;
3302
3303         if (slot)
3304                 *slot = s;
3305         s = NULL;
3306
3307 finish:
3308         bus_match_parse_free(components, n_components);
3309         sd_bus_slot_unref(s);
3310
3311         return r;
3312 }
3313
3314 #if 0 /// UNNEEDED by elogind
3315 #endif // 0
3316 _public_ int sd_bus_add_match(
3317                 sd_bus *bus,
3318                 sd_bus_slot **slot,
3319                 const char *match,
3320                 sd_bus_message_handler_t callback,
3321                 void *userdata) {
3322
3323         return bus_add_match_full(bus, slot, false, match, callback, NULL, userdata);
3324 }
3325
3326 _public_ int sd_bus_add_match_async(
3327                 sd_bus *bus,
3328                 sd_bus_slot **slot,
3329                 const char *match,
3330                 sd_bus_message_handler_t callback,
3331                 sd_bus_message_handler_t install_callback,
3332                 void *userdata) {
3333
3334         return bus_add_match_full(bus, slot, true, match, callback, install_callback, userdata);
3335 }
3336
3337 bool bus_pid_changed(sd_bus *bus) {
3338         assert(bus);
3339
3340         /* We don't support people creating a bus connection and
3341          * keeping it around over a fork(). Let's complain. */
3342
3343         return bus->original_pid != getpid_cached();
3344 }
3345
3346 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3347         sd_bus *bus = userdata;
3348         int r;
3349
3350         assert(bus);
3351
3352         /* Note that this is called both on input_fd, output_fd as well as inotify_fd events */
3353
3354         r = sd_bus_process(bus, NULL);
3355         if (r < 0) {
3356                 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3357                 bus_enter_closing(bus);
3358         }
3359
3360         return 1;
3361 }
3362
3363 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3364         sd_bus *bus = userdata;
3365         int r;
3366
3367         assert(bus);
3368
3369         r = sd_bus_process(bus, NULL);
3370         if (r < 0) {
3371                 log_debug_errno(r, "Processing of bus failed, closing down: %m");
3372                 bus_enter_closing(bus);
3373         }
3374
3375         return 1;
3376 }
3377
3378 static int prepare_callback(sd_event_source *s, void *userdata) {
3379         sd_bus *bus = userdata;
3380         int r, e;
3381         usec_t until;
3382
3383         assert(s);
3384         assert(bus);
3385
3386         e = sd_bus_get_events(bus);
3387         if (e < 0) {
3388                 r = e;
3389                 goto fail;
3390         }
3391
3392         if (bus->output_fd != bus->input_fd) {
3393
3394                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3395                 if (r < 0)
3396                         goto fail;
3397
3398                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3399         } else
3400                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3401         if (r < 0)
3402                 goto fail;
3403
3404         r = sd_bus_get_timeout(bus, &until);
3405         if (r < 0)
3406                 goto fail;
3407         if (r > 0) {
3408                 int j;
3409
3410                 j = sd_event_source_set_time(bus->time_event_source, until);
3411                 if (j < 0) {
3412                         r = j;
3413                         goto fail;
3414                 }
3415         }
3416
3417         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3418         if (r < 0)
3419                 goto fail;
3420
3421         return 1;
3422
3423 fail:
3424         log_debug_errno(r, "Preparing of bus events failed, closing down: %m");
3425         bus_enter_closing(bus);
3426
3427         return 1;
3428 }
3429
3430 static int quit_callback(sd_event_source *event, void *userdata) {
3431         sd_bus *bus = userdata;
3432
3433         assert(event);
3434
3435         sd_bus_flush(bus);
3436         sd_bus_close(bus);
3437
3438         return 1;
3439 }
3440
3441 int bus_attach_io_events(sd_bus *bus) {
3442         int r;
3443
3444         assert(bus);
3445
3446         if (bus->input_fd < 0)
3447                 return 0;
3448
3449         if (!bus->event)
3450                 return 0;
3451
3452         if (!bus->input_io_event_source) {
3453                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3454                 if (r < 0)
3455                         return r;
3456
3457                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3458                 if (r < 0)
3459                         return r;
3460
3461                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3462                 if (r < 0)
3463                         return r;
3464
3465                 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3466         } else
3467                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3468
3469         if (r < 0)
3470                 return r;
3471
3472         if (bus->output_fd != bus->input_fd) {
3473                 assert(bus->output_fd >= 0);
3474
3475                 if (!bus->output_io_event_source) {
3476                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3477                         if (r < 0)
3478                                 return r;
3479
3480                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3481                         if (r < 0)
3482                                 return r;
3483
3484                         r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3485                 } else
3486                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3487
3488                 if (r < 0)
3489                         return r;
3490         }
3491
3492         return 0;
3493 }
3494
3495 static void bus_detach_io_events(sd_bus *bus) {
3496         assert(bus);
3497
3498         if (bus->input_io_event_source) {
3499                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3500                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3501         }
3502
3503         if (bus->output_io_event_source) {
3504                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3505                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3506         }
3507 }
3508
3509 int bus_attach_inotify_event(sd_bus *bus) {
3510         int r;
3511
3512         assert(bus);
3513
3514         if (bus->inotify_fd < 0)
3515                 return 0;
3516
3517         if (!bus->event)
3518                 return 0;
3519
3520         if (!bus->inotify_event_source) {
3521                 r = sd_event_add_io(bus->event, &bus->inotify_event_source, bus->inotify_fd, EPOLLIN, io_callback, bus);
3522                 if (r < 0)
3523                         return r;
3524
3525                 r = sd_event_source_set_priority(bus->inotify_event_source, bus->event_priority);
3526                 if (r < 0)
3527                         return r;
3528
3529                 r = sd_event_source_set_description(bus->inotify_event_source, "bus-inotify");
3530         } else
3531                 r = sd_event_source_set_io_fd(bus->inotify_event_source, bus->inotify_fd);
3532         if (r < 0)
3533                 return r;
3534
3535         return 0;
3536 }
3537
3538 static void bus_detach_inotify_event(sd_bus *bus) {
3539         assert(bus);
3540
3541         if (bus->inotify_event_source) {
3542                 sd_event_source_set_enabled(bus->inotify_event_source, SD_EVENT_OFF);
3543                 bus->inotify_event_source = sd_event_source_unref(bus->inotify_event_source);
3544         }
3545 }
3546
3547 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3548         int r;
3549
3550         assert_return(bus, -EINVAL);
3551         assert_return(bus = bus_resolve(bus), -ENOPKG);
3552         assert_return(!bus->event, -EBUSY);
3553
3554         assert(!bus->input_io_event_source);
3555         assert(!bus->output_io_event_source);
3556         assert(!bus->time_event_source);
3557
3558         if (event)
3559                 bus->event = sd_event_ref(event);
3560         else  {
3561                 r = sd_event_default(&bus->event);
3562                 if (r < 0)
3563                         return r;
3564         }
3565
3566         bus->event_priority = priority;
3567
3568         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3569         if (r < 0)
3570                 goto fail;
3571
3572         r = sd_event_source_set_priority(bus->time_event_source, priority);
3573         if (r < 0)
3574                 goto fail;
3575
3576         r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3577         if (r < 0)
3578                 goto fail;
3579
3580         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3581         if (r < 0)
3582                 goto fail;
3583
3584         r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3585         if (r < 0)
3586                 goto fail;
3587
3588         r = bus_attach_io_events(bus);
3589         if (r < 0)
3590                 goto fail;
3591
3592         r = bus_attach_inotify_event(bus);
3593         if (r < 0)
3594                 goto fail;
3595
3596         return 0;
3597
3598 fail:
3599         sd_bus_detach_event(bus);
3600         return r;
3601 }
3602
3603 _public_ int sd_bus_detach_event(sd_bus *bus) {
3604         assert_return(bus, -EINVAL);
3605         assert_return(bus = bus_resolve(bus), -ENOPKG);
3606
3607         if (!bus->event)
3608                 return 0;
3609
3610         bus_detach_io_events(bus);
3611         bus_detach_inotify_event(bus);
3612
3613         if (bus->time_event_source) {
3614                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3615                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3616         }
3617
3618         if (bus->quit_event_source) {
3619                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3620                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3621         }
3622
3623         bus->event = sd_event_unref(bus->event);
3624         return 1;
3625 }
3626
3627 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3628         assert_return(bus, NULL);
3629
3630         return bus->event;
3631 }
3632
3633 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3634         assert_return(bus, NULL);
3635
3636         return bus->current_message;
3637 }
3638
3639 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3640         assert_return(bus, NULL);
3641
3642         return bus->current_slot;
3643 }
3644
3645 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3646         assert_return(bus, NULL);
3647
3648         return bus->current_handler;
3649 }
3650
3651 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3652         assert_return(bus, NULL);
3653
3654         return bus->current_userdata;
3655 }
3656
3657 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3658         sd_bus *b = NULL;
3659         int r;
3660
3661         assert(bus_open);
3662         assert(default_bus);
3663
3664         if (!ret)
3665                 return !!*default_bus;
3666
3667         if (*default_bus) {
3668                 *ret = sd_bus_ref(*default_bus);
3669                 return 0;
3670         }
3671
3672         r = bus_open(&b);
3673         if (r < 0)
3674                 return r;
3675
3676         b->default_bus_ptr = default_bus;
3677         b->tid = gettid();
3678         *default_bus = b;
3679
3680         *ret = b;
3681         return 1;
3682 }
3683
3684 _public_ int sd_bus_default_system(sd_bus **ret) {
3685         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3686 }
3687
3688
3689 _public_ int sd_bus_default_user(sd_bus **ret) {
3690 #if 0 /// elogind does not support user buses
3691         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3692 #else
3693         return sd_bus_default_system(ret);
3694 #endif // 0
3695 }
3696
3697 _public_ int sd_bus_default(sd_bus **ret) {
3698         int (*bus_open)(sd_bus **) = NULL;
3699         sd_bus **busp;
3700
3701         busp = bus_choose_default(&bus_open);
3702         return bus_default(bus_open, busp, ret);
3703 }
3704
3705 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3706         assert_return(b, -EINVAL);
3707         assert_return(tid, -EINVAL);
3708         assert_return(!bus_pid_changed(b), -ECHILD);
3709
3710         if (b->tid != 0) {
3711                 *tid = b->tid;
3712                 return 0;
3713         }
3714
3715         if (b->event)
3716                 return sd_event_get_tid(b->event, tid);
3717
3718         return -ENXIO;
3719 }
3720
3721 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3722         _cleanup_free_ char *e = NULL;
3723         char *ret;
3724
3725         assert_return(object_path_is_valid(prefix), -EINVAL);
3726         assert_return(external_id, -EINVAL);
3727         assert_return(ret_path, -EINVAL);
3728
3729         e = bus_label_escape(external_id);
3730         if (!e)
3731                 return -ENOMEM;
3732
3733         ret = strjoin(prefix, "/", e);
3734         if (!ret)
3735                 return -ENOMEM;
3736
3737         *ret_path = ret;
3738         return 0;
3739 }
3740
3741 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3742         const char *e;
3743         char *ret;
3744
3745         assert_return(object_path_is_valid(path), -EINVAL);
3746         assert_return(object_path_is_valid(prefix), -EINVAL);
3747         assert_return(external_id, -EINVAL);
3748
3749         e = object_path_startswith(path, prefix);
3750         if (!e) {
3751                 *external_id = NULL;
3752                 return 0;
3753         }
3754
3755         ret = bus_label_unescape(e);
3756         if (!ret)
3757                 return -ENOMEM;
3758
3759         *external_id = ret;
3760         return 1;
3761 }
3762
3763 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3764         _cleanup_strv_free_ char **labels = NULL;
3765         char *path, *path_pos, **label_pos;
3766         const char *sep, *template_pos;
3767         size_t path_length;
3768         va_list list;
3769         int r;
3770
3771         assert_return(out, -EINVAL);
3772         assert_return(path_template, -EINVAL);
3773
3774         path_length = strlen(path_template);
3775
3776         va_start(list, path_template);
3777         for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3778                 const char *arg;
3779                 char *label;
3780
3781                 arg = va_arg(list, const char *);
3782                 if (!arg) {
3783                         va_end(list);
3784                         return -EINVAL;
3785                 }
3786
3787                 label = bus_label_escape(arg);
3788                 if (!label) {
3789                         va_end(list);
3790                         return -ENOMEM;
3791                 }
3792
3793                 r = strv_consume(&labels, label);
3794                 if (r < 0) {
3795                         va_end(list);
3796                         return r;
3797                 }
3798
3799                 /* add label length, but account for the format character */
3800                 path_length += strlen(label) - 1;
3801         }
3802         va_end(list);
3803
3804         path = malloc(path_length + 1);
3805         if (!path)
3806                 return -ENOMEM;
3807
3808         path_pos = path;
3809         label_pos = labels;
3810
3811         for (template_pos = path_template; *template_pos; ) {
3812                 sep = strchrnul(template_pos, '%');
3813                 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3814                 if (!*sep)
3815                         break;
3816
3817                 path_pos = stpcpy(path_pos, *label_pos++);
3818                 template_pos = sep + 1;
3819         }
3820
3821         *path_pos = 0;
3822         *out = path;
3823         return 0;
3824 }
3825
3826 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3827         _cleanup_strv_free_ char **labels = NULL;
3828         const char *template_pos, *path_pos;
3829         char **label_pos;
3830         va_list list;
3831         int r;
3832
3833         /*
3834          * This decodes an object-path based on a template argument. The
3835          * template consists of a verbatim path, optionally including special
3836          * directives:
3837          *
3838          *   - Each occurrence of '%' in the template matches an arbitrary
3839          *     substring of a label in the given path. At most one such
3840          *     directive is allowed per label. For each such directive, the
3841          *     caller must provide an output parameter (char **) via va_arg. If
3842          *     NULL is passed, the given label is verified, but not returned.
3843          *     For each matched label, the *decoded* label is stored in the
3844          *     passed output argument, and the caller is responsible to free
3845          *     it. Note that the output arguments are only modified if the
3846          *     actualy path matched the template. Otherwise, they're left
3847          *     untouched.
3848          *
3849          * This function returns <0 on error, 0 if the path does not match the
3850          * template, 1 if it matched.
3851          */
3852
3853         assert_return(path, -EINVAL);
3854         assert_return(path_template, -EINVAL);
3855
3856         path_pos = path;
3857
3858         for (template_pos = path_template; *template_pos; ) {
3859                 const char *sep;
3860                 size_t length;
3861                 char *label;
3862
3863                 /* verify everything until the next '%' matches verbatim */
3864                 sep = strchrnul(template_pos, '%');
3865                 length = sep - template_pos;
3866                 if (strncmp(path_pos, template_pos, length))
3867                         return 0;
3868
3869                 path_pos += length;
3870                 template_pos += length;
3871
3872                 if (!*template_pos)
3873                         break;
3874
3875                 /* We found the next '%' character. Everything up until here
3876                  * matched. We now skip ahead to the end of this label and make
3877                  * sure it matches the tail of the label in the path. Then we
3878                  * decode the string in-between and save it for later use. */
3879
3880                 ++template_pos; /* skip over '%' */
3881
3882                 sep = strchrnul(template_pos, '/');
3883                 length = sep - template_pos; /* length of suffix to match verbatim */
3884
3885                 /* verify the suffixes match */
3886                 sep = strchrnul(path_pos, '/');
3887                 if (sep - path_pos < (ssize_t)length ||
3888                     strncmp(sep - length, template_pos, length))
3889                         return 0;
3890
3891                 template_pos += length; /* skip over matched label */
3892                 length = sep - path_pos - length; /* length of sub-label to decode */
3893
3894                 /* store unescaped label for later use */
3895                 label = bus_label_unescape_n(path_pos, length);
3896                 if (!label)
3897                         return -ENOMEM;
3898
3899                 r = strv_consume(&labels, label);
3900                 if (r < 0)
3901                         return r;
3902
3903                 path_pos = sep; /* skip decoded label and suffix */
3904         }
3905
3906         /* end of template must match end of path */
3907         if (*path_pos)
3908                 return 0;
3909
3910         /* copy the labels over to the caller */
3911         va_start(list, path_template);
3912         for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3913                 char **arg;
3914
3915                 arg = va_arg(list, char **);
3916                 if (arg)
3917                         *arg = *label_pos;
3918                 else
3919                         free(*label_pos);
3920         }
3921         va_end(list);
3922
3923         labels = mfree(labels);
3924         return 1;
3925 }
3926
3927 _public_ int sd_bus_try_close(sd_bus *bus) {
3928         assert_return(bus, -EINVAL);
3929         assert_return(bus = bus_resolve(bus), -ENOPKG);
3930         assert_return(!bus_pid_changed(bus), -ECHILD);
3931
3932         return -EOPNOTSUPP;
3933 }
3934
3935 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3936         assert_return(bus, -EINVAL);
3937         assert_return(bus = bus_resolve(bus), -ENOPKG);
3938         assert_return(description, -EINVAL);
3939         assert_return(bus->description, -ENXIO);
3940         assert_return(!bus_pid_changed(bus), -ECHILD);
3941
3942         if (bus->description)
3943                 *description = bus->description;
3944         else if (bus->is_system)
3945                 *description = "system";
3946         else if (bus->is_user)
3947                 *description = "user";
3948         else
3949                 *description = NULL;
3950
3951         return 0;
3952 }
3953
3954 int bus_get_root_path(sd_bus *bus) {
3955         int r;
3956
3957         if (bus->cgroup_root)
3958                 return 0;
3959
3960         r = cg_get_root_path(&bus->cgroup_root);
3961         if (r == -ENOENT) {
3962                 bus->cgroup_root = strdup("/");
3963                 if (!bus->cgroup_root)
3964                         return -ENOMEM;
3965
3966                 r = 0;
3967         }
3968
3969         return r;
3970 }
3971
3972 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3973         assert_return(bus, -EINVAL);
3974         assert_return(bus = bus_resolve(bus), -ENOPKG);
3975         assert_return(scope, -EINVAL);
3976         assert_return(!bus_pid_changed(bus), -ECHILD);
3977
3978         if (bus->is_user) {
3979                 *scope = "user";
3980                 return 0;
3981         }
3982
3983         if (bus->is_system) {
3984                 *scope = "system";
3985                 return 0;
3986         }
3987
3988         return -ENODATA;
3989 }
3990
3991 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3992
3993         assert_return(bus, -EINVAL);
3994         assert_return(bus = bus_resolve(bus), -ENOPKG);
3995         assert_return(address, -EINVAL);
3996         assert_return(!bus_pid_changed(bus), -ECHILD);
3997
3998         if (bus->address) {
3999                 *address = bus->address;
4000                 return 0;
4001         }
4002
4003         return -ENODATA;
4004 }
4005
4006 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
4007         assert_return(bus, -EINVAL);
4008         assert_return(bus = bus_resolve(bus), -ENOPKG);
4009         assert_return(mask, -EINVAL);
4010         assert_return(!bus_pid_changed(bus), -ECHILD);
4011
4012         *mask = bus->creds_mask;
4013         return 0;
4014 }
4015
4016 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
4017         assert_return(bus, -EINVAL);
4018         assert_return(bus = bus_resolve(bus), -ENOPKG);
4019         assert_return(!bus_pid_changed(bus), -ECHILD);
4020
4021         return bus->bus_client;
4022 }
4023
4024 _public_ int sd_bus_is_server(sd_bus *bus) {
4025         assert_return(bus, -EINVAL);
4026         assert_return(bus = bus_resolve(bus), -ENOPKG);
4027         assert_return(!bus_pid_changed(bus), -ECHILD);
4028
4029         return bus->is_server;
4030 }
4031
4032 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
4033         assert_return(bus, -EINVAL);
4034         assert_return(bus = bus_resolve(bus), -ENOPKG);
4035         assert_return(!bus_pid_changed(bus), -ECHILD);
4036
4037         return bus->anonymous_auth;
4038 }
4039
4040 _public_ int sd_bus_is_trusted(sd_bus *bus) {
4041         assert_return(bus, -EINVAL);
4042         assert_return(bus = bus_resolve(bus), -ENOPKG);
4043         assert_return(!bus_pid_changed(bus), -ECHILD);
4044
4045         return bus->trusted;
4046 }
4047
4048 _public_ int sd_bus_is_monitor(sd_bus *bus) {
4049         assert_return(bus, -EINVAL);
4050         assert_return(bus = bus_resolve(bus), -ENOPKG);
4051         assert_return(!bus_pid_changed(bus), -ECHILD);
4052
4053         return bus->is_monitor;
4054 }
4055
4056 static void flush_close(sd_bus *bus) {
4057         if (!bus)
4058                 return;
4059
4060         /* Flushes and closes the specified bus. We take a ref before,
4061          * to ensure the flushing does not cause the bus to be
4062          * unreferenced. */
4063
4064         sd_bus_flush_close_unref(sd_bus_ref(bus));
4065 }
4066
4067 _public_ void sd_bus_default_flush_close(void) {
4068         flush_close(default_starter_bus);
4069 #if 0 /// elogind does not support user buses
4070         flush_close(default_user_bus);
4071 #endif // 0
4072         flush_close(default_system_bus);
4073 }
4074
4075 _public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
4076         assert_return(bus, -EINVAL);
4077         assert_return(bus = bus_resolve(bus), -ENOPKG);
4078
4079         /* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
4080          * disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
4081          * from the client side. */
4082         bus->exit_on_disconnect = b;
4083
4084         /* If the exit condition was triggered already, exit immediately. */
4085         return bus_exit_now(bus);
4086 }
4087
4088 _public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
4089         assert_return(bus, -EINVAL);
4090         assert_return(bus = bus_resolve(bus), -ENOPKG);
4091
4092         return bus->exit_on_disconnect;
4093 }
4094
4095 _public_ int sd_bus_set_sender(sd_bus *bus, const char *sender) {
4096         assert_return(bus, -EINVAL);
4097         assert_return(bus = bus_resolve(bus), -ENOPKG);
4098         assert_return(!bus->bus_client, -EPERM);
4099         assert_return(!sender || service_name_is_valid(sender), -EINVAL);
4100
4101         return free_and_strdup(&bus->patch_sender, sender);
4102 }
4103
4104 _public_ int sd_bus_get_sender(sd_bus *bus, const char **ret) {
4105         assert_return(bus, -EINVAL);
4106         assert_return(bus = bus_resolve(bus), -ENOPKG);
4107         assert_return(ret, -EINVAL);
4108
4109         if (!bus->patch_sender)
4110                 return -ENODATA;
4111
4112         *ret = bus->patch_sender;
4113         return 0;
4114 }
4115
4116 _public_ int sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret) {
4117         assert_return(bus, -EINVAL);
4118         assert_return(bus = bus_resolve(bus), -ENOPKG);
4119         assert_return(!bus_pid_changed(bus), -ECHILD);
4120         assert_return(ret, -EINVAL);
4121
4122         *ret = bus->rqueue_size;
4123         return 0;
4124 }
4125
4126 _public_ int sd_bus_get_n_queued_write(sd_bus *bus, uint64_t *ret) {
4127         assert_return(bus, -EINVAL);
4128         assert_return(bus = bus_resolve(bus), -ENOPKG);
4129         assert_return(!bus_pid_changed(bus), -ECHILD);
4130         assert_return(ret, -EINVAL);
4131
4132         *ret = bus->wqueue_size;
4133         return 0;
4134 }