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

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