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_bus_message_unref_ 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 /// elogind does not support systemd units
1168 #if 0
1169                 else if (STR_IN_SET(e, "session", "user"))
1170                         return sd_bus_open_user(ret);
1171 #endif // 0
1172         }
1173
1174         e = secure_getenv("DBUS_STARTER_ADDRESS");
1175         if (!e) {
1176 /// elogind does not support systemd units
1177 #if 0
1178                 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1179                         return sd_bus_open_user(ret);
1180                 else
1181 #endif // 0
1182                 return sd_bus_open_system(ret);
1183         }
1184
1185         r = sd_bus_new(&b);
1186         if (r < 0)
1187                 return r;
1188
1189         r = sd_bus_set_address(b, e);
1190         if (r < 0)
1191                 goto fail;
1192
1193         b->bus_client = true;
1194
1195         /* We don't know whether the bus is trusted or not, so better
1196          * be safe, and authenticate everything */
1197         b->trusted = false;
1198         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1199         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1200
1201         r = sd_bus_start(b);
1202         if (r < 0)
1203                 goto fail;
1204
1205         *ret = b;
1206         return 0;
1207
1208 fail:
1209         bus_free(b);
1210         return r;
1211 }
1212
1213 int bus_set_address_system(sd_bus *b) {
1214         const char *e;
1215         assert(b);
1216
1217         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1218         if (e)
1219                 return sd_bus_set_address(b, e);
1220
1221         return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1222 }
1223
1224 _public_ int sd_bus_open_system(sd_bus **ret) {
1225         sd_bus *b;
1226         int r;
1227
1228         assert_return(ret, -EINVAL);
1229
1230         r = sd_bus_new(&b);
1231         if (r < 0)
1232                 return r;
1233
1234         r = bus_set_address_system(b);
1235         if (r < 0)
1236                 goto fail;
1237
1238         b->bus_client = true;
1239         b->is_system = true;
1240
1241         /* Let's do per-method access control on the system bus. We
1242          * need the caller's UID and capability set for that. */
1243         b->trusted = false;
1244         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1245         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1246
1247         r = sd_bus_start(b);
1248         if (r < 0)
1249                 goto fail;
1250
1251         *ret = b;
1252         return 0;
1253
1254 fail:
1255         bus_free(b);
1256         return r;
1257 }
1258
1259 /// elogind can not open/use a user bus
1260 #if 0
1261 int bus_set_address_user(sd_bus *b) {
1262         const char *e;
1263         uid_t uid;
1264         int r;
1265
1266         assert(b);
1267
1268         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1269         if (e)
1270                 return sd_bus_set_address(b, e);
1271
1272         r = cg_pid_get_owner_uid(0, &uid);
1273         if (r < 0)
1274                 uid = getuid();
1275
1276         e = secure_getenv("XDG_RUNTIME_DIR");
1277         if (e) {
1278                 _cleanup_free_ char *ee = NULL;
1279
1280                 ee = bus_address_escape(e);
1281                 if (!ee)
1282                         return -ENOMEM;
1283
1284                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1285         } else
1286                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1287
1288         if (!b->address)
1289                 return -ENOMEM;
1290
1291         return 0;
1292 }
1293 #endif // 0
1294
1295 _public_ int sd_bus_open_user(sd_bus **ret) {
1296 /// elogind does not support user buses
1297 #if 0
1298         sd_bus *b;
1299         int r;
1300
1301         assert_return(ret, -EINVAL);
1302
1303         r = sd_bus_new(&b);
1304         if (r < 0)
1305                 return r;
1306
1307         r = bus_set_address_user(b);
1308         if (r < 0)
1309                 return r;
1310
1311         b->bus_client = true;
1312         b->is_user = true;
1313
1314         /* We don't do any per-method access control on the user
1315          * bus. */
1316         b->trusted = true;
1317
1318         r = sd_bus_start(b);
1319         if (r < 0)
1320                 goto fail;
1321
1322         *ret = b;
1323         return 0;
1324
1325 fail:
1326         bus_free(b);
1327         return r;
1328 #else
1329         return sd_bus_open_system(ret);
1330 #endif // 0
1331 }
1332
1333 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1334         _cleanup_free_ char *e = NULL;
1335         char *m = NULL, *c = NULL;
1336
1337         assert(b);
1338         assert(host);
1339
1340         /* Let's see if we shall enter some container */
1341         m = strchr(host, ':');
1342         if (m) {
1343                 m++;
1344
1345                 /* Let's make sure this is not a port of some kind,
1346                  * and is a valid machine name. */
1347                 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1348                         char *t;
1349
1350                         /* Cut out the host part */
1351                         t = strndupa(host, m - host - 1);
1352                         e = bus_address_escape(t);
1353                         if (!e)
1354                                 return -ENOMEM;
1355
1356                         c = strjoina(",argv4=--machine=", m);
1357                 }
1358         }
1359
1360         if (!e) {
1361                 e = bus_address_escape(host);
1362                 if (!e)
1363                         return -ENOMEM;
1364         }
1365
1366         b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1367         if (!b->address)
1368                 return -ENOMEM;
1369
1370         return 0;
1371  }
1372
1373 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1374         sd_bus *bus;
1375         int r;
1376
1377         assert_return(host, -EINVAL);
1378         assert_return(ret, -EINVAL);
1379
1380         r = sd_bus_new(&bus);
1381         if (r < 0)
1382                 return r;
1383
1384         r = bus_set_address_system_remote(bus, host);
1385         if (r < 0)
1386                 goto fail;
1387
1388         bus->bus_client = true;
1389         bus->trusted = false;
1390         bus->is_system = true;
1391
1392         r = sd_bus_start(bus);
1393         if (r < 0)
1394                 goto fail;
1395
1396         *ret = bus;
1397         return 0;
1398
1399 fail:
1400         bus_free(bus);
1401         return r;
1402 }
1403
1404 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1405         _cleanup_free_ char *e = NULL;
1406
1407         assert(b);
1408         assert(machine);
1409
1410         e = bus_address_escape(machine);
1411         if (!e)
1412                 return -ENOMEM;
1413
1414         b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1415         if (!b->address)
1416                 return -ENOMEM;
1417
1418         return 0;
1419 }
1420
1421 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1422         sd_bus *bus;
1423         int r;
1424
1425         assert_return(machine, -EINVAL);
1426         assert_return(ret, -EINVAL);
1427         assert_return(machine_name_is_valid(machine), -EINVAL);
1428
1429         r = sd_bus_new(&bus);
1430         if (r < 0)
1431                 return r;
1432
1433         r = bus_set_address_system_machine(bus, machine);
1434         if (r < 0)
1435                 goto fail;
1436
1437         bus->bus_client = true;
1438         bus->trusted = false;
1439         bus->is_system = true;
1440
1441         r = sd_bus_start(bus);
1442         if (r < 0)
1443                 goto fail;
1444
1445         *ret = bus;
1446         return 0;
1447
1448 fail:
1449         bus_free(bus);
1450         return r;
1451 }
1452
1453 _public_ void sd_bus_close(sd_bus *bus) {
1454
1455         if (!bus)
1456                 return;
1457         if (bus->state == BUS_CLOSED)
1458                 return;
1459         if (bus_pid_changed(bus))
1460                 return;
1461
1462         bus->state = BUS_CLOSED;
1463
1464         sd_bus_detach_event(bus);
1465
1466         /* Drop all queued messages so that they drop references to
1467          * the bus object and the bus may be freed */
1468         bus_reset_queues(bus);
1469
1470         if (!bus->is_kernel)
1471                 bus_close_fds(bus);
1472
1473         /* We'll leave the fd open in case this is a kernel bus, since
1474          * there might still be memblocks around that reference this
1475          * bus, and they might need to invoke the KDBUS_CMD_FREE
1476          * ioctl on the fd when they are freed. */
1477 }
1478
1479 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1480
1481         if (!bus)
1482                 return NULL;
1483
1484         sd_bus_flush(bus);
1485         sd_bus_close(bus);
1486
1487         return sd_bus_unref(bus);
1488 }
1489
1490 static void bus_enter_closing(sd_bus *bus) {
1491         assert(bus);
1492
1493         if (bus->state != BUS_OPENING &&
1494             bus->state != BUS_AUTHENTICATING &&
1495             bus->state != BUS_HELLO &&
1496             bus->state != BUS_RUNNING)
1497                 return;
1498
1499         bus->state = BUS_CLOSING;
1500 }
1501
1502 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1503         assert_return(bus, NULL);
1504
1505         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1506
1507         return bus;
1508 }
1509
1510 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1511         unsigned i;
1512
1513         if (!bus)
1514                 return NULL;
1515
1516         i = REFCNT_DEC(bus->n_ref);
1517         if (i > 0)
1518                 return NULL;
1519
1520         bus_free(bus);
1521         return NULL;
1522 }
1523
1524 #if 0 /// UNNEEDED by elogind
1525 _public_ int sd_bus_is_open(sd_bus *bus) {
1526
1527         assert_return(bus, -EINVAL);
1528         assert_return(!bus_pid_changed(bus), -ECHILD);
1529
1530         return BUS_IS_OPEN(bus->state);
1531 }
1532 #endif // 0
1533
1534 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1535         int r;
1536
1537         assert_return(bus, -EINVAL);
1538         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1539         assert_return(!bus_pid_changed(bus), -ECHILD);
1540
1541         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1542                 return 0;
1543
1544         if (type == SD_BUS_TYPE_UNIX_FD) {
1545                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1546                         return 0;
1547
1548                 r = bus_ensure_running(bus);
1549                 if (r < 0)
1550                         return r;
1551
1552                 return bus->can_fds;
1553         }
1554
1555         return bus_type_is_valid(type);
1556 }
1557
1558 #if 0 /// UNNEEDED by elogind
1559 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1560         int r;
1561
1562         assert_return(bus, -EINVAL);
1563         assert_return(id, -EINVAL);
1564         assert_return(!bus_pid_changed(bus), -ECHILD);
1565
1566         r = bus_ensure_running(bus);
1567         if (r < 0)
1568                 return r;
1569
1570         *id = bus->server_id;
1571         return 0;
1572 }
1573 #endif // 0
1574
1575 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1576         assert(b);
1577         assert(m);
1578
1579         if (m->sealed) {
1580                 /* If we copy the same message to multiple
1581                  * destinations, avoid using the same cookie
1582                  * numbers. */
1583                 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1584                 return 0;
1585         }
1586
1587         if (timeout == 0)
1588                 timeout = BUS_DEFAULT_TIMEOUT;
1589
1590         return bus_message_seal(m, ++b->cookie, timeout);
1591 }
1592
1593 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1594         bool remarshal = false;
1595
1596         assert(b);
1597
1598         /* wrong packet version */
1599         if (b->message_version != 0 && b->message_version != (*m)->header->version)
1600                 remarshal = true;
1601
1602         /* wrong packet endianness */
1603         if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1604                 remarshal = true;
1605
1606         /* TODO: kdbus-messages received from the kernel contain data which is
1607          * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1608          * force remarshaling of the message. Technically, we could just
1609          * recreate the kdbus message, but that is non-trivial as other parts of
1610          * the message refer to m->kdbus already. This should be fixed! */
1611         if ((*m)->kdbus && (*m)->release_kdbus)
1612                 remarshal = true;
1613
1614         return remarshal ? bus_message_remarshal(b, m) : 0;
1615 }
1616
1617 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1618         assert(b);
1619         assert(m);
1620
1621         /* Fake some timestamps, if they were requested, and not
1622          * already initialized */
1623         if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1624                 if (m->realtime <= 0)
1625                         m->realtime = now(CLOCK_REALTIME);
1626
1627                 if (m->monotonic <= 0)
1628                         m->monotonic = now(CLOCK_MONOTONIC);
1629         }
1630
1631         /* The bus specification says the serial number cannot be 0,
1632          * hence let's fill something in for synthetic messages. Since
1633          * synthetic messages might have a fake sender and we don't
1634          * want to interfere with the real sender's serial numbers we
1635          * pick a fixed, artificial one. We use (uint32_t) -1 rather
1636          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1637          * even though kdbus can do 64bit. */
1638         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1639 }
1640
1641 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1642         int r;
1643
1644         assert(bus);
1645         assert(m);
1646
1647         if (bus->is_kernel)
1648                 r = bus_kernel_write_message(bus, m, hint_sync_call);
1649         else
1650                 r = bus_socket_write_message(bus, m, idx);
1651
1652         if (r <= 0)
1653                 return r;
1654
1655         if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1656                 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1657                           bus_message_type_to_string(m->header->type),
1658                           strna(sd_bus_message_get_sender(m)),
1659                           strna(sd_bus_message_get_destination(m)),
1660                           strna(sd_bus_message_get_path(m)),
1661                           strna(sd_bus_message_get_interface(m)),
1662                           strna(sd_bus_message_get_member(m)),
1663                           BUS_MESSAGE_COOKIE(m),
1664                           m->reply_cookie,
1665                           strna(m->error.message));
1666
1667         return r;
1668 }
1669
1670 static int dispatch_wqueue(sd_bus *bus) {
1671         int r, ret = 0;
1672
1673         assert(bus);
1674         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1675
1676         while (bus->wqueue_size > 0) {
1677
1678                 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1679                 if (r < 0)
1680                         return r;
1681                 else if (r == 0)
1682                         /* Didn't do anything this time */
1683                         return ret;
1684                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1685                         /* Fully written. Let's drop the entry from
1686                          * the queue.
1687                          *
1688                          * This isn't particularly optimized, but
1689                          * well, this is supposed to be our worst-case
1690                          * buffer only, and the socket buffer is
1691                          * supposed to be our primary buffer, and if
1692                          * it got full, then all bets are off
1693                          * anyway. */
1694
1695                         bus->wqueue_size --;
1696                         sd_bus_message_unref(bus->wqueue[0]);
1697                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1698                         bus->windex = 0;
1699
1700                         ret = 1;
1701                 }
1702         }
1703
1704         return ret;
1705 }
1706
1707 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1708         assert(bus);
1709
1710         if (bus->is_kernel)
1711                 return bus_kernel_read_message(bus, hint_priority, priority);
1712         else
1713                 return bus_socket_read_message(bus);
1714 }
1715
1716 int bus_rqueue_make_room(sd_bus *bus) {
1717         assert(bus);
1718
1719         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1720                 return -ENOBUFS;
1721
1722         if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1723                 return -ENOMEM;
1724
1725         return 0;
1726 }
1727
1728 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1729         int r, ret = 0;
1730
1731         assert(bus);
1732         assert(m);
1733         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1734
1735         /* Note that the priority logic is only available on kdbus,
1736          * where the rqueue is unused. We check the rqueue here
1737          * anyway, because it's simple... */
1738
1739         for (;;) {
1740                 if (bus->rqueue_size > 0) {
1741                         /* Dispatch a queued message */
1742
1743                         *m = bus->rqueue[0];
1744                         bus->rqueue_size --;
1745                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1746                         return 1;
1747                 }
1748
1749                 /* Try to read a new message */
1750                 r = bus_read_message(bus, hint_priority, priority);
1751                 if (r < 0)
1752                         return r;
1753                 if (r == 0)
1754                         return ret;
1755
1756                 ret = 1;
1757         }
1758 }
1759
1760 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1761         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1762         int r;
1763
1764         assert_return(m, -EINVAL);
1765
1766         if (!bus)
1767                 bus = m->bus;
1768
1769         assert_return(!bus_pid_changed(bus), -ECHILD);
1770         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1771
1772         if (!BUS_IS_OPEN(bus->state))
1773                 return -ENOTCONN;
1774
1775         if (m->n_fds > 0) {
1776                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1777                 if (r < 0)
1778                         return r;
1779                 if (r == 0)
1780                         return -EOPNOTSUPP;
1781         }
1782
1783         /* If the cookie number isn't kept, then we know that no reply
1784          * is expected */
1785         if (!cookie && !m->sealed)
1786                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1787
1788         r = bus_seal_message(bus, m, 0);
1789         if (r < 0)
1790                 return r;
1791
1792         /* Remarshall if we have to. This will possibly unref the
1793          * message and place a replacement in m */
1794         r = bus_remarshal_message(bus, &m);
1795         if (r < 0)
1796                 return r;
1797
1798         /* If this is a reply and no reply was requested, then let's
1799          * suppress this, if we can */
1800         if (m->dont_send)
1801                 goto finish;
1802
1803         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1804                 size_t idx = 0;
1805
1806                 r = bus_write_message(bus, m, hint_sync_call, &idx);
1807                 if (r < 0) {
1808                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1809                                 bus_enter_closing(bus);
1810                                 return -ECONNRESET;
1811                         }
1812
1813                         return r;
1814                 }
1815
1816                 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1817                         /* Wasn't fully written. So let's remember how
1818                          * much was written. Note that the first entry
1819                          * of the wqueue array is always allocated so
1820                          * that we always can remember how much was
1821                          * written. */
1822                         bus->wqueue[0] = sd_bus_message_ref(m);
1823                         bus->wqueue_size = 1;
1824                         bus->windex = idx;
1825                 }
1826
1827         } else {
1828                 /* Just append it to the queue. */
1829
1830                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1831                         return -ENOBUFS;
1832
1833                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1834                         return -ENOMEM;
1835
1836                 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1837         }
1838
1839 finish:
1840         if (cookie)
1841                 *cookie = BUS_MESSAGE_COOKIE(m);
1842
1843         return 1;
1844 }
1845
1846 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1847         return bus_send_internal(bus, m, cookie, false);
1848 }
1849
1850 #if 0 /// UNNEEDED by elogind
1851 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1852         int r;
1853
1854         assert_return(m, -EINVAL);
1855
1856         if (!bus)
1857                 bus = m->bus;
1858
1859         assert_return(!bus_pid_changed(bus), -ECHILD);
1860
1861         if (!BUS_IS_OPEN(bus->state))
1862                 return -ENOTCONN;
1863
1864         if (!streq_ptr(m->destination, destination)) {
1865
1866                 if (!destination)
1867                         return -EEXIST;
1868
1869                 r = sd_bus_message_set_destination(m, destination);
1870                 if (r < 0)
1871                         return r;
1872         }
1873
1874         return sd_bus_send(bus, m, cookie);
1875 }
1876 #endif // 0
1877
1878 static usec_t calc_elapse(uint64_t usec) {
1879         if (usec == (uint64_t) -1)
1880                 return 0;
1881
1882         return now(CLOCK_MONOTONIC) + usec;
1883 }
1884
1885 static int timeout_compare(const void *a, const void *b) {
1886         const struct reply_callback *x = a, *y = b;
1887
1888         if (x->timeout != 0 && y->timeout == 0)
1889                 return -1;
1890
1891         if (x->timeout == 0 && y->timeout != 0)
1892                 return 1;
1893
1894         if (x->timeout < y->timeout)
1895                 return -1;
1896
1897         if (x->timeout > y->timeout)
1898                 return 1;
1899
1900         return 0;
1901 }
1902
1903 _public_ int sd_bus_call_async(
1904                 sd_bus *bus,
1905                 sd_bus_slot **slot,
1906                 sd_bus_message *_m,
1907                 sd_bus_message_handler_t callback,
1908                 void *userdata,
1909                 uint64_t usec) {
1910
1911         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1912         _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1913         int r;
1914
1915         assert_return(m, -EINVAL);
1916         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1917         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1918         assert_return(callback, -EINVAL);
1919
1920         if (!bus)
1921                 bus = m->bus;
1922
1923         assert_return(!bus_pid_changed(bus), -ECHILD);
1924         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1925
1926         if (!BUS_IS_OPEN(bus->state))
1927                 return -ENOTCONN;
1928
1929         r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1930         if (r < 0)
1931                 return r;
1932
1933         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1934         if (r < 0)
1935                 return r;
1936
1937         r = bus_seal_message(bus, m, usec);
1938         if (r < 0)
1939                 return r;
1940
1941         r = bus_remarshal_message(bus, &m);
1942         if (r < 0)
1943                 return r;
1944
1945         s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1946         if (!s)
1947                 return -ENOMEM;
1948
1949         s->reply_callback.callback = callback;
1950
1951         s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1952         r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1953         if (r < 0) {
1954                 s->reply_callback.cookie = 0;
1955                 return r;
1956         }
1957
1958         s->reply_callback.timeout = calc_elapse(m->timeout);
1959         if (s->reply_callback.timeout != 0) {
1960                 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1961                 if (r < 0) {
1962                         s->reply_callback.timeout = 0;
1963                         return r;
1964                 }
1965         }
1966
1967         r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1968         if (r < 0)
1969                 return r;
1970
1971         if (slot)
1972                 *slot = s;
1973         s = NULL;
1974
1975         return r;
1976 }
1977
1978 int bus_ensure_running(sd_bus *bus) {
1979         int r;
1980
1981         assert(bus);
1982
1983         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1984                 return -ENOTCONN;
1985         if (bus->state == BUS_RUNNING)
1986                 return 1;
1987
1988         for (;;) {
1989                 r = sd_bus_process(bus, NULL);
1990                 if (r < 0)
1991                         return r;
1992                 if (bus->state == BUS_RUNNING)
1993                         return 1;
1994                 if (r > 0)
1995                         continue;
1996
1997                 r = sd_bus_wait(bus, (uint64_t) -1);
1998                 if (r < 0)
1999                         return r;
2000         }
2001 }
2002
2003 _public_ int sd_bus_call(
2004                 sd_bus *bus,
2005                 sd_bus_message *_m,
2006                 uint64_t usec,
2007                 sd_bus_error *error,
2008                 sd_bus_message **reply) {
2009
2010         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2011         usec_t timeout;
2012         uint64_t cookie;
2013         unsigned i;
2014         int r;
2015
2016         bus_assert_return(m, -EINVAL, error);
2017         bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2018         bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2019         bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2020
2021         if (!bus)
2022                 bus = m->bus;
2023
2024         bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2025         bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2026
2027         if (!BUS_IS_OPEN(bus->state)) {
2028                 r = -ENOTCONN;
2029                 goto fail;
2030         }
2031
2032         r = bus_ensure_running(bus);
2033         if (r < 0)
2034                 goto fail;
2035
2036         i = bus->rqueue_size;
2037
2038         r = bus_seal_message(bus, m, usec);
2039         if (r < 0)
2040                 goto fail;
2041
2042         r = bus_remarshal_message(bus, &m);
2043         if (r < 0)
2044                 goto fail;
2045
2046         r = bus_send_internal(bus, m, &cookie, true);
2047         if (r < 0)
2048                 goto fail;
2049
2050         timeout = calc_elapse(m->timeout);
2051
2052         for (;;) {
2053                 usec_t left;
2054
2055                 while (i < bus->rqueue_size) {
2056                         sd_bus_message *incoming = NULL;
2057
2058                         incoming = bus->rqueue[i];
2059
2060                         if (incoming->reply_cookie == cookie) {
2061                                 /* Found a match! */
2062
2063                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2064                                 bus->rqueue_size--;
2065                                 log_debug_bus_message(incoming);
2066
2067                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2068
2069                                         if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2070                                                 if (reply)
2071                                                         *reply = incoming;
2072                                                 else
2073                                                         sd_bus_message_unref(incoming);
2074
2075                                                 return 1;
2076                                         }
2077
2078                                         r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2079                                         sd_bus_message_unref(incoming);
2080                                         return r;
2081
2082                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2083                                         r = sd_bus_error_copy(error, &incoming->error);
2084                                 sd_bus_message_unref(incoming);
2085                                 return r;
2086                                 } else {
2087                                         r = -EIO;
2088                                         goto fail;
2089                                 }
2090
2091                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2092                                    bus->unique_name &&
2093                                    incoming->sender &&
2094                                    streq(bus->unique_name, incoming->sender)) {
2095
2096                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2097                                 bus->rqueue_size--;
2098
2099                                 /* Our own message? Somebody is trying
2100                                  * to send its own client a message,
2101                                  * let's not dead-lock, let's fail
2102                                  * immediately. */
2103
2104                                 sd_bus_message_unref(incoming);
2105                                 r = -ELOOP;
2106                                 goto fail;
2107                         }
2108
2109                         /* Try to read more, right-away */
2110                         i++;
2111                 }
2112
2113                 r = bus_read_message(bus, false, 0);
2114                 if (r < 0) {
2115                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2116                                 bus_enter_closing(bus);
2117                                 r = -ECONNRESET;
2118                         }
2119
2120                         goto fail;
2121                 }
2122                 if (r > 0)
2123                         continue;
2124
2125                 if (timeout > 0) {
2126                         usec_t n;
2127
2128                         n = now(CLOCK_MONOTONIC);
2129                         if (n >= timeout) {
2130                                 r = -ETIMEDOUT;
2131                                 goto fail;
2132                         }
2133
2134                         left = timeout - n;
2135                 } else
2136                         left = (uint64_t) -1;
2137
2138                 r = bus_poll(bus, true, left);
2139                 if (r < 0)
2140                         goto fail;
2141                 if (r == 0) {
2142                         r = -ETIMEDOUT;
2143                         goto fail;
2144                 }
2145
2146                 r = dispatch_wqueue(bus);
2147                 if (r < 0) {
2148                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2149                                 bus_enter_closing(bus);
2150                                 r = -ECONNRESET;
2151                         }
2152
2153                         goto fail;
2154                 }
2155         }
2156
2157 fail:
2158         return sd_bus_error_set_errno(error, r);
2159 }
2160
2161 #if 0 /// UNNEEDED by elogind
2162 _public_ int sd_bus_get_fd(sd_bus *bus) {
2163
2164         assert_return(bus, -EINVAL);
2165         assert_return(bus->input_fd == bus->output_fd, -EPERM);
2166         assert_return(!bus_pid_changed(bus), -ECHILD);
2167
2168         return bus->input_fd;
2169 }
2170 #endif // 0
2171
2172 _public_ int sd_bus_get_events(sd_bus *bus) {
2173         int flags = 0;
2174
2175         assert_return(bus, -EINVAL);
2176         assert_return(!bus_pid_changed(bus), -ECHILD);
2177
2178         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2179                 return -ENOTCONN;
2180
2181         if (bus->state == BUS_OPENING)
2182                 flags |= POLLOUT;
2183         else if (bus->state == BUS_AUTHENTICATING) {
2184
2185                 if (bus_socket_auth_needs_write(bus))
2186                         flags |= POLLOUT;
2187
2188                 flags |= POLLIN;
2189
2190         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2191                 if (bus->rqueue_size <= 0)
2192                         flags |= POLLIN;
2193                 if (bus->wqueue_size > 0)
2194                         flags |= POLLOUT;
2195         }
2196
2197         return flags;
2198 }
2199
2200 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2201         struct reply_callback *c;
2202
2203         assert_return(bus, -EINVAL);
2204         assert_return(timeout_usec, -EINVAL);
2205         assert_return(!bus_pid_changed(bus), -ECHILD);
2206
2207         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2208                 return -ENOTCONN;
2209
2210         if (bus->track_queue) {
2211                 *timeout_usec = 0;
2212                 return 1;
2213         }
2214
2215         if (bus->state == BUS_CLOSING) {
2216                 *timeout_usec = 0;
2217                 return 1;
2218         }
2219
2220         if (bus->state == BUS_AUTHENTICATING) {
2221                 *timeout_usec = bus->auth_timeout;
2222                 return 1;
2223         }
2224
2225         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2226                 *timeout_usec = (uint64_t) -1;
2227                 return 0;
2228         }
2229
2230         if (bus->rqueue_size > 0) {
2231                 *timeout_usec = 0;
2232                 return 1;
2233         }
2234
2235         c = prioq_peek(bus->reply_callbacks_prioq);
2236         if (!c) {
2237                 *timeout_usec = (uint64_t) -1;
2238                 return 0;
2239         }
2240
2241         if (c->timeout == 0) {
2242                 *timeout_usec = (uint64_t) -1;
2243                 return 0;
2244         }
2245
2246         *timeout_usec = c->timeout;
2247         return 1;
2248 }
2249
2250 static int process_timeout(sd_bus *bus) {
2251         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2252         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2253         struct reply_callback *c;
2254         sd_bus_slot *slot;
2255         usec_t n;
2256         int r;
2257
2258         assert(bus);
2259
2260         c = prioq_peek(bus->reply_callbacks_prioq);
2261         if (!c)
2262                 return 0;
2263
2264         n = now(CLOCK_MONOTONIC);
2265         if (c->timeout > n)
2266                 return 0;
2267
2268         r = bus_message_new_synthetic_error(
2269                         bus,
2270                         c->cookie,
2271                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2272                         &m);
2273         if (r < 0)
2274                 return r;
2275
2276         r = bus_seal_synthetic_message(bus, m);
2277         if (r < 0)
2278                 return r;
2279
2280         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2281         c->timeout = 0;
2282
2283         ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2284         c->cookie = 0;
2285
2286         slot = container_of(c, sd_bus_slot, reply_callback);
2287
2288         bus->iteration_counter ++;
2289
2290         bus->current_message = m;
2291         bus->current_slot = sd_bus_slot_ref(slot);
2292         bus->current_handler = c->callback;
2293         bus->current_userdata = slot->userdata;
2294         r = c->callback(m, slot->userdata, &error_buffer);
2295         bus->current_userdata = NULL;
2296         bus->current_handler = NULL;
2297         bus->current_slot = NULL;
2298         bus->current_message = NULL;
2299
2300         if (slot->floating) {
2301                 bus_slot_disconnect(slot);
2302                 sd_bus_slot_unref(slot);
2303         }
2304
2305         sd_bus_slot_unref(slot);
2306
2307         return bus_maybe_reply_error(m, r, &error_buffer);
2308 }
2309
2310 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2311         assert(bus);
2312         assert(m);
2313
2314         if (bus->state != BUS_HELLO)
2315                 return 0;
2316
2317         /* Let's make sure the first message on the bus is the HELLO
2318          * reply. But note that we don't actually parse the message
2319          * here (we leave that to the usual handling), we just verify
2320          * we don't let any earlier msg through. */
2321
2322         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2323             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2324                 return -EIO;
2325
2326         if (m->reply_cookie != 1)
2327                 return -EIO;
2328
2329         return 0;
2330 }
2331
2332 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2333         _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2334         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2335         struct reply_callback *c;
2336         sd_bus_slot *slot;
2337         int r;
2338
2339         assert(bus);
2340         assert(m);
2341
2342         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2343             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2344                 return 0;
2345
2346         if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2347                 return 0;
2348
2349         if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2350                 return 0;
2351
2352         c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2353         if (!c)
2354                 return 0;
2355
2356         c->cookie = 0;
2357
2358         slot = container_of(c, sd_bus_slot, reply_callback);
2359
2360         if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2361
2362                 /* If the reply contained a file descriptor which we
2363                  * didn't want we pass an error instead. */
2364
2365                 r = bus_message_new_synthetic_error(
2366                                 bus,
2367                                 m->reply_cookie,
2368                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2369                                 &synthetic_reply);
2370                 if (r < 0)
2371                         return r;
2372
2373                 /* Copy over original timestamp */
2374                 synthetic_reply->realtime = m->realtime;
2375                 synthetic_reply->monotonic = m->monotonic;
2376                 synthetic_reply->seqnum = m->seqnum;
2377
2378                 r = bus_seal_synthetic_message(bus, synthetic_reply);
2379                 if (r < 0)
2380                         return r;
2381
2382                 m = synthetic_reply;
2383         } else {
2384                 r = sd_bus_message_rewind(m, true);
2385                 if (r < 0)
2386                         return r;
2387         }
2388
2389         if (c->timeout != 0) {
2390                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2391                 c->timeout = 0;
2392         }
2393
2394         bus->current_slot = sd_bus_slot_ref(slot);
2395         bus->current_handler = c->callback;
2396         bus->current_userdata = slot->userdata;
2397         r = c->callback(m, slot->userdata, &error_buffer);
2398         bus->current_userdata = NULL;
2399         bus->current_handler = NULL;
2400         bus->current_slot = NULL;
2401
2402         if (slot->floating) {
2403                 bus_slot_disconnect(slot);
2404                 sd_bus_slot_unref(slot);
2405         }
2406
2407         sd_bus_slot_unref(slot);
2408
2409         return bus_maybe_reply_error(m, r, &error_buffer);
2410 }
2411
2412 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2413         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2414         struct filter_callback *l;
2415         int r;
2416
2417         assert(bus);
2418         assert(m);
2419
2420         do {
2421                 bus->filter_callbacks_modified = false;
2422
2423                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2424                         sd_bus_slot *slot;
2425
2426                         if (bus->filter_callbacks_modified)
2427                                 break;
2428
2429                         /* Don't run this more than once per iteration */
2430                         if (l->last_iteration == bus->iteration_counter)
2431                                 continue;
2432
2433                         l->last_iteration = bus->iteration_counter;
2434
2435                         r = sd_bus_message_rewind(m, true);
2436                         if (r < 0)
2437                                 return r;
2438
2439                         slot = container_of(l, sd_bus_slot, filter_callback);
2440
2441                         bus->current_slot = sd_bus_slot_ref(slot);
2442                         bus->current_handler = l->callback;
2443                         bus->current_userdata = slot->userdata;
2444                         r = l->callback(m, slot->userdata, &error_buffer);
2445                         bus->current_userdata = NULL;
2446                         bus->current_handler = NULL;
2447                         bus->current_slot = sd_bus_slot_unref(slot);
2448
2449                         r = bus_maybe_reply_error(m, r, &error_buffer);
2450                         if (r != 0)
2451                                 return r;
2452
2453                 }
2454
2455         } while (bus->filter_callbacks_modified);
2456
2457         return 0;
2458 }
2459
2460 static int process_match(sd_bus *bus, sd_bus_message *m) {
2461         int r;
2462
2463         assert(bus);
2464         assert(m);
2465
2466         do {
2467                 bus->match_callbacks_modified = false;
2468
2469                 r = bus_match_run(bus, &bus->match_callbacks, m);
2470                 if (r != 0)
2471                         return r;
2472
2473         } while (bus->match_callbacks_modified);
2474
2475         return 0;
2476 }
2477
2478 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2479         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2480         int r;
2481
2482         assert(bus);
2483         assert(m);
2484
2485         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2486                 return 0;
2487
2488         if (bus->manual_peer_interface)
2489                 return 0;
2490
2491         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2492                 return 0;
2493
2494         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2495                 return 0;
2496
2497         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2498                 return 1;
2499
2500         if (streq_ptr(m->member, "Ping"))
2501                 r = sd_bus_message_new_method_return(m, &reply);
2502         else if (streq_ptr(m->member, "GetMachineId")) {
2503                 sd_id128_t id;
2504                 char sid[33];
2505
2506                 r = sd_id128_get_machine(&id);
2507                 if (r < 0)
2508                         return r;
2509
2510                 r = sd_bus_message_new_method_return(m, &reply);
2511                 if (r < 0)
2512                         return r;
2513
2514                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2515         } else {
2516                 r = sd_bus_message_new_method_errorf(
2517                                 m, &reply,
2518                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2519                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2520         }
2521
2522         if (r < 0)
2523                 return r;
2524
2525         r = sd_bus_send(bus, reply, NULL);
2526         if (r < 0)
2527                 return r;
2528
2529         return 1;
2530 }
2531
2532 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2533         assert(bus);
2534         assert(m);
2535
2536         /* If we got a message with a file descriptor which we didn't
2537          * want to accept, then let's drop it. How can this even
2538          * happen? For example, when the kernel queues a message into
2539          * an activatable names's queue which allows fds, and then is
2540          * delivered to us later even though we ourselves did not
2541          * negotiate it. */
2542
2543         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2544                 return 0;
2545
2546         if (m->n_fds <= 0)
2547                 return 0;
2548
2549         if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2550                 return 0;
2551
2552         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2553                 return 1; /* just eat it up */
2554
2555         return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2556 }
2557
2558 static int process_message(sd_bus *bus, sd_bus_message *m) {
2559         int r;
2560
2561         assert(bus);
2562         assert(m);
2563
2564         bus->current_message = m;
2565         bus->iteration_counter++;
2566
2567         log_debug_bus_message(m);
2568
2569         r = process_hello(bus, m);
2570         if (r != 0)
2571                 goto finish;
2572
2573         r = process_reply(bus, m);
2574         if (r != 0)
2575                 goto finish;
2576
2577         r = process_fd_check(bus, m);
2578         if (r != 0)
2579                 goto finish;
2580
2581         r = process_filter(bus, m);
2582         if (r != 0)
2583                 goto finish;
2584
2585         r = process_match(bus, m);
2586         if (r != 0)
2587                 goto finish;
2588
2589         r = process_builtin(bus, m);
2590         if (r != 0)
2591                 goto finish;
2592
2593         r = bus_process_object(bus, m);
2594
2595 finish:
2596         bus->current_message = NULL;
2597         return r;
2598 }
2599
2600 static int dispatch_track(sd_bus *bus) {
2601         assert(bus);
2602
2603         if (!bus->track_queue)
2604                 return 0;
2605
2606         bus_track_dispatch(bus->track_queue);
2607         return 1;
2608 }
2609
2610 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2611         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2612         int r;
2613
2614         assert(bus);
2615         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2616
2617         r = process_timeout(bus);
2618         if (r != 0)
2619                 goto null_message;
2620
2621         r = dispatch_wqueue(bus);
2622         if (r != 0)
2623                 goto null_message;
2624
2625         r = dispatch_track(bus);
2626         if (r != 0)
2627                 goto null_message;
2628
2629         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2630         if (r < 0)
2631                 return r;
2632         if (!m)
2633                 goto null_message;
2634
2635         r = process_message(bus, m);
2636         if (r != 0)
2637                 goto null_message;
2638
2639         if (ret) {
2640                 r = sd_bus_message_rewind(m, true);
2641                 if (r < 0)
2642                         return r;
2643
2644                 *ret = m;
2645                 m = NULL;
2646                 return 1;
2647         }
2648
2649         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2650
2651                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2652                           strna(sd_bus_message_get_sender(m)),
2653                           strna(sd_bus_message_get_path(m)),
2654                           strna(sd_bus_message_get_interface(m)),
2655                           strna(sd_bus_message_get_member(m)));
2656
2657                 r = sd_bus_reply_method_errorf(
2658                                 m,
2659                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2660                                 "Unknown object '%s'.", m->path);
2661                 if (r < 0)
2662                         return r;
2663         }
2664
2665         return 1;
2666
2667 null_message:
2668         if (r >= 0 && ret)
2669                 *ret = NULL;
2670
2671         return r;
2672 }
2673
2674 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2675         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2676         struct reply_callback *c;
2677         int r;
2678
2679         assert(bus);
2680         assert(bus->state == BUS_CLOSING);
2681
2682         c = ordered_hashmap_first(bus->reply_callbacks);
2683         if (c) {
2684                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2685                 sd_bus_slot *slot;
2686
2687                 /* First, fail all outstanding method calls */
2688                 r = bus_message_new_synthetic_error(
2689                                 bus,
2690                                 c->cookie,
2691                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2692                                 &m);
2693                 if (r < 0)
2694                         return r;
2695
2696                 r = bus_seal_synthetic_message(bus, m);
2697                 if (r < 0)
2698                         return r;
2699
2700                 if (c->timeout != 0) {
2701                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2702                         c->timeout = 0;
2703                 }
2704
2705                 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2706                 c->cookie = 0;
2707
2708                 slot = container_of(c, sd_bus_slot, reply_callback);
2709
2710                 bus->iteration_counter++;
2711
2712                 bus->current_message = m;
2713                 bus->current_slot = sd_bus_slot_ref(slot);
2714                 bus->current_handler = c->callback;
2715                 bus->current_userdata = slot->userdata;
2716                 r = c->callback(m, slot->userdata, &error_buffer);
2717                 bus->current_userdata = NULL;
2718                 bus->current_handler = NULL;
2719                 bus->current_slot = NULL;
2720                 bus->current_message = NULL;
2721
2722                 if (slot->floating) {
2723                         bus_slot_disconnect(slot);
2724                         sd_bus_slot_unref(slot);
2725                 }
2726
2727                 sd_bus_slot_unref(slot);
2728
2729                 return bus_maybe_reply_error(m, r, &error_buffer);
2730         }
2731
2732         /* Then, synthesize a Disconnected message */
2733         r = sd_bus_message_new_signal(
2734                         bus,
2735                         &m,
2736                         "/org/freedesktop/DBus/Local",
2737                         "org.freedesktop.DBus.Local",
2738                         "Disconnected");
2739         if (r < 0)
2740                 return r;
2741
2742         bus_message_set_sender_local(bus, m);
2743
2744         r = bus_seal_synthetic_message(bus, m);
2745         if (r < 0)
2746                 return r;
2747
2748         sd_bus_close(bus);
2749
2750         bus->current_message = m;
2751         bus->iteration_counter++;
2752
2753         r = process_filter(bus, m);
2754         if (r != 0)
2755                 goto finish;
2756
2757         r = process_match(bus, m);
2758         if (r != 0)
2759                 goto finish;
2760
2761         if (ret) {
2762                 *ret = m;
2763                 m = NULL;
2764         }
2765
2766         r = 1;
2767
2768 finish:
2769         bus->current_message = NULL;
2770
2771         return r;
2772 }
2773
2774 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2775         BUS_DONT_DESTROY(bus);
2776         int r;
2777
2778         /* Returns 0 when we didn't do anything. This should cause the
2779          * caller to invoke sd_bus_wait() before returning the next
2780          * time. Returns > 0 when we did something, which possibly
2781          * means *ret is filled in with an unprocessed message. */
2782
2783         assert_return(bus, -EINVAL);
2784         assert_return(!bus_pid_changed(bus), -ECHILD);
2785
2786         /* We don't allow recursively invoking sd_bus_process(). */
2787         assert_return(!bus->current_message, -EBUSY);
2788         assert(!bus->current_slot);
2789
2790         switch (bus->state) {
2791
2792         case BUS_UNSET:
2793                 return -ENOTCONN;
2794
2795         case BUS_CLOSED:
2796                 return -ECONNRESET;
2797
2798         case BUS_OPENING:
2799                 r = bus_socket_process_opening(bus);
2800                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2801                         bus_enter_closing(bus);
2802                         r = 1;
2803                 } else if (r < 0)
2804                         return r;
2805                 if (ret)
2806                         *ret = NULL;
2807                 return r;
2808
2809         case BUS_AUTHENTICATING:
2810                 r = bus_socket_process_authenticating(bus);
2811                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2812                         bus_enter_closing(bus);
2813                         r = 1;
2814                 } else if (r < 0)
2815                         return r;
2816
2817                 if (ret)
2818                         *ret = NULL;
2819
2820                 return r;
2821
2822         case BUS_RUNNING:
2823         case BUS_HELLO:
2824                 r = process_running(bus, hint_priority, priority, ret);
2825                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2826                         bus_enter_closing(bus);
2827                         r = 1;
2828
2829                         if (ret)
2830                                 *ret = NULL;
2831                 }
2832
2833                 return r;
2834
2835         case BUS_CLOSING:
2836                 return process_closing(bus, ret);
2837         }
2838
2839         assert_not_reached("Unknown state");
2840 }
2841
2842 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2843         return bus_process_internal(bus, false, 0, ret);
2844 }
2845
2846 #if 0 /// UNNEEDED by elogind
2847 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2848         return bus_process_internal(bus, true, priority, ret);
2849 }
2850 #endif // 0
2851
2852 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2853         struct pollfd p[2] = {};
2854         int r, e, n;
2855         struct timespec ts;
2856         usec_t m = USEC_INFINITY;
2857
2858         assert(bus);
2859
2860         if (bus->state == BUS_CLOSING)
2861                 return 1;
2862
2863         if (!BUS_IS_OPEN(bus->state))
2864                 return -ENOTCONN;
2865
2866         e = sd_bus_get_events(bus);
2867         if (e < 0)
2868                 return e;
2869
2870         if (need_more)
2871                 /* The caller really needs some more data, he doesn't
2872                  * care about what's already read, or any timeouts
2873                  * except its own. */
2874                 e |= POLLIN;
2875         else {
2876                 usec_t until;
2877                 /* The caller wants to process if there's something to
2878                  * process, but doesn't care otherwise */
2879
2880                 r = sd_bus_get_timeout(bus, &until);
2881                 if (r < 0)
2882                         return r;
2883                 if (r > 0) {
2884                         usec_t nw;
2885                         nw = now(CLOCK_MONOTONIC);
2886                         m = until > nw ? until - nw : 0;
2887                 }
2888         }
2889
2890         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2891                 m = timeout_usec;
2892
2893         p[0].fd = bus->input_fd;
2894         if (bus->output_fd == bus->input_fd) {
2895                 p[0].events = e;
2896                 n = 1;
2897         } else {
2898                 p[0].events = e & POLLIN;
2899                 p[1].fd = bus->output_fd;
2900                 p[1].events = e & POLLOUT;
2901                 n = 2;
2902         }
2903
2904         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2905         if (r < 0)
2906                 return -errno;
2907
2908         return r > 0 ? 1 : 0;
2909 }
2910
2911 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2912
2913         assert_return(bus, -EINVAL);
2914         assert_return(!bus_pid_changed(bus), -ECHILD);
2915
2916         if (bus->state == BUS_CLOSING)
2917                 return 0;
2918
2919         if (!BUS_IS_OPEN(bus->state))
2920                 return -ENOTCONN;
2921
2922         if (bus->rqueue_size > 0)
2923                 return 0;
2924
2925         return bus_poll(bus, false, timeout_usec);
2926 }
2927
2928 _public_ int sd_bus_flush(sd_bus *bus) {
2929         int r;
2930
2931         assert_return(bus, -EINVAL);
2932         assert_return(!bus_pid_changed(bus), -ECHILD);
2933
2934         if (bus->state == BUS_CLOSING)
2935                 return 0;
2936
2937         if (!BUS_IS_OPEN(bus->state))
2938                 return -ENOTCONN;
2939
2940         r = bus_ensure_running(bus);
2941         if (r < 0)
2942                 return r;
2943
2944         if (bus->wqueue_size <= 0)
2945                 return 0;
2946
2947         for (;;) {
2948                 r = dispatch_wqueue(bus);
2949                 if (r < 0) {
2950                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2951                                 bus_enter_closing(bus);
2952                                 return -ECONNRESET;
2953                         }
2954
2955                         return r;
2956                 }
2957
2958                 if (bus->wqueue_size <= 0)
2959                         return 0;
2960
2961                 r = bus_poll(bus, false, (uint64_t) -1);
2962                 if (r < 0)
2963                         return r;
2964         }
2965 }
2966
2967 #if 0 /// UNNEEDED by elogind
2968 _public_ int sd_bus_add_filter(
2969                 sd_bus *bus,
2970                 sd_bus_slot **slot,
2971                 sd_bus_message_handler_t callback,
2972                 void *userdata) {
2973
2974         sd_bus_slot *s;
2975
2976         assert_return(bus, -EINVAL);
2977         assert_return(callback, -EINVAL);
2978         assert_return(!bus_pid_changed(bus), -ECHILD);
2979
2980         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2981         if (!s)
2982                 return -ENOMEM;
2983
2984         s->filter_callback.callback = callback;
2985
2986         bus->filter_callbacks_modified = true;
2987         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2988
2989         if (slot)
2990                 *slot = s;
2991
2992         return 0;
2993 }
2994 #endif // 0
2995
2996 _public_ int sd_bus_add_match(
2997                 sd_bus *bus,
2998                 sd_bus_slot **slot,
2999                 const char *match,
3000                 sd_bus_message_handler_t callback,
3001                 void *userdata) {
3002
3003         struct bus_match_component *components = NULL;
3004         unsigned n_components = 0;
3005         sd_bus_slot *s = NULL;
3006         int r = 0;
3007
3008         assert_return(bus, -EINVAL);
3009         assert_return(match, -EINVAL);
3010         assert_return(!bus_pid_changed(bus), -ECHILD);
3011
3012         r = bus_match_parse(match, &components, &n_components);
3013         if (r < 0)
3014                 goto finish;
3015
3016         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3017         if (!s) {
3018                 r = -ENOMEM;
3019                 goto finish;
3020         }
3021
3022         s->match_callback.callback = callback;
3023         s->match_callback.cookie = ++bus->match_cookie;
3024
3025         if (bus->bus_client) {
3026                 enum bus_match_scope scope;
3027
3028                 scope = bus_match_get_scope(components, n_components);
3029
3030                 /* Do not install server-side matches for matches
3031                  * against the local service, interface or bus
3032                  * path. */
3033                 if (scope != BUS_MATCH_LOCAL) {
3034
3035                         if (!bus->is_kernel) {
3036                                 /* When this is not a kernel transport, we
3037                                  * store the original match string, so that we
3038                                  * can use it to remove the match again */
3039
3040                                 s->match_callback.match_string = strdup(match);
3041                                 if (!s->match_callback.match_string) {
3042                                         r = -ENOMEM;
3043                                         goto finish;
3044                                 }
3045                         }
3046
3047                         r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3048                         if (r < 0)
3049                                 goto finish;
3050
3051                         s->match_added = true;
3052                 }
3053         }
3054
3055         bus->match_callbacks_modified = true;
3056         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3057         if (r < 0)
3058                 goto finish;
3059
3060         if (slot)
3061                 *slot = s;
3062         s = NULL;
3063
3064 finish:
3065         bus_match_parse_free(components, n_components);
3066         sd_bus_slot_unref(s);
3067
3068         return r;
3069 }
3070
3071 #if 0 /// UNNEEDED by elogind
3072 int bus_remove_match_by_string(
3073                 sd_bus *bus,
3074                 const char *match,
3075                 sd_bus_message_handler_t callback,
3076                 void *userdata) {
3077
3078         struct bus_match_component *components = NULL;
3079         unsigned n_components = 0;
3080         struct match_callback *c;
3081         int r = 0;
3082
3083         assert_return(bus, -EINVAL);
3084         assert_return(match, -EINVAL);
3085         assert_return(!bus_pid_changed(bus), -ECHILD);
3086
3087         r = bus_match_parse(match, &components, &n_components);
3088         if (r < 0)
3089                 goto finish;
3090
3091         r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3092         if (r <= 0)
3093                 goto finish;
3094
3095         sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3096
3097 finish:
3098         bus_match_parse_free(components, n_components);
3099
3100         return r;
3101 }
3102 #endif // 0
3103
3104 bool bus_pid_changed(sd_bus *bus) {
3105         assert(bus);
3106
3107         /* We don't support people creating a bus connection and
3108          * keeping it around over a fork(). Let's complain. */
3109
3110         return bus->original_pid != getpid();
3111 }
3112
3113 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3114         sd_bus *bus = userdata;
3115         int r;
3116
3117         assert(bus);
3118
3119         r = sd_bus_process(bus, NULL);
3120         if (r < 0)
3121                 return r;
3122
3123         return 1;
3124 }
3125
3126 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3127         sd_bus *bus = userdata;
3128         int r;
3129
3130         assert(bus);
3131
3132         r = sd_bus_process(bus, NULL);
3133         if (r < 0)
3134                 return r;
3135
3136         return 1;
3137 }
3138
3139 static int prepare_callback(sd_event_source *s, void *userdata) {
3140         sd_bus *bus = userdata;
3141         int r, e;
3142         usec_t until;
3143
3144         assert(s);
3145         assert(bus);
3146
3147         e = sd_bus_get_events(bus);
3148         if (e < 0)
3149                 return e;
3150
3151         if (bus->output_fd != bus->input_fd) {
3152
3153                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3154                 if (r < 0)
3155                         return r;
3156
3157                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3158                 if (r < 0)
3159                         return r;
3160         } else {
3161                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3162                 if (r < 0)
3163                         return r;
3164         }
3165
3166         r = sd_bus_get_timeout(bus, &until);
3167         if (r < 0)
3168                 return r;
3169         if (r > 0) {
3170                 int j;
3171
3172                 j = sd_event_source_set_time(bus->time_event_source, until);
3173                 if (j < 0)
3174                         return j;
3175         }
3176
3177         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3178         if (r < 0)
3179                 return r;
3180
3181         return 1;
3182 }
3183
3184 static int quit_callback(sd_event_source *event, void *userdata) {
3185         sd_bus *bus = userdata;
3186
3187         assert(event);
3188
3189         sd_bus_flush(bus);
3190         sd_bus_close(bus);
3191
3192         return 1;
3193 }
3194
3195 static int attach_io_events(sd_bus *bus) {
3196         int r;
3197
3198         assert(bus);
3199
3200         if (bus->input_fd < 0)
3201                 return 0;
3202
3203         if (!bus->event)
3204                 return 0;
3205
3206         if (!bus->input_io_event_source) {
3207                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3208                 if (r < 0)
3209                         return r;
3210
3211                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3212                 if (r < 0)
3213                         return r;
3214
3215                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3216                 if (r < 0)
3217                         return r;
3218
3219                 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3220         } else
3221                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3222
3223         if (r < 0)
3224                 return r;
3225
3226         if (bus->output_fd != bus->input_fd) {
3227                 assert(bus->output_fd >= 0);
3228
3229                 if (!bus->output_io_event_source) {
3230                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3231                         if (r < 0)
3232                                 return r;
3233
3234                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3235                         if (r < 0)
3236                                 return r;
3237
3238                         r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3239                 } else
3240                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3241
3242                 if (r < 0)
3243                         return r;
3244         }
3245
3246         return 0;
3247 }
3248
3249 static void detach_io_events(sd_bus *bus) {
3250         assert(bus);
3251
3252         if (bus->input_io_event_source) {
3253                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3254                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3255         }
3256
3257         if (bus->output_io_event_source) {
3258                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3259                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3260         }
3261 }
3262
3263 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3264         int r;
3265
3266         assert_return(bus, -EINVAL);
3267         assert_return(!bus->event, -EBUSY);
3268
3269         assert(!bus->input_io_event_source);
3270         assert(!bus->output_io_event_source);
3271         assert(!bus->time_event_source);
3272
3273         if (event)
3274                 bus->event = sd_event_ref(event);
3275         else  {
3276                 r = sd_event_default(&bus->event);
3277                 if (r < 0)
3278                         return r;
3279         }
3280
3281         bus->event_priority = priority;
3282
3283         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3284         if (r < 0)
3285                 goto fail;
3286
3287         r = sd_event_source_set_priority(bus->time_event_source, priority);
3288         if (r < 0)
3289                 goto fail;
3290
3291         r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3292         if (r < 0)
3293                 goto fail;
3294
3295         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3296         if (r < 0)
3297                 goto fail;
3298
3299         r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3300         if (r < 0)
3301                 goto fail;
3302
3303         r = attach_io_events(bus);
3304         if (r < 0)
3305                 goto fail;
3306
3307         return 0;
3308
3309 fail:
3310         sd_bus_detach_event(bus);
3311         return r;
3312 }
3313
3314 _public_ int sd_bus_detach_event(sd_bus *bus) {
3315         assert_return(bus, -EINVAL);
3316
3317         if (!bus->event)
3318                 return 0;
3319
3320         detach_io_events(bus);
3321
3322         if (bus->time_event_source) {
3323                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3324                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3325         }
3326
3327         if (bus->quit_event_source) {
3328                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3329                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3330         }
3331
3332         bus->event = sd_event_unref(bus->event);
3333         return 1;
3334 }
3335
3336 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3337         assert_return(bus, NULL);
3338
3339         return bus->event;
3340 }
3341
3342 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3343         assert_return(bus, NULL);
3344
3345         return bus->current_message;
3346 }
3347
3348 #if 0 /// UNNEEDED by elogind
3349 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3350         assert_return(bus, NULL);
3351
3352         return bus->current_slot;
3353 }
3354 #endif // 0
3355
3356 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3357         assert_return(bus, NULL);
3358
3359         return bus->current_handler;
3360 }
3361
3362 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3363         assert_return(bus, NULL);
3364
3365         return bus->current_userdata;
3366 }
3367
3368 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3369         sd_bus *b = NULL;
3370         int r;
3371
3372         assert(bus_open);
3373         assert(default_bus);
3374
3375         if (!ret)
3376                 return !!*default_bus;
3377
3378         if (*default_bus) {
3379                 *ret = sd_bus_ref(*default_bus);
3380                 return 0;
3381         }
3382
3383         r = bus_open(&b);
3384         if (r < 0)
3385                 return r;
3386
3387         b->default_bus_ptr = default_bus;
3388         b->tid = gettid();
3389         *default_bus = b;
3390
3391         *ret = b;
3392         return 1;
3393 }
3394
3395 _public_ int sd_bus_default_system(sd_bus **ret) {
3396         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3397 }
3398
3399
3400 _public_ int sd_bus_default_user(sd_bus **ret) {
3401 /// elogind does not support user buses
3402 #if 0
3403         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3404 #else
3405         return sd_bus_default_system(ret);
3406 #endif // 0
3407 }
3408
3409 _public_ int sd_bus_default(sd_bus **ret) {
3410
3411         const char *e;
3412
3413         /* Let's try our best to reuse another cached connection. If
3414          * the starter bus type is set, connect via our normal
3415          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3416          * we can share the connection with the user/system default
3417          * bus. */
3418
3419         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3420         if (e) {
3421                 if (streq(e, "system"))
3422                         return sd_bus_default_system(ret);
3423 /// elogind does not support systemd units
3424 #if 0
3425                 else if (STR_IN_SET(e, "user", "session"))
3426                         return sd_bus_default_user(ret);
3427 #endif // 0
3428         }
3429
3430         /* No type is specified, so we have not other option than to
3431          * use the starter address if it is set. */
3432
3433         e = secure_getenv("DBUS_STARTER_ADDRESS");
3434         if (e) {
3435
3436                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3437         }
3438
3439         /* Finally, if nothing is set use the cached connection for
3440          * the right scope */
3441
3442 /// elogind does not support systemd units
3443 #if 0
3444         if (cg_pid_get_owner_uid(0, NULL) >= 0)
3445                 return sd_bus_default_user(ret);
3446         else
3447 #endif // 0
3448         return sd_bus_default_system(ret);
3449 }
3450
3451 #if 0 /// UNNEEDED by elogind
3452 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3453         assert_return(b, -EINVAL);
3454         assert_return(tid, -EINVAL);
3455         assert_return(!bus_pid_changed(b), -ECHILD);
3456
3457         if (b->tid != 0) {
3458                 *tid = b->tid;
3459                 return 0;
3460         }
3461
3462         if (b->event)
3463                 return sd_event_get_tid(b->event, tid);
3464
3465         return -ENXIO;
3466 }
3467
3468 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3469         _cleanup_free_ char *e = NULL;
3470         char *ret;
3471
3472         assert_return(object_path_is_valid(prefix), -EINVAL);
3473         assert_return(external_id, -EINVAL);
3474         assert_return(ret_path, -EINVAL);
3475
3476         e = bus_label_escape(external_id);
3477         if (!e)
3478                 return -ENOMEM;
3479
3480         ret = strjoin(prefix, "/", e, NULL);
3481         if (!ret)
3482                 return -ENOMEM;
3483
3484         *ret_path = ret;
3485         return 0;
3486 }
3487
3488 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3489         const char *e;
3490         char *ret;
3491
3492         assert_return(object_path_is_valid(path), -EINVAL);
3493         assert_return(object_path_is_valid(prefix), -EINVAL);
3494         assert_return(external_id, -EINVAL);
3495
3496         e = object_path_startswith(path, prefix);
3497         if (!e) {
3498                 *external_id = NULL;
3499                 return 0;
3500         }
3501
3502         ret = bus_label_unescape(e);
3503         if (!ret)
3504                 return -ENOMEM;
3505
3506         *external_id = ret;
3507         return 1;
3508 }
3509
3510 _public_ int sd_bus_path_encode_many(char **out, const char *path_template, ...) {
3511         _cleanup_strv_free_ char **labels = NULL;
3512         char *path, *path_pos, **label_pos;
3513         const char *sep, *template_pos;
3514         size_t path_length;
3515         va_list list;
3516         int r;
3517
3518         assert_return(out, -EINVAL);
3519         assert_return(path_template, -EINVAL);
3520
3521         path_length = strlen(path_template);
3522
3523         va_start(list, path_template);
3524         for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
3525                 const char *arg;
3526                 char *label;
3527
3528                 arg = va_arg(list, const char *);
3529                 if (!arg) {
3530                         va_end(list);
3531                         return -EINVAL;
3532                 }
3533
3534                 label = bus_label_escape(arg);
3535                 if (!label) {
3536                         va_end(list);
3537                         return -ENOMEM;
3538                 }
3539
3540                 r = strv_consume(&labels, label);
3541                 if (r < 0) {
3542                         va_end(list);
3543                         return r;
3544                 }
3545
3546                 /* add label length, but account for the format character */
3547                 path_length += strlen(label) - 1;
3548         }
3549         va_end(list);
3550
3551         path = malloc(path_length + 1);
3552         if (!path)
3553                 return -ENOMEM;
3554
3555         path_pos = path;
3556         label_pos = labels;
3557
3558         for (template_pos = path_template; *template_pos; ) {
3559                 sep = strchrnul(template_pos, '%');
3560                 path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
3561                 if (!*sep)
3562                         break;
3563
3564                 path_pos = stpcpy(path_pos, *label_pos++);
3565                 template_pos = sep + 1;
3566         }
3567
3568         *path_pos = 0;
3569         *out = path;
3570         return 0;
3571 }
3572
3573 _public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
3574         _cleanup_strv_free_ char **labels = NULL;
3575         const char *template_pos, *path_pos;
3576         char **label_pos;
3577         va_list list;
3578         int r;
3579
3580         /*
3581          * This decodes an object-path based on a template argument. The
3582          * template consists of a verbatim path, optionally including special
3583          * directives:
3584          *
3585          *   - Each occurrence of '%' in the template matches an arbitrary
3586          *     substring of a label in the given path. At most one such
3587          *     directive is allowed per label. For each such directive, the
3588          *     caller must provide an output parameter (char **) via va_arg. If
3589          *     NULL is passed, the given label is verified, but not returned.
3590          *     For each matched label, the *decoded* label is stored in the
3591          *     passed output argument, and the caller is responsible to free
3592          *     it. Note that the output arguments are only modified if the
3593          *     actualy path matched the template. Otherwise, they're left
3594          *     untouched.
3595          *
3596          * This function returns <0 on error, 0 if the path does not match the
3597          * template, 1 if it matched.
3598          */
3599
3600         assert_return(path, -EINVAL);
3601         assert_return(path_template, -EINVAL);
3602
3603         path_pos = path;
3604
3605         for (template_pos = path_template; *template_pos; ) {
3606                 const char *sep;
3607                 size_t length;
3608                 char *label;
3609
3610                 /* verify everything until the next '%' matches verbatim */
3611                 sep = strchrnul(template_pos, '%');
3612                 length = sep - template_pos;
3613                 if (strncmp(path_pos, template_pos, length))
3614                         return 0;
3615
3616                 path_pos += length;
3617                 template_pos += length;
3618
3619                 if (!*template_pos)
3620                         break;
3621
3622                 /* We found the next '%' character. Everything up until here
3623                  * matched. We now skip ahead to the end of this label and make
3624                  * sure it matches the tail of the label in the path. Then we
3625                  * decode the string in-between and save it for later use. */
3626
3627                 ++template_pos; /* skip over '%' */
3628
3629                 sep = strchrnul(template_pos, '/');
3630                 length = sep - template_pos; /* length of suffix to match verbatim */
3631
3632                 /* verify the suffixes match */
3633                 sep = strchrnul(path_pos, '/');
3634                 if (sep - path_pos < (ssize_t)length ||
3635                     strncmp(sep - length, template_pos, length))
3636                         return 0;
3637
3638                 template_pos += length; /* skip over matched label */
3639                 length = sep - path_pos - length; /* length of sub-label to decode */
3640
3641                 /* store unescaped label for later use */
3642                 label = bus_label_unescape_n(path_pos, length);
3643                 if (!label)
3644                         return -ENOMEM;
3645
3646                 r = strv_consume(&labels, label);
3647                 if (r < 0)
3648                         return r;
3649
3650                 path_pos = sep; /* skip decoded label and suffix */
3651         }
3652
3653         /* end of template must match end of path */
3654         if (*path_pos)
3655                 return 0;
3656
3657         /* copy the labels over to the caller */
3658         va_start(list, path_template);
3659         for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
3660                 char **arg;
3661
3662                 arg = va_arg(list, char **);
3663                 if (arg)
3664                         *arg = *label_pos;
3665                 else
3666                         free(*label_pos);
3667         }
3668         va_end(list);
3669
3670         free(labels);
3671         labels = NULL;
3672         return 1;
3673 }
3674
3675 _public_ int sd_bus_try_close(sd_bus *bus) {
3676         int r;
3677
3678         assert_return(bus, -EINVAL);
3679         assert_return(!bus_pid_changed(bus), -ECHILD);
3680
3681         if (!bus->is_kernel)
3682                 return -EOPNOTSUPP;
3683
3684         if (!BUS_IS_OPEN(bus->state))
3685                 return -ENOTCONN;
3686
3687         if (bus->rqueue_size > 0)
3688                 return -EBUSY;
3689
3690         if (bus->wqueue_size > 0)
3691                 return -EBUSY;
3692
3693         r = bus_kernel_try_close(bus);
3694         if (r < 0)
3695                 return r;
3696
3697         sd_bus_close(bus);
3698         return 0;
3699 }
3700
3701 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3702         assert_return(bus, -EINVAL);
3703         assert_return(description, -EINVAL);
3704         assert_return(bus->description, -ENXIO);
3705         assert_return(!bus_pid_changed(bus), -ECHILD);
3706
3707         *description = bus->description;
3708         return 0;
3709 }
3710 #endif // 0
3711
3712 int bus_get_root_path(sd_bus *bus) {
3713         int r;
3714
3715         if (bus->cgroup_root)
3716                 return 0;
3717
3718         r = cg_get_root_path(&bus->cgroup_root);
3719         if (r == -ENOENT) {
3720                 bus->cgroup_root = strdup("/");
3721                 if (!bus->cgroup_root)
3722                         return -ENOMEM;
3723
3724                 r = 0;
3725         }
3726
3727         return r;
3728 }
3729
3730 #if 0 /// UNNEEDED by elogind
3731 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3732         int r;
3733
3734         assert_return(bus, -EINVAL);
3735         assert_return(scope, -EINVAL);
3736         assert_return(!bus_pid_changed(bus), -ECHILD);
3737
3738         if (bus->is_kernel) {
3739                 _cleanup_free_ char *n = NULL;
3740                 const char *dash;
3741
3742                 r = bus_kernel_get_bus_name(bus, &n);
3743                 if (r < 0)
3744                         return r;
3745
3746                 if (streq(n, "0-system")) {
3747                         *scope = "system";
3748                         return 0;
3749                 }
3750
3751                 dash = strchr(n, '-');
3752                 if (streq_ptr(dash, "-user")) {
3753                         *scope = "user";
3754                         return 0;
3755                 }
3756         }
3757
3758         if (bus->is_user) {
3759                 *scope = "user";
3760                 return 0;
3761         }
3762
3763         if (bus->is_system) {
3764                 *scope = "system";
3765                 return 0;
3766         }
3767
3768         return -ENODATA;
3769 }
3770
3771 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3772
3773         assert_return(bus, -EINVAL);
3774         assert_return(address, -EINVAL);
3775         assert_return(!bus_pid_changed(bus), -ECHILD);
3776
3777         if (bus->address) {
3778                 *address = bus->address;
3779                 return 0;
3780         }
3781
3782         return -ENODATA;
3783 }
3784
3785 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3786         assert_return(bus, -EINVAL);
3787         assert_return(mask, -EINVAL);
3788         assert_return(!bus_pid_changed(bus), -ECHILD);
3789
3790         *mask = bus->creds_mask;
3791         return 0;
3792 }
3793
3794 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3795         assert_return(bus, -EINVAL);
3796         assert_return(!bus_pid_changed(bus), -ECHILD);
3797
3798         return bus->bus_client;
3799 }
3800
3801 _public_ int sd_bus_is_server(sd_bus *bus) {
3802         assert_return(bus, -EINVAL);
3803         assert_return(!bus_pid_changed(bus), -ECHILD);
3804
3805         return bus->is_server;
3806 }
3807
3808 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3809         assert_return(bus, -EINVAL);
3810         assert_return(!bus_pid_changed(bus), -ECHILD);
3811
3812         return bus->anonymous_auth;
3813 }
3814
3815 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3816         assert_return(bus, -EINVAL);
3817         assert_return(!bus_pid_changed(bus), -ECHILD);
3818
3819         return bus->trusted;
3820 }
3821
3822 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3823         assert_return(bus, -EINVAL);
3824         assert_return(!bus_pid_changed(bus), -ECHILD);
3825
3826         return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3827 }
3828
3829 static void flush_close(sd_bus *bus) {
3830         if (!bus)
3831                 return;
3832
3833         /* Flushes and closes the specified bus. We take a ref before,
3834          * to ensure the flushing does not cause the bus to be
3835          * unreferenced. */
3836
3837         sd_bus_flush_close_unref(sd_bus_ref(bus));
3838 }
3839
3840 _public_ void sd_bus_default_flush_close(void) {
3841         flush_close(default_starter_bus);
3842         flush_close(default_user_bus);
3843         flush_close(default_system_bus);
3844 }
3845 #endif // 0