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