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