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

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