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