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

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