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