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

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <endian.h>
  23 #include <netdb.h>
  24 #include <poll.h>
  25 #include <pthread.h>
  26 #include <stdlib.h>
  27 #include <sys/mman.h>
  28 #include <unistd.h>
  29
  30 #include "sd-bus.h"
  31
  32 #include "alloc-util.h"
  33 #include "bus-container.h"
  34 #include "bus-control.h"
  35 #include "bus-internal.h"
  36 #include "bus-kernel.h"
  37 #include "bus-label.h"
  38 #include "bus-message.h"
  39 #include "bus-objects.h"
  40 #include "bus-protocol.h"
  41 #include "bus-slot.h"
  42 #include "bus-socket.h"
  43 #include "bus-track.h"
  44 #include "bus-type.h"
  45 #include "bus-util.h"
  46 #include "cgroup-util.h"
  47 #include "def.h"
  48 #include "fd-util.h"
  49 #include "hexdecoct.h"
  50 #include "hostname-util.h"
  51 #include "macro.h"
  52 #include "missing.h"
  53 #include "parse-util.h"
  54 #include "string-util.h"
  55 #include "strv.h"
  56 #include "util.h"
  57
  58 #define log_debug_bus_message(m)                                         \
  59         do {                                                             \
  60                 sd_bus_message *_mm = (m);                               \
  61                 log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", \
  62                           bus_message_type_to_string(_mm->header->type), \
  63                           strna(sd_bus_message_get_sender(_mm)),         \
  64                           strna(sd_bus_message_get_destination(_mm)),    \
  65                           strna(sd_bus_message_get_path(_mm)),           \
  66                           strna(sd_bus_message_get_interface(_mm)),      \
  67                           strna(sd_bus_message_get_member(_mm)),         \
  68                           BUS_MESSAGE_COOKIE(_mm),                       \
  69                           _mm->reply_cookie,                             \
  70                           strna(_mm->error.message));                    \
  71         } while (false)
  72
  73 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
  74 static int attach_io_events(sd_bus *b);
  75 static void detach_io_events(sd_bus *b);
  76
  77 static thread_local sd_bus *default_system_bus = NULL;
  78 #if 0 /// UNNEEDED by elogind
  79 static thread_local sd_bus *default_user_bus = NULL;
  80 #endif // 0
  81 static thread_local sd_bus *default_starter_bus = NULL;
  82
  83 static void bus_close_fds(sd_bus *b) {
  84         assert(b);
  85
  86         detach_io_events(b);
  87
  88         if (b->input_fd != b->output_fd)
  89                 safe_close(b->output_fd);
  90         b->output_fd = b->input_fd = safe_close(b->input_fd);
  91 }
  92
  93 static void bus_reset_queues(sd_bus *b) {
  94         assert(b);
  95
  96         while (b->rqueue_size > 0)
  97                 sd_bus_message_unref(b->rqueue[--b->rqueue_size]);
  98
  99         b->rqueue = mfree(b->rqueue);
 100         b->rqueue_allocated = 0;
 101
 102         while (b->wqueue_size > 0)
 103                 sd_bus_message_unref(b->wqueue[--b->wqueue_size]);
 104
 105         b->wqueue = mfree(b->wqueue);
 106         b->wqueue_allocated = 0;
 107 }
 108
 109 static void bus_free(sd_bus *b) {
 110         sd_bus_slot *s;
 111
 112         assert(b);
 113         assert(!b->track_queue);
 114
 115         b->state = BUS_CLOSED;
 116
 117         sd_bus_detach_event(b);
 118
 119         while ((s = b->slots)) {
 120                 /* At this point only floating slots can still be
 121                  * around, because the non-floating ones keep a
 122                  * reference to the bus, and we thus couldn't be
 123                  * destructing right now... We forcibly disconnect the
 124                  * slots here, so that they still can be referenced by
 125                  * apps, but are dead. */
 126
 127                 assert(s->floating);
 128                 bus_slot_disconnect(s);
 129                 sd_bus_slot_unref(s);
 130         }
 131
 132         if (b->default_bus_ptr)
 133                 *b->default_bus_ptr = NULL;
 134
 135         bus_close_fds(b);
 136
 137         if (b->kdbus_buffer)
 138                 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
 139
 140         free(b->label);
 141         free(b->rbuffer);
 142         free(b->unique_name);
 143         free(b->auth_buffer);
 144         free(b->address);
 145         free(b->kernel);
 146         free(b->machine);
 147         free(b->fake_label);
 148         free(b->cgroup_root);
 149         free(b->description);
 150
 151         free(b->exec_path);
 152         strv_free(b->exec_argv);
 153
 154         close_many(b->fds, b->n_fds);
 155         free(b->fds);
 156
 157         bus_reset_queues(b);
 158
 159         ordered_hashmap_free_free(b->reply_callbacks);
 160         prioq_free(b->reply_callbacks_prioq);
 161
 162         assert(b->match_callbacks.type == BUS_MATCH_ROOT);
 163         bus_match_free(&b->match_callbacks);
 164
 165         hashmap_free_free(b->vtable_methods);
 166         hashmap_free_free(b->vtable_properties);
 167
 168         assert(hashmap_isempty(b->nodes));
 169         hashmap_free(b->nodes);
 170
 171         bus_kernel_flush_memfd(b);
 172
 173         assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
 174
 175         free(b);
 176 }
 177
 178 _public_ int sd_bus_new(sd_bus **ret) {
 179         sd_bus *r;
 180
 181         assert_return(ret, -EINVAL);
 182
 183         r = new0(sd_bus, 1);
 184         if (!r)
 185                 return -ENOMEM;
 186
 187         r->n_ref = REFCNT_INIT;
 188         r->input_fd = r->output_fd = -1;
 189         r->message_version = 1;
 190         r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
 191         r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
 192         r->attach_flags |= KDBUS_ATTACH_NAMES;
 193         r->original_pid = getpid();
 194
 195         assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
 196
 197         /* We guarantee that wqueue always has space for at least one
 198          * entry */
 199         if (!GREEDY_REALLOC(r->wqueue, r->wqueue_allocated, 1)) {
 200                 free(r);
 201                 return -ENOMEM;
 202         }
 203
 204         *ret = r;
 205         return 0;
 206 }
 207
 208 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
 209         char *a;
 210
 211         assert_return(bus, -EINVAL);
 212         assert_return(bus->state == BUS_UNSET, -EPERM);
 213         assert_return(address, -EINVAL);
 214         assert_return(!bus_pid_changed(bus), -ECHILD);
 215
 216         a = strdup(address);
 217         if (!a)
 218                 return -ENOMEM;
 219
 220         free(bus->address);
 221         bus->address = a;
 222
 223         return 0;
 224 }
 225
 226 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
 227         assert_return(bus, -EINVAL);
 228         assert_return(bus->state == BUS_UNSET, -EPERM);
 229         assert_return(input_fd >= 0, -EBADF);
 230         assert_return(output_fd >= 0, -EBADF);
 231         assert_return(!bus_pid_changed(bus), -ECHILD);
 232
 233         bus->input_fd = input_fd;
 234         bus->output_fd = output_fd;
 235         return 0;
 236 }
 237
 238 #if 0 /// UNNEEDED by elogind
 239 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
 240         char *p, **a;
 241
 242         assert_return(bus, -EINVAL);
 243         assert_return(bus->state == BUS_UNSET, -EPERM);
 244         assert_return(path, -EINVAL);
 245         assert_return(!strv_isempty(argv), -EINVAL);
 246         assert_return(!bus_pid_changed(bus), -ECHILD);
 247
 248         p = strdup(path);
 249         if (!p)
 250                 return -ENOMEM;
 251
 252         a = strv_copy(argv);
 253         if (!a) {
 254                 free(p);
 255                 return -ENOMEM;
 256         }
 257
 258         free(bus->exec_path);
 259         strv_free(bus->exec_argv);
 260
 261         bus->exec_path = p;
 262         bus->exec_argv = a;
 263
 264         return 0;
 265 }
 266
 267 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
 268         assert_return(bus, -EINVAL);
 269         assert_return(bus->state == BUS_UNSET, -EPERM);
 270         assert_return(!bus_pid_changed(bus), -ECHILD);
 271
 272         bus->bus_client = !!b;
 273         return 0;
 274 }
 275
 276 _public_ int sd_bus_set_monitor(sd_bus *bus, int b) {
 277         assert_return(bus, -EINVAL);
 278         assert_return(bus->state == BUS_UNSET, -EPERM);
 279         assert_return(!bus_pid_changed(bus), -ECHILD);
 280
 281         SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b);
 282         return 0;
 283 }
 284
 285 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
 286         assert_return(bus, -EINVAL);
 287         assert_return(bus->state == BUS_UNSET, -EPERM);
 288         assert_return(!bus_pid_changed(bus), -ECHILD);
 289
 290         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
 291         return 0;
 292 }
 293
 294 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {
 295         uint64_t new_flags;
 296         assert_return(bus, -EINVAL);
 297         assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
 298         assert_return(!bus_pid_changed(bus), -ECHILD);
 299
 300         new_flags = bus->attach_flags;
 301         SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b);
 302
 303         if (bus->attach_flags == new_flags)
 304                 return 0;
 305
 306         bus->attach_flags = new_flags;
 307         if (bus->state != BUS_UNSET && bus->is_kernel)
 308                 bus_kernel_realize_attach_flags(bus);
 309
 310         return 0;
 311 }
 312
 313 _public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) {
 314         uint64_t new_flags;
 315
 316         assert_return(bus, -EINVAL);
 317         assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL);
 318         assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM);
 319         assert_return(!bus_pid_changed(bus), -ECHILD);
 320
 321         if (b)
 322                 bus->creds_mask |= mask;
 323         else
 324                 bus->creds_mask &= ~mask;
 325
 326         /* The well knowns we need unconditionally, so that matches can work */
 327         bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
 328
 329         /* Make sure we don't lose the timestamp flag */
 330         new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask);
 331         if (bus->attach_flags == new_flags)
 332                 return 0;
 333
 334         bus->attach_flags = new_flags;
 335         if (bus->state != BUS_UNSET && bus->is_kernel)
 336                 bus_kernel_realize_attach_flags(bus);
 337
 338         return 0;
 339 }
 340
 341 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
 342         assert_return(bus, -EINVAL);
 343         assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
 344         assert_return(bus->state == BUS_UNSET, -EPERM);
 345         assert_return(!bus_pid_changed(bus), -ECHILD);
 346
 347         bus->is_server = !!b;
 348         bus->server_id = server_id;
 349         return 0;
 350 }
 351
 352 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
 353         assert_return(bus, -EINVAL);
 354         assert_return(bus->state == BUS_UNSET, -EPERM);
 355         assert_return(!bus_pid_changed(bus), -ECHILD);
 356
 357         bus->anonymous_auth = !!b;
 358         return 0;
 359 }
 360
 361 _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
 362         assert_return(bus, -EINVAL);
 363         assert_return(bus->state == BUS_UNSET, -EPERM);
 364         assert_return(!bus_pid_changed(bus), -ECHILD);
 365
 366         bus->trusted = !!b;
 367         return 0;
 368 }
 369
 370 _public_ int sd_bus_set_description(sd_bus *bus, const char *description) {
 371         assert_return(bus, -EINVAL);
 372         assert_return(bus->state == BUS_UNSET, -EPERM);
 373         assert_return(!bus_pid_changed(bus), -ECHILD);
 374
 375         return free_and_strdup(&bus->description, description);
 376 }
 377 #endif // 0
 378
 379 _public_ int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b) {
 380         assert_return(bus, -EINVAL);
 381         assert_return(!bus_pid_changed(bus), -ECHILD);
 382
 383         bus->allow_interactive_authorization = !!b;
 384         return 0;
 385 }
 386
 387 #if 0 /// UNNEEDED by elogind
 388 _public_ int sd_bus_get_allow_interactive_authorization(sd_bus *bus) {
 389         assert_return(bus, -EINVAL);
 390         assert_return(!bus_pid_changed(bus), -ECHILD);
 391
 392         return bus->allow_interactive_authorization;
 393 }
 394 #endif // 0
 395
 396 static int hello_callback(sd_bus_message *reply, void *userdata, sd_bus_error *error) {
 397         const char *s;
 398         sd_bus *bus;
 399         int r;
 400
 401         assert(reply);
 402         bus = reply->bus;
 403         assert(bus);
 404         assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
 405
 406         r = sd_bus_message_get_errno(reply);
 407         if (r > 0)
 408                 return -r;
 409
 410         r = sd_bus_message_read(reply, "s", &s);
 411         if (r < 0)
 412                 return r;
 413
 414         if (!service_name_is_valid(s) || s[0] != ':')
 415                 return -EBADMSG;
 416
 417         bus->unique_name = strdup(s);
 418         if (!bus->unique_name)
 419                 return -ENOMEM;
 420
 421         if (bus->state == BUS_HELLO)
 422                 bus->state = BUS_RUNNING;
 423
 424         return 1;
 425 }
 426
 427 static int bus_send_hello(sd_bus *bus) {
 428         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 429         int r;
 430
 431         assert(bus);
 432
 433         if (!bus->bus_client || bus->is_kernel)
 434                 return 0;
 435
 436         r = sd_bus_message_new_method_call(
 437                         bus,
 438                         &m,
 439                         "org.freedesktop.DBus",
 440                         "/org/freedesktop/DBus",
 441                         "org.freedesktop.DBus",
 442                         "Hello");
 443         if (r < 0)
 444                 return r;
 445
 446         return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0);
 447 }
 448
 449 int bus_start_running(sd_bus *bus) {
 450         assert(bus);
 451
 452         if (bus->bus_client && !bus->is_kernel) {
 453                 bus->state = BUS_HELLO;
 454                 return 1;
 455         }
 456
 457         bus->state = BUS_RUNNING;
 458         return 1;
 459 }
 460
 461 static int parse_address_key(const char **p, const char *key, char **value) {
 462         size_t l, n = 0, allocated = 0;
 463         const char *a;
 464         char *r = NULL;
 465
 466         assert(p);
 467         assert(*p);
 468         assert(value);
 469
 470         if (key) {
 471                 l = strlen(key);
 472                 if (strncmp(*p, key, l) != 0)
 473                         return 0;
 474
 475                 if ((*p)[l] != '=')
 476                         return 0;
 477
 478                 if (*value)
 479                         return -EINVAL;
 480
 481                 a = *p + l + 1;
 482         } else
 483                 a = *p;
 484
 485         while (*a != ';' && *a != ',' && *a != 0) {
 486                 char c;
 487
 488                 if (*a == '%') {
 489                         int x, y;
 490
 491                         x = unhexchar(a[1]);
 492                         if (x < 0) {
 493                                 free(r);
 494                                 return x;
 495                         }
 496
 497                         y = unhexchar(a[2]);
 498                         if (y < 0) {
 499                                 free(r);
 500                                 return y;
 501                         }
 502
 503                         c = (char) ((x << 4) | y);
 504                         a += 3;
 505                 } else {
 506                         c = *a;
 507                         a++;
 508                 }
 509
 510                 if (!GREEDY_REALLOC(r, allocated, n + 2))
 511                         return -ENOMEM;
 512
 513                 r[n++] = c;
 514         }
 515
 516         if (!r) {
 517                 r = strdup("");
 518                 if (!r)
 519                         return -ENOMEM;
 520         } else
 521                 r[n] = 0;
 522
 523         if (*a == ',')
 524                 a++;
 525
 526         *p = a;
 527
 528         free(*value);
 529         *value = r;
 530
 531         return 1;
 532 }
 533
 534 static void skip_address_key(const char **p) {
 535         assert(p);
 536         assert(*p);
 537
 538         *p += strcspn(*p, ",");
 539
 540         if (**p == ',')
 541                 (*p) ++;
 542 }
 543
 544 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
 545         _cleanup_free_ char *path = NULL, *abstract = NULL;
 546         size_t l;
 547         int r;
 548
 549         assert(b);
 550         assert(p);
 551         assert(*p);
 552         assert(guid);
 553
 554         while (**p != 0 && **p != ';') {
 555                 r = parse_address_key(p, "guid", guid);
 556                 if (r < 0)
 557                         return r;
 558                 else if (r > 0)
 559                         continue;
 560
 561                 r = parse_address_key(p, "path", &path);
 562                 if (r < 0)
 563                         return r;
 564                 else if (r > 0)
 565                         continue;
 566
 567                 r = parse_address_key(p, "abstract", &abstract);
 568                 if (r < 0)
 569                         return r;
 570                 else if (r > 0)
 571                         continue;
 572
 573                 skip_address_key(p);
 574         }
 575
 576         if (!path && !abstract)
 577                 return -EINVAL;
 578
 579         if (path && abstract)
 580                 return -EINVAL;
 581
 582         if (path) {
 583                 l = strlen(path);
 584                 if (l > sizeof(b->sockaddr.un.sun_path))
 585                         return -E2BIG;
 586
 587                 b->sockaddr.un.sun_family = AF_UNIX;
 588                 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
 589                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
 590         } else if (abstract) {
 591                 l = strlen(abstract);
 592                 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
 593                         return -E2BIG;
 594
 595                 b->sockaddr.un.sun_family = AF_UNIX;
 596                 b->sockaddr.un.sun_path[0] = 0;
 597                 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
 598                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
 599         }
 600
 601         return 0;
 602 }
 603
 604 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
 605         _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
 606         int r;
 607         struct addrinfo *result, hints = {
 608                 .ai_socktype = SOCK_STREAM,
 609                 .ai_flags = AI_ADDRCONFIG,
 610         };
 611
 612         assert(b);
 613         assert(p);
 614         assert(*p);
 615         assert(guid);
 616
 617         while (**p != 0 && **p != ';') {
 618                 r = parse_address_key(p, "guid", guid);
 619                 if (r < 0)
 620                         return r;
 621                 else if (r > 0)
 622                         continue;
 623
 624                 r = parse_address_key(p, "host", &host);
 625                 if (r < 0)
 626                         return r;
 627                 else if (r > 0)
 628                         continue;
 629
 630                 r = parse_address_key(p, "port", &port);
 631                 if (r < 0)
 632                         return r;
 633                 else if (r > 0)
 634                         continue;
 635
 636                 r = parse_address_key(p, "family", &family);
 637                 if (r < 0)
 638                         return r;
 639                 else if (r > 0)
 640                         continue;
 641
 642                 skip_address_key(p);
 643         }
 644
 645         if (!host || !port)
 646                 return -EINVAL;
 647
 648         if (family) {
 649                 if (streq(family, "ipv4"))
 650                         hints.ai_family = AF_INET;
 651                 else if (streq(family, "ipv6"))
 652                         hints.ai_family = AF_INET6;
 653                 else
 654                         return -EINVAL;
 655         }
 656
 657         r = getaddrinfo(host, port, &hints, &result);
 658         if (r == EAI_SYSTEM)
 659                 return -errno;
 660         else if (r != 0)
 661                 return -EADDRNOTAVAIL;
 662
 663         memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
 664         b->sockaddr_size = result->ai_addrlen;
 665
 666         freeaddrinfo(result);
 667
 668         return 0;
 669 }
 670
 671 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
 672         char *path = NULL;
 673         unsigned n_argv = 0, j;
 674         char **argv = NULL;
 675         size_t allocated = 0;
 676         int r;
 677
 678         assert(b);
 679         assert(p);
 680         assert(*p);
 681         assert(guid);
 682
 683         while (**p != 0 && **p != ';') {
 684                 r = parse_address_key(p, "guid", guid);
 685                 if (r < 0)
 686                         goto fail;
 687                 else if (r > 0)
 688                         continue;
 689
 690                 r = parse_address_key(p, "path", &path);
 691                 if (r < 0)
 692                         goto fail;
 693                 else if (r > 0)
 694                         continue;
 695
 696                 if (startswith(*p, "argv")) {
 697                         unsigned ul;
 698
 699                         errno = 0;
 700                         ul = strtoul(*p + 4, (char**) p, 10);
 701                         if (errno > 0 || **p != '=' || ul > 256) {
 702                                 r = -EINVAL;
 703                                 goto fail;
 704                         }
 705
 706                         (*p) ++;
 707
 708                         if (ul >= n_argv) {
 709                                 if (!GREEDY_REALLOC0(argv, allocated, ul + 2)) {
 710                                         r = -ENOMEM;
 711                                         goto fail;
 712                                 }
 713
 714                                 n_argv = ul + 1;
 715                         }
 716
 717                         r = parse_address_key(p, NULL, argv + ul);
 718                         if (r < 0)
 719                                 goto fail;
 720
 721                         continue;
 722                 }
 723
 724                 skip_address_key(p);
 725         }
 726
 727         if (!path) {
 728                 r = -EINVAL;
 729                 goto fail;
 730         }
 731
 732         /* Make sure there are no holes in the array, with the
 733          * exception of argv[0] */
 734         for (j = 1; j < n_argv; j++)
 735                 if (!argv[j]) {
 736                         r = -EINVAL;
 737                         goto fail;
 738                 }
 739
 740         if (argv && argv[0] == NULL) {
 741                 argv[0] = strdup(path);
 742                 if (!argv[0]) {
 743                         r = -ENOMEM;
 744                         goto fail;
 745                 }
 746         }
 747
 748         b->exec_path = path;
 749         b->exec_argv = argv;
 750         return 0;
 751
 752 fail:
 753         for (j = 0; j < n_argv; j++)
 754                 free(argv[j]);
 755
 756         free(argv);
 757         free(path);
 758         return r;
 759 }
 760
 761 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
 762         _cleanup_free_ char *path = NULL;
 763         int r;
 764
 765         assert(b);
 766         assert(p);
 767         assert(*p);
 768         assert(guid);
 769
 770         while (**p != 0 && **p != ';') {
 771                 r = parse_address_key(p, "guid", guid);
 772                 if (r < 0)
 773                         return r;
 774                 else if (r > 0)
 775                         continue;
 776
 777                 r = parse_address_key(p, "path", &path);
 778                 if (r < 0)
 779                         return r;
 780                 else if (r > 0)
 781                         continue;
 782
 783                 skip_address_key(p);
 784         }
 785
 786         if (!path)
 787                 return -EINVAL;
 788
 789         free(b->kernel);
 790         b->kernel = path;
 791         path = NULL;
 792
 793         return 0;
 794 }
 795
 796 static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) {
 797         _cleanup_free_ char *machine = NULL, *pid = NULL;
 798         int r;
 799
 800         assert(b);
 801         assert(p);
 802         assert(*p);
 803         assert(guid);
 804
 805         while (**p != 0 && **p != ';') {
 806                 r = parse_address_key(p, "guid", guid);
 807                 if (r < 0)
 808                         return r;
 809                 else if (r > 0)
 810                         continue;
 811
 812                 r = parse_address_key(p, "machine", &machine);
 813                 if (r < 0)
 814                         return r;
 815                 else if (r > 0)
 816                         continue;
 817
 818                 r = parse_address_key(p, "pid", &pid);
 819                 if (r < 0)
 820                         return r;
 821                 else if (r > 0)
 822                         continue;
 823
 824                 skip_address_key(p);
 825         }
 826
 827         if (!machine == !pid)
 828                 return -EINVAL;
 829
 830         if (machine) {
 831                 if (!machine_name_is_valid(machine))
 832                         return -EINVAL;
 833
 834                 free(b->machine);
 835                 b->machine = machine;
 836                 machine = NULL;
 837         } else {
 838                 b->machine = mfree(b->machine);
 839         }
 840
 841         if (pid) {
 842                 r = parse_pid(pid, &b->nspid);
 843                 if (r < 0)
 844                         return r;
 845         } else
 846                 b->nspid = 0;
 847
 848         b->sockaddr.un.sun_family = AF_UNIX;
 849         strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
 850         b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
 851
 852         return 0;
 853 }
 854
 855 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
 856         _cleanup_free_ char *machine = NULL, *pid = NULL;
 857         int r;
 858
 859         assert(b);
 860         assert(p);
 861         assert(*p);
 862         assert(guid);
 863
 864         while (**p != 0 && **p != ';') {
 865                 r = parse_address_key(p, "guid", guid);
 866                 if (r < 0)
 867                         return r;
 868                 else if (r > 0)
 869                         continue;
 870
 871                 r = parse_address_key(p, "machine", &machine);
 872                 if (r < 0)
 873                         return r;
 874                 else if (r > 0)
 875                         continue;
 876
 877                 r = parse_address_key(p, "pid", &pid);
 878                 if (r < 0)
 879                         return r;
 880                 else if (r > 0)
 881                         continue;
 882
 883                 skip_address_key(p);
 884         }
 885
 886         if (!machine == !pid)
 887                 return -EINVAL;
 888
 889         if (machine) {
 890                 if (!machine_name_is_valid(machine))
 891                         return -EINVAL;
 892
 893                 free(b->machine);
 894                 b->machine = machine;
 895                 machine = NULL;
 896         } else {
 897                 b->machine = mfree(b->machine);
 898         }
 899
 900         if (pid) {
 901                 r = parse_pid(pid, &b->nspid);
 902                 if (r < 0)
 903                         return r;
 904         } else
 905                 b->nspid = 0;
 906
 907         r = free_and_strdup(&b->kernel, "/sys/fs/kdbus/0-system/bus");
 908         if (r < 0)
 909                 return r;
 910
 911         return 0;
 912 }
 913
 914 static void bus_reset_parsed_address(sd_bus *b) {
 915         assert(b);
 916
 917         zero(b->sockaddr);
 918         b->sockaddr_size = 0;
 919         b->exec_argv = strv_free(b->exec_argv);
 920         b->exec_path = mfree(b->exec_path);
 921         b->server_id = SD_ID128_NULL;
 922         b->kernel = mfree(b->kernel);
 923         b->machine = mfree(b->machine);
 924         b->nspid = 0;
 925 }
 926
 927 static int bus_parse_next_address(sd_bus *b) {
 928         _cleanup_free_ char *guid = NULL;
 929         const char *a;
 930         int r;
 931
 932         assert(b);
 933
 934         if (!b->address)
 935                 return 0;
 936         if (b->address[b->address_index] == 0)
 937                 return 0;
 938
 939         bus_reset_parsed_address(b);
 940
 941         a = b->address + b->address_index;
 942
 943         while (*a != 0) {
 944
 945                 if (*a == ';') {
 946                         a++;
 947                         continue;
 948                 }
 949
 950                 if (startswith(a, "unix:")) {
 951                         a += 5;
 952
 953                         r = parse_unix_address(b, &a, &guid);
 954                         if (r < 0)
 955                                 return r;
 956                         break;
 957
 958                 } else if (startswith(a, "tcp:")) {
 959
 960                         a += 4;
 961                         r = parse_tcp_address(b, &a, &guid);
 962                         if (r < 0)
 963                                 return r;
 964
 965                         break;
 966
 967                 } else if (startswith(a, "unixexec:")) {
 968
 969                         a += 9;
 970                         r = parse_exec_address(b, &a, &guid);
 971                         if (r < 0)
 972                                 return r;
 973
 974                         break;
 975
 976                 } else if (startswith(a, "kernel:")) {
 977
 978                         a += 7;
 979                         r = parse_kernel_address(b, &a, &guid);
 980                         if (r < 0)
 981                                 return r;
 982
 983                         break;
 984                 } else if (startswith(a, "x-machine-unix:")) {
 985
 986                         a += 15;
 987                         r = parse_container_unix_address(b, &a, &guid);
 988                         if (r < 0)
 989                                 return r;
 990
 991                         break;
 992                 } else if (startswith(a, "x-machine-kernel:")) {
 993
 994                         a += 17;
 995                         r = parse_container_kernel_address(b, &a, &guid);
 996                         if (r < 0)
 997                                 return r;
 998
 999                         break;
1000                 }
1001
1002                 a = strchr(a, ';');
1003                 if (!a)
1004                         return 0;
1005         }
1006
1007         if (guid) {
1008                 r = sd_id128_from_string(guid, &b->server_id);
1009                 if (r < 0)
1010                         return r;
1011         }
1012
1013         b->address_index = a - b->address;
1014         return 1;
1015 }
1016
1017 static int bus_start_address(sd_bus *b) {
1018         bool container_kdbus_available = false;
1019         bool kdbus_available = false;
1020         int r;
1021
1022         assert(b);
1023
1024         for (;;) {
1025                 bool skipped = false;
1026
1027                 bus_close_fds(b);
1028
1029                 /*
1030                  * Usually, if you provide multiple different bus-addresses, we
1031                  * try all of them in order. We use the first one that
1032                  * succeeds. However, if you mix kernel and unix addresses, we
1033                  * never try unix-addresses if a previous kernel address was
1034                  * tried and kdbus was available. This is required to prevent
1035                  * clients to fallback to the bus-proxy if kdbus is available
1036                  * but failed (eg., too many connections).
1037                  */
1038
1039                 if (b->exec_path)
1040                         r = bus_socket_exec(b);
1041                 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1042                         r = bus_container_connect_kernel(b);
1043                         if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1044                                 container_kdbus_available = true;
1045
1046                 } else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) {
1047                         if (!container_kdbus_available)
1048                                 r = bus_container_connect_socket(b);
1049                         else
1050                                 skipped = true;
1051
1052                 } else if (b->kernel) {
1053                         r = bus_kernel_connect(b);
1054                         if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1055                                 kdbus_available = true;
1056
1057                 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
1058                         if (!kdbus_available)
1059                                 r = bus_socket_connect(b);
1060                         else
1061                                 skipped = true;
1062                 } else
1063                         skipped = true;
1064
1065                 if (!skipped) {
1066                         if (r >= 0) {
1067                                 r = attach_io_events(b);
1068                                 if (r >= 0)
1069                                         return r;
1070                         }
1071
1072                         b->last_connect_error = -r;
1073                 }
1074
1075                 r = bus_parse_next_address(b);
1076                 if (r < 0)
1077                         return r;
1078                 if (r == 0)
1079                         return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1080         }
1081 }
1082
1083 int bus_next_address(sd_bus *b) {
1084         assert(b);
1085
1086         bus_reset_parsed_address(b);
1087         return bus_start_address(b);
1088 }
1089
1090 static int bus_start_fd(sd_bus *b) {
1091         struct stat st;
1092         int r;
1093
1094         assert(b);
1095         assert(b->input_fd >= 0);
1096         assert(b->output_fd >= 0);
1097
1098         r = fd_nonblock(b->input_fd, true);
1099         if (r < 0)
1100                 return r;
1101
1102         r = fd_cloexec(b->input_fd, true);
1103         if (r < 0)
1104                 return r;
1105
1106         if (b->input_fd != b->output_fd) {
1107                 r = fd_nonblock(b->output_fd, true);
1108                 if (r < 0)
1109                         return r;
1110
1111                 r = fd_cloexec(b->output_fd, true);
1112                 if (r < 0)
1113                         return r;
1114         }
1115
1116         if (fstat(b->input_fd, &st) < 0)
1117                 return -errno;
1118
1119         if (S_ISCHR(b->input_fd))
1120                 return bus_kernel_take_fd(b);
1121         else
1122                 return bus_socket_take_fd(b);
1123 }
1124
1125 _public_ int sd_bus_start(sd_bus *bus) {
1126         int r;
1127
1128         assert_return(bus, -EINVAL);
1129         assert_return(bus->state == BUS_UNSET, -EPERM);
1130         assert_return(!bus_pid_changed(bus), -ECHILD);
1131
1132         bus->state = BUS_OPENING;
1133
1134         if (bus->is_server && bus->bus_client)
1135                 return -EINVAL;
1136
1137         if (bus->input_fd >= 0)
1138                 r = bus_start_fd(bus);
1139         else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1140                 r = bus_start_address(bus);
1141         else
1142                 return -EINVAL;
1143
1144         if (r < 0) {
1145                 sd_bus_close(bus);
1146                 return r;
1147         }
1148
1149         return bus_send_hello(bus);
1150 }
1151
1152 _public_ int sd_bus_open(sd_bus **ret) {
1153         const char *e;
1154         sd_bus *b;
1155         int r;
1156
1157         assert_return(ret, -EINVAL);
1158
1159         /* Let's connect to the starter bus if it is set, and
1160          * otherwise to the bus that is appropropriate for the scope
1161          * we are running in */
1162
1163         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1164         if (e) {
1165                 if (streq(e, "system"))
1166                         return sd_bus_open_system(ret);
1167 #if 0 /// elogind does not support systemd units
1168                 else if (STR_IN_SET(e, "session", "user"))
1169                         return sd_bus_open_user(ret);
1170 #endif // 0
1171         }
1172
1173         e = secure_getenv("DBUS_STARTER_ADDRESS");
1174         if (!e) {
1175 #if 0 /// elogind does not support systemd units
1176                 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1177                         return sd_bus_open_user(ret);
1178                 else
1179 #endif // 0
1180                 return sd_bus_open_system(ret);
1181         }
1182
1183         r = sd_bus_new(&b);
1184         if (r < 0)
1185                 return r;
1186
1187         r = sd_bus_set_address(b, e);
1188         if (r < 0)
1189                 goto fail;
1190
1191         b->bus_client = true;
1192
1193         /* We don't know whether the bus is trusted or not, so better
1194          * be safe, and authenticate everything */
1195         b->trusted = false;
1196         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1197         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1198
1199         r = sd_bus_start(b);
1200         if (r < 0)
1201                 goto fail;
1202
1203         *ret = b;
1204         return 0;
1205
1206 fail:
1207         bus_free(b);
1208         return r;
1209 }
1210
1211 int bus_set_address_system(sd_bus *b) {
1212         const char *e;
1213         assert(b);
1214
1215         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1216         if (e)
1217                 return sd_bus_set_address(b, e);
1218
1219         return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1220 }
1221
1222 _public_ int sd_bus_open_system(sd_bus **ret) {
1223         sd_bus *b;
1224         int r;
1225
1226         assert_return(ret, -EINVAL);
1227
1228         r = sd_bus_new(&b);
1229         if (r < 0)
1230                 return r;
1231
1232         r = bus_set_address_system(b);
1233         if (r < 0)
1234                 goto fail;
1235
1236         b->bus_client = true;
1237         b->is_system = true;
1238
1239         /* Let's do per-method access control on the system bus. We
1240          * need the caller's UID and capability set for that. */
1241         b->trusted = false;
1242         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1243         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1244
1245         r = sd_bus_start(b);
1246         if (r < 0)
1247                 goto fail;
1248
1249         *ret = b;
1250         return 0;
1251
1252 fail:
1253         bus_free(b);
1254         return r;
1255 }
1256
1257 #if 0 /// elogind can not open/use a user bus
1258 int bus_set_address_user(sd_bus *b) {
1259         const char *e;
1260         uid_t uid;
1261         int r;
1262
1263         assert(b);
1264
1265         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1266         if (e)
1267                 return sd_bus_set_address(b, e);
1268
1269         r = cg_pid_get_owner_uid(0, &uid);
1270         if (r < 0)
1271                 uid = getuid();
1272
1273         e = secure_getenv("XDG_RUNTIME_DIR");
1274         if (e) {
1275                 _cleanup_free_ char *ee = NULL;
1276
1277                 ee = bus_address_escape(e);
1278                 if (!ee)
1279                         return -ENOMEM;
1280
1281                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1282         } else
1283                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1284
1285         if (!b->address)
1286                 return -ENOMEM;
1287
1288         return 0;
1289 }
1290 #endif // 0
1291
1292 _public_ int sd_bus_open_user(sd_bus **ret) {
1293 #if 0 /// elogind does not support user buses
1294         sd_bus *b;
1295         int r;
1296
1297         assert_return(ret, -EINVAL);
1298
1299         r = sd_bus_new(&b);
1300         if (r < 0)
1301                 return r;
1302
1303         r = bus_set_address_user(b);
1304         if (r < 0)
1305                 return r;
1306
1307         b->bus_client = true;
1308         b->is_user = true;
1309
1310         /* We don't do any per-method access control on the user
1311          * bus. */
1312         b->trusted = true;
1313
1314         r = sd_bus_start(b);
1315         if (r < 0)
1316                 goto fail;
1317
1318         *ret = b;
1319         return 0;
1320
1321 fail:
1322         bus_free(b);
1323         return r;
1324 #else
1325         return sd_bus_open_system(ret);
1326 #endif // 0
1327 }
1328
1329 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1330         _cleanup_free_ char *e = NULL;
1331         char *m = NULL, *c = NULL;
1332
1333         assert(b);
1334         assert(host);
1335
1336         /* Let's see if we shall enter some container */
1337         m = strchr(host, ':');
1338         if (m) {
1339                 m++;
1340
1341                 /* Let's make sure this is not a port of some kind,
1342                  * and is a valid machine name. */
1343                 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1344                         char *t;
1345
1346                         /* Cut out the host part */
1347                         t = strndupa(host, m - host - 1);
1348                         e = bus_address_escape(t);
1349                         if (!e)
1350                                 return -ENOMEM;
1351
1352                         c = strjoina(",argv4=--machine=", m);
1353                 }
1354         }
1355
1356         if (!e) {
1357                 e = bus_address_escape(host);
1358                 if (!e)
1359                         return -ENOMEM;
1360         }
1361
1362         b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1363         if (!b->address)
1364                 return -ENOMEM;
1365
1366         return 0;
1367  }
1368
1369 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1370         sd_bus *bus;
1371         int r;
1372
1373         assert_return(host, -EINVAL);
1374         assert_return(ret, -EINVAL);
1375
1376         r = sd_bus_new(&bus);
1377         if (r < 0)
1378                 return r;
1379
1380         r = bus_set_address_system_remote(bus, host);
1381         if (r < 0)
1382                 goto fail;
1383
1384         bus->bus_client = true;
1385         bus->trusted = false;
1386         bus->is_system = true;
1387
1388         r = sd_bus_start(bus);
1389         if (r < 0)
1390                 goto fail;
1391
1392         *ret = bus;
1393         return 0;
1394
1395 fail:
1396         bus_free(bus);
1397         return r;
1398 }
1399
1400 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1401         _cleanup_free_ char *e = NULL;
1402
1403         assert(b);
1404         assert(machine);
1405
1406         e = bus_address_escape(machine);
1407         if (!e)
1408                 return -ENOMEM;
1409
1410         b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1411         if (!b->address)
1412                 return -ENOMEM;
1413
1414         return 0;
1415 }
1416
1417 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1418         sd_bus *bus;
1419         int r;
1420
1421         assert_return(machine, -EINVAL);
1422         assert_return(ret, -EINVAL);
1423         assert_return(machine_name_is_valid(machine), -EINVAL);
1424
1425         r = sd_bus_new(&bus);
1426         if (r < 0)
1427                 return r;
1428
1429         r = bus_set_address_system_machine(bus, machine);
1430         if (r < 0)
1431                 goto fail;
1432
1433         bus->bus_client = true;
1434         bus->trusted = false;
1435         bus->is_system = true;
1436
1437         r = sd_bus_start(bus);
1438         if (r < 0)
1439                 goto fail;
1440
1441         *ret = bus;
1442         return 0;
1443
1444 fail:
1445         bus_free(bus);
1446         return r;
1447 }
1448
1449 _public_ void sd_bus_close(sd_bus *bus) {
1450
1451         if (!bus)
1452                 return;
1453         if (bus->state == BUS_CLOSED)
1454                 return;
1455         if (bus_pid_changed(bus))
1456                 return;
1457
1458         bus->state = BUS_CLOSED;
1459
1460         sd_bus_detach_event(bus);
1461
1462         /* Drop all queued messages so that they drop references to
1463          * the bus object and the bus may be freed */
1464         bus_reset_queues(bus);
1465
1466         if (!bus->is_kernel)
1467                 bus_close_fds(bus);
1468
1469         /* We'll leave the fd open in case this is a kernel bus, since
1470          * there might still be memblocks around that reference this
1471          * bus, and they might need to invoke the KDBUS_CMD_FREE
1472          * ioctl on the fd when they are freed. */
1473 }
1474
1475 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1476
1477         if (!bus)
1478                 return NULL;
1479
1480         sd_bus_flush(bus);
1481         sd_bus_close(bus);
1482
1483         return sd_bus_unref(bus);
1484 }
1485
1486 static void bus_enter_closing(sd_bus *bus) {
1487         assert(bus);
1488
1489         if (bus->state != BUS_OPENING &&
1490             bus->state != BUS_AUTHENTICATING &&
1491             bus->state != BUS_HELLO &&
1492             bus->state != BUS_RUNNING)
1493                 return;
1494
1495         bus->state = BUS_CLOSING;
1496 }
1497
1498 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1499         assert_return(bus, 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_bus_message_unref_ 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_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1908         _cleanup_bus_slot_unref_ 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_bus_message_unref_ 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_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2248         _cleanup_bus_message_unref_ 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_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2330         _cleanup_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_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_bus_message_unref_ 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_bus_message_unref_ 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_bus_message_unref_ 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_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