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