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

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