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

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