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