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

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