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