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

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