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