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         char *m = NULL, *c = NULL;
1213
1214         assert(b);
1215         assert(host);
1216
1217         /* Let's see if we shall enter some container */
1218         m = strchr(host, ':');
1219         if (m) {
1220                 m++;
1221
1222                 /* Let's make sure this is not a port of some kind,
1223                  * and is a valid machine name. */
1224                 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1225                         char *t;
1226
1227                         /* Cut out the host part */
1228                         t = strndupa(host, m - host - 1);
1229                         e = bus_address_escape(t);
1230                         if (!e)
1231                                 return -ENOMEM;
1232
1233                         c = strappenda(",argv4=--machine=", m);
1234                 }
1235         }
1236
1237         if (!e) {
1238                 e = bus_address_escape(host);
1239                 if (!e)
1240                         return -ENOMEM;
1241         }
1242
1243         b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1244         if (!b->address)
1245                 return -ENOMEM;
1246
1247         return 0;
1248  }
1249
1250 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1251         sd_bus *bus;
1252         int r;
1253
1254         assert_return(host, -EINVAL);
1255         assert_return(ret, -EINVAL);
1256
1257         r = sd_bus_new(&bus);
1258         if (r < 0)
1259                 return r;
1260
1261         r = bus_set_address_system_remote(bus, host);
1262         if (r < 0)
1263                 goto fail;
1264
1265         bus->bus_client = true;
1266         bus->trusted = false;
1267
1268         r = sd_bus_start(bus);
1269         if (r < 0)
1270                 goto fail;
1271
1272         *ret = bus;
1273         return 0;
1274
1275 fail:
1276         bus_free(bus);
1277         return r;
1278 }
1279
1280 int bus_set_address_system_container(sd_bus *b, const char *machine) {
1281         _cleanup_free_ char *e = NULL;
1282
1283         assert(b);
1284         assert(machine);
1285
1286         e = bus_address_escape(machine);
1287         if (!e)
1288                 return -ENOMEM;
1289
1290 #ifdef ENABLE_KDBUS
1291         b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL);
1292 #else
1293         b->address = strjoin("x-container-unix:machine=", e, NULL);
1294 #endif
1295         if (!b->address)
1296                 return -ENOMEM;
1297
1298         return 0;
1299 }
1300
1301 _public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) {
1302         sd_bus *bus;
1303         int r;
1304
1305         assert_return(machine, -EINVAL);
1306         assert_return(ret, -EINVAL);
1307         assert_return(filename_is_safe(machine), -EINVAL);
1308
1309         r = sd_bus_new(&bus);
1310         if (r < 0)
1311                 return r;
1312
1313         r = bus_set_address_system_container(bus, machine);
1314         if (r < 0)
1315                 goto fail;
1316
1317         bus->bus_client = true;
1318         bus->trusted = false;
1319
1320         r = sd_bus_start(bus);
1321         if (r < 0)
1322                 goto fail;
1323
1324         *ret = bus;
1325         return 0;
1326
1327 fail:
1328         bus_free(bus);
1329         return r;
1330 }
1331
1332 _public_ void sd_bus_close(sd_bus *bus) {
1333
1334         if (!bus)
1335                 return;
1336         if (bus->state == BUS_CLOSED)
1337                 return;
1338         if (bus_pid_changed(bus))
1339                 return;
1340
1341         bus->state = BUS_CLOSED;
1342
1343         sd_bus_detach_event(bus);
1344
1345         /* Drop all queued messages so that they drop references to
1346          * the bus object and the bus may be freed */
1347         bus_reset_queues(bus);
1348
1349         if (!bus->is_kernel)
1350                 bus_close_fds(bus);
1351
1352         /* We'll leave the fd open in case this is a kernel bus, since
1353          * there might still be memblocks around that reference this
1354          * bus, and they might need to invoke the KDBUS_CMD_FREE
1355          * ioctl on the fd when they are freed. */
1356 }
1357
1358 static void bus_enter_closing(sd_bus *bus) {
1359         assert(bus);
1360
1361         if (bus->state != BUS_OPENING &&
1362             bus->state != BUS_AUTHENTICATING &&
1363             bus->state != BUS_HELLO &&
1364             bus->state != BUS_RUNNING)
1365                 return;
1366
1367         bus->state = BUS_CLOSING;
1368 }
1369
1370 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1371         assert_return(bus, NULL);
1372
1373         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1374
1375         return bus;
1376 }
1377
1378 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1379         unsigned i;
1380
1381         if (!bus)
1382                 return NULL;
1383
1384         i = REFCNT_DEC(bus->n_ref);
1385         if (i > 0)
1386                 return NULL;
1387
1388         bus_free(bus);
1389         return NULL;
1390 }
1391
1392 _public_ int sd_bus_is_open(sd_bus *bus) {
1393
1394         assert_return(bus, -EINVAL);
1395         assert_return(!bus_pid_changed(bus), -ECHILD);
1396
1397         return BUS_IS_OPEN(bus->state);
1398 }
1399
1400 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1401         int r;
1402
1403         assert_return(bus, -EINVAL);
1404         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1405         assert_return(!bus_pid_changed(bus), -ECHILD);
1406
1407         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1408                 return 0;
1409
1410         if (type == SD_BUS_TYPE_UNIX_FD) {
1411                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1412                         return 0;
1413
1414                 r = bus_ensure_running(bus);
1415                 if (r < 0)
1416                         return r;
1417
1418                 return bus->can_fds;
1419         }
1420
1421         return bus_type_is_valid(type);
1422 }
1423
1424 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1425         int r;
1426
1427         assert_return(bus, -EINVAL);
1428         assert_return(server_id, -EINVAL);
1429         assert_return(!bus_pid_changed(bus), -ECHILD);
1430
1431         r = bus_ensure_running(bus);
1432         if (r < 0)
1433                 return r;
1434
1435         *server_id = bus->server_id;
1436         return 0;
1437 }
1438
1439 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1440         assert(b);
1441         assert(m);
1442
1443         if (m->sealed) {
1444                 /* If we copy the same message to multiple
1445                  * destinations, avoid using the same cookie
1446                  * numbers. */
1447                 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1448                 return 0;
1449         }
1450
1451         if (timeout == 0)
1452                 timeout = BUS_DEFAULT_TIMEOUT;
1453
1454         return bus_message_seal(m, ++b->cookie, timeout);
1455 }
1456
1457 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1458         assert(b);
1459
1460         /* Do packet version and endianness already match? */
1461         if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1462             (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1463                 return 0;
1464
1465         /* No? Then remarshal! */
1466         return bus_message_remarshal(b, m);
1467 }
1468
1469 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1470         assert(b);
1471         assert(m);
1472
1473         /* The bus specification says the serial number cannot be 0,
1474          * hence let's fill something in for synthetic messages. Since
1475          * synthetic messages might have a fake sender and we don't
1476          * want to interfere with the real sender's serial numbers we
1477          * pick a fixed, artificial one. We use (uint32_t) -1 rather
1478          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1479          * even though kdbus can do 64bit. */
1480
1481         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1482 }
1483
1484 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1485         int r;
1486
1487         assert(bus);
1488         assert(m);
1489
1490         if (bus->is_kernel)
1491                 r = bus_kernel_write_message(bus, m, hint_sync_call);
1492         else
1493                 r = bus_socket_write_message(bus, m, idx);
1494
1495         if (r <= 0)
1496                 return r;
1497
1498         if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1499                 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1500                           bus_message_type_to_string(m->header->type),
1501                           strna(sd_bus_message_get_sender(m)),
1502                           strna(sd_bus_message_get_destination(m)),
1503                           strna(sd_bus_message_get_path(m)),
1504                           strna(sd_bus_message_get_interface(m)),
1505                           strna(sd_bus_message_get_member(m)),
1506                           BUS_MESSAGE_COOKIE(m),
1507                           m->reply_cookie,
1508                           strna(m->error.message));
1509
1510         return r;
1511 }
1512
1513 static int dispatch_wqueue(sd_bus *bus) {
1514         int r, ret = 0;
1515
1516         assert(bus);
1517         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1518
1519         while (bus->wqueue_size > 0) {
1520
1521                 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1522                 if (r < 0)
1523                         return r;
1524                 else if (r == 0)
1525                         /* Didn't do anything this time */
1526                         return ret;
1527                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1528                         /* Fully written. Let's drop the entry from
1529                          * the queue.
1530                          *
1531                          * This isn't particularly optimized, but
1532                          * well, this is supposed to be our worst-case
1533                          * buffer only, and the socket buffer is
1534                          * supposed to be our primary buffer, and if
1535                          * it got full, then all bets are off
1536                          * anyway. */
1537
1538                         bus->wqueue_size --;
1539                         sd_bus_message_unref(bus->wqueue[0]);
1540                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1541                         bus->windex = 0;
1542
1543                         ret = 1;
1544                 }
1545         }
1546
1547         return ret;
1548 }
1549
1550 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1551         assert(bus);
1552
1553         if (bus->is_kernel)
1554                 return bus_kernel_read_message(bus, hint_priority, priority);
1555         else
1556                 return bus_socket_read_message(bus);
1557 }
1558
1559 int bus_rqueue_make_room(sd_bus *bus) {
1560         assert(bus);
1561
1562         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1563                 return -ENOBUFS;
1564
1565         if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1566                 return -ENOMEM;
1567
1568         return 0;
1569 }
1570
1571 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1572         int r, ret = 0;
1573
1574         assert(bus);
1575         assert(m);
1576         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1577
1578         /* Note that the priority logic is only available on kdbus,
1579          * where the rqueue is unused. We check the rqueue here
1580          * anyway, because it's simple... */
1581
1582         for (;;) {
1583                 if (bus->rqueue_size > 0) {
1584                         /* Dispatch a queued message */
1585
1586                         *m = bus->rqueue[0];
1587                         bus->rqueue_size --;
1588                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1589                         return 1;
1590                 }
1591
1592                 /* Try to read a new message */
1593                 r = bus_read_message(bus, hint_priority, priority);
1594                 if (r < 0)
1595                         return r;
1596                 if (r == 0)
1597                         return ret;
1598
1599                 ret = 1;
1600         }
1601 }
1602
1603 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1604         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1605         int r;
1606
1607         assert_return(bus, -EINVAL);
1608         assert_return(m, -EINVAL);
1609         assert_return(!bus_pid_changed(bus), -ECHILD);
1610         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1611
1612         if (!BUS_IS_OPEN(bus->state))
1613                 return -ENOTCONN;
1614
1615         if (m->n_fds > 0) {
1616                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1617                 if (r < 0)
1618                         return r;
1619                 if (r == 0)
1620                         return -ENOTSUP;
1621         }
1622
1623         /* If the cookie number isn't kept, then we know that no reply
1624          * is expected */
1625         if (!cookie && !m->sealed)
1626                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1627
1628         r = bus_seal_message(bus, m, 0);
1629         if (r < 0)
1630                 return r;
1631
1632         /* Remarshall if we have to. This will possibly unref the
1633          * message and place a replacement in m */
1634         r = bus_remarshal_message(bus, &m);
1635         if (r < 0)
1636                 return r;
1637
1638         /* If this is a reply and no reply was requested, then let's
1639          * suppress this, if we can */
1640         if (m->dont_send && !cookie)
1641                 return 1;
1642
1643         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1644                 size_t idx = 0;
1645
1646                 r = bus_write_message(bus, m, hint_sync_call, &idx);
1647                 if (r < 0) {
1648                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1649                                 bus_enter_closing(bus);
1650                                 return -ECONNRESET;
1651                         }
1652
1653                         return r;
1654                 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1655                         /* Wasn't fully written. So let's remember how
1656                          * much was written. Note that the first entry
1657                          * of the wqueue array is always allocated so
1658                          * that we always can remember how much was
1659                          * written. */
1660                         bus->wqueue[0] = sd_bus_message_ref(m);
1661                         bus->wqueue_size = 1;
1662                         bus->windex = idx;
1663                 }
1664         } else {
1665                 /* Just append it to the queue. */
1666
1667                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1668                         return -ENOBUFS;
1669
1670                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1671                         return -ENOMEM;
1672
1673                 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1674         }
1675
1676         if (cookie)
1677                 *cookie = BUS_MESSAGE_COOKIE(m);
1678
1679         return 1;
1680 }
1681
1682 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1683         return bus_send_internal(bus, m, cookie, false);
1684 }
1685
1686 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1687         int r;
1688
1689         assert_return(bus, -EINVAL);
1690         assert_return(m, -EINVAL);
1691         assert_return(!bus_pid_changed(bus), -ECHILD);
1692
1693         if (!BUS_IS_OPEN(bus->state))
1694                 return -ENOTCONN;
1695
1696         if (!streq_ptr(m->destination, destination)) {
1697
1698                 if (!destination)
1699                         return -EEXIST;
1700
1701                 r = sd_bus_message_set_destination(m, destination);
1702                 if (r < 0)
1703                         return r;
1704         }
1705
1706         return sd_bus_send(bus, m, cookie);
1707 }
1708
1709 static usec_t calc_elapse(uint64_t usec) {
1710         if (usec == (uint64_t) -1)
1711                 return 0;
1712
1713         return now(CLOCK_MONOTONIC) + usec;
1714 }
1715
1716 static int timeout_compare(const void *a, const void *b) {
1717         const struct reply_callback *x = a, *y = b;
1718
1719         if (x->timeout != 0 && y->timeout == 0)
1720                 return -1;
1721
1722         if (x->timeout == 0 && y->timeout != 0)
1723                 return 1;
1724
1725         if (x->timeout < y->timeout)
1726                 return -1;
1727
1728         if (x->timeout > y->timeout)
1729                 return 1;
1730
1731         return 0;
1732 }
1733
1734 _public_ int sd_bus_call_async(
1735                 sd_bus *bus,
1736                 sd_bus_slot **slot,
1737                 sd_bus_message *_m,
1738                 sd_bus_message_handler_t callback,
1739                 void *userdata,
1740                 uint64_t usec) {
1741
1742         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1743         _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1744         int r;
1745
1746         assert_return(bus, -EINVAL);
1747         assert_return(m, -EINVAL);
1748         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1749         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1750         assert_return(callback, -EINVAL);
1751         assert_return(!bus_pid_changed(bus), -ECHILD);
1752         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1753
1754         if (!BUS_IS_OPEN(bus->state))
1755                 return -ENOTCONN;
1756
1757         r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1758         if (r < 0)
1759                 return r;
1760
1761         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1762         if (r < 0)
1763                 return r;
1764
1765         r = bus_seal_message(bus, m, usec);
1766         if (r < 0)
1767                 return r;
1768
1769         r = bus_remarshal_message(bus, &m);
1770         if (r < 0)
1771                 return r;
1772
1773         s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1774         if (!s)
1775                 return -ENOMEM;
1776
1777         s->reply_callback.callback = callback;
1778
1779         s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1780         r = hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1781         if (r < 0) {
1782                 s->reply_callback.cookie = 0;
1783                 return r;
1784         }
1785
1786         s->reply_callback.timeout = calc_elapse(m->timeout);
1787         if (s->reply_callback.timeout != 0) {
1788                 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1789                 if (r < 0) {
1790                         s->reply_callback.timeout = 0;
1791                         return r;
1792                 }
1793         }
1794
1795         r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1796         if (r < 0)
1797                 return r;
1798
1799         if (slot)
1800                 *slot = s;
1801         s = NULL;
1802
1803         return r;
1804 }
1805
1806 int bus_ensure_running(sd_bus *bus) {
1807         int r;
1808
1809         assert(bus);
1810
1811         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1812                 return -ENOTCONN;
1813         if (bus->state == BUS_RUNNING)
1814                 return 1;
1815
1816         for (;;) {
1817                 r = sd_bus_process(bus, NULL);
1818                 if (r < 0)
1819                         return r;
1820                 if (bus->state == BUS_RUNNING)
1821                         return 1;
1822                 if (r > 0)
1823                         continue;
1824
1825                 r = sd_bus_wait(bus, (uint64_t) -1);
1826                 if (r < 0)
1827                         return r;
1828         }
1829 }
1830
1831 _public_ int sd_bus_call(
1832                 sd_bus *bus,
1833                 sd_bus_message *_m,
1834                 uint64_t usec,
1835                 sd_bus_error *error,
1836                 sd_bus_message **reply) {
1837
1838         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1839         usec_t timeout;
1840         uint64_t cookie;
1841         unsigned i;
1842         int r;
1843
1844         assert_return(bus, -EINVAL);
1845         assert_return(m, -EINVAL);
1846         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1847         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1848         assert_return(!bus_error_is_dirty(error), -EINVAL);
1849         assert_return(!bus_pid_changed(bus), -ECHILD);
1850         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1851
1852         if (!BUS_IS_OPEN(bus->state))
1853                 return -ENOTCONN;
1854
1855         r = bus_ensure_running(bus);
1856         if (r < 0)
1857                 return r;
1858
1859         i = bus->rqueue_size;
1860
1861         r = bus_seal_message(bus, m, usec);
1862         if (r < 0)
1863                 return r;
1864
1865         r = bus_remarshal_message(bus, &m);
1866         if (r < 0)
1867                 return r;
1868
1869         r = bus_send_internal(bus, m, &cookie, true);
1870         if (r < 0)
1871                 return r;
1872
1873         timeout = calc_elapse(m->timeout);
1874
1875         for (;;) {
1876                 usec_t left;
1877
1878                 while (i < bus->rqueue_size) {
1879                         sd_bus_message *incoming = NULL;
1880
1881                         incoming = bus->rqueue[i];
1882
1883                         if (incoming->reply_cookie == cookie) {
1884                                 /* Found a match! */
1885
1886                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1887                                 bus->rqueue_size--;
1888
1889                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1890
1891                                         if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1892                                                 if (reply)
1893                                                         *reply = incoming;
1894                                                 else
1895                                                         sd_bus_message_unref(incoming);
1896
1897                                                 return 1;
1898                                         }
1899
1900                                         r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1901
1902                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1903                                         r = sd_bus_error_copy(error, &incoming->error);
1904                                 else
1905                                         r = -EIO;
1906
1907                                 sd_bus_message_unref(incoming);
1908                                 return r;
1909
1910                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1911                                    bus->unique_name &&
1912                                    incoming->sender &&
1913                                    streq(bus->unique_name, incoming->sender)) {
1914
1915                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1916                                 bus->rqueue_size--;
1917
1918                                 /* Our own message? Somebody is trying
1919                                  * to send its own client a message,
1920                                  * let's not dead-lock, let's fail
1921                                  * immediately. */
1922
1923                                 sd_bus_message_unref(incoming);
1924                                 return -ELOOP;
1925                         }
1926
1927                         /* Try to read more, right-away */
1928                         i++;
1929                 }
1930
1931                 r = bus_read_message(bus, false, 0);
1932                 if (r < 0) {
1933                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1934                                 bus_enter_closing(bus);
1935                                 return -ECONNRESET;
1936                         }
1937
1938                         return r;
1939                 }
1940                 if (r > 0)
1941                         continue;
1942
1943                 if (timeout > 0) {
1944                         usec_t n;
1945
1946                         n = now(CLOCK_MONOTONIC);
1947                         if (n >= timeout)
1948                                 return -ETIMEDOUT;
1949
1950                         left = timeout - n;
1951                 } else
1952                         left = (uint64_t) -1;
1953
1954                 r = bus_poll(bus, true, left);
1955                 if (r < 0)
1956                         return r;
1957                 if (r == 0)
1958                         return -ETIMEDOUT;
1959
1960                 r = dispatch_wqueue(bus);
1961                 if (r < 0) {
1962                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1963                                 bus_enter_closing(bus);
1964                                 return -ECONNRESET;
1965                         }
1966
1967                         return r;
1968                 }
1969         }
1970 }
1971
1972 _public_ int sd_bus_get_fd(sd_bus *bus) {
1973
1974         assert_return(bus, -EINVAL);
1975         assert_return(bus->input_fd == bus->output_fd, -EPERM);
1976         assert_return(!bus_pid_changed(bus), -ECHILD);
1977
1978         return bus->input_fd;
1979 }
1980
1981 _public_ int sd_bus_get_events(sd_bus *bus) {
1982         int flags = 0;
1983
1984         assert_return(bus, -EINVAL);
1985         assert_return(!bus_pid_changed(bus), -ECHILD);
1986
1987         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
1988                 return -ENOTCONN;
1989
1990         if (bus->state == BUS_OPENING)
1991                 flags |= POLLOUT;
1992         else if (bus->state == BUS_AUTHENTICATING) {
1993
1994                 if (bus_socket_auth_needs_write(bus))
1995                         flags |= POLLOUT;
1996
1997                 flags |= POLLIN;
1998
1999         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2000                 if (bus->rqueue_size <= 0)
2001                         flags |= POLLIN;
2002                 if (bus->wqueue_size > 0)
2003                         flags |= POLLOUT;
2004         }
2005
2006         return flags;
2007 }
2008
2009 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2010         struct reply_callback *c;
2011
2012         assert_return(bus, -EINVAL);
2013         assert_return(timeout_usec, -EINVAL);
2014         assert_return(!bus_pid_changed(bus), -ECHILD);
2015
2016         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2017                 return -ENOTCONN;
2018
2019         if (bus->track_queue) {
2020                 *timeout_usec = 0;
2021                 return 1;
2022         }
2023
2024         if (bus->state == BUS_CLOSING) {
2025                 *timeout_usec = 0;
2026                 return 1;
2027         }
2028
2029         if (bus->state == BUS_AUTHENTICATING) {
2030                 *timeout_usec = bus->auth_timeout;
2031                 return 1;
2032         }
2033
2034         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2035                 *timeout_usec = (uint64_t) -1;
2036                 return 0;
2037         }
2038
2039         if (bus->rqueue_size > 0) {
2040                 *timeout_usec = 0;
2041                 return 1;
2042         }
2043
2044         c = prioq_peek(bus->reply_callbacks_prioq);
2045         if (!c) {
2046                 *timeout_usec = (uint64_t) -1;
2047                 return 0;
2048         }
2049
2050         if (c->timeout == 0) {
2051                 *timeout_usec = (uint64_t) -1;
2052                 return 0;
2053         }
2054
2055         *timeout_usec = c->timeout;
2056         return 1;
2057 }
2058
2059 static int process_timeout(sd_bus *bus) {
2060         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2061         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2062         struct reply_callback *c;
2063         sd_bus_slot *slot;
2064         usec_t n;
2065         int r;
2066
2067         assert(bus);
2068
2069         c = prioq_peek(bus->reply_callbacks_prioq);
2070         if (!c)
2071                 return 0;
2072
2073         n = now(CLOCK_MONOTONIC);
2074         if (c->timeout > n)
2075                 return 0;
2076
2077         r = bus_message_new_synthetic_error(
2078                         bus,
2079                         c->cookie,
2080                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2081                         &m);
2082         if (r < 0)
2083                 return r;
2084
2085         m->sender = "org.freedesktop.DBus";
2086
2087         r = bus_seal_synthetic_message(bus, m);
2088         if (r < 0)
2089                 return r;
2090
2091         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2092         c->timeout = 0;
2093
2094         hashmap_remove(bus->reply_callbacks, &c->cookie);
2095         c->cookie = 0;
2096
2097         slot = container_of(c, sd_bus_slot, reply_callback);
2098
2099         bus->iteration_counter ++;
2100
2101         bus->current_message = m;
2102         bus->current_slot = sd_bus_slot_ref(slot);
2103         r = c->callback(bus, m, slot->userdata, &error_buffer);
2104         bus->current_slot = sd_bus_slot_unref(slot);
2105         bus->current_message = NULL;
2106
2107         if (slot->floating) {
2108                 bus_slot_disconnect(slot);
2109                 sd_bus_slot_unref(slot);
2110         }
2111
2112         return bus_maybe_reply_error(m, r, &error_buffer);
2113 }
2114
2115 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2116         assert(bus);
2117         assert(m);
2118
2119         if (bus->state != BUS_HELLO)
2120                 return 0;
2121
2122         /* Let's make sure the first message on the bus is the HELLO
2123          * reply. But note that we don't actually parse the message
2124          * here (we leave that to the usual handling), we just verify
2125          * we don't let any earlier msg through. */
2126
2127         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2128             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2129                 return -EIO;
2130
2131         if (m->reply_cookie != 1)
2132                 return -EIO;
2133
2134         return 0;
2135 }
2136
2137 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2138         _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2139         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2140         struct reply_callback *c;
2141         sd_bus_slot *slot;
2142         int r;
2143
2144         assert(bus);
2145         assert(m);
2146
2147         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2148             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2149                 return 0;
2150
2151         if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2152                 return 0;
2153
2154         if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2155                 return 0;
2156
2157         c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2158         if (!c)
2159                 return 0;
2160
2161         c->cookie = 0;
2162
2163         slot = container_of(c, sd_bus_slot, reply_callback);
2164
2165         if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2166
2167                 /* If the reply contained a file descriptor which we
2168                  * didn't want we pass an error instead. */
2169
2170                 r = bus_message_new_synthetic_error(
2171                                 bus,
2172                                 m->reply_cookie,
2173                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2174                                 &synthetic_reply);
2175                 if (r < 0)
2176                         return r;
2177
2178                 r = bus_seal_synthetic_message(bus, synthetic_reply);
2179                 if (r < 0)
2180                         return r;
2181
2182                 m = synthetic_reply;
2183         } else {
2184                 r = sd_bus_message_rewind(m, true);
2185                 if (r < 0)
2186                         return r;
2187         }
2188
2189         if (c->timeout != 0) {
2190                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2191                 c->timeout = 0;
2192         }
2193
2194         bus->current_slot = sd_bus_slot_ref(slot);
2195         r = c->callback(bus, m, slot->userdata, &error_buffer);
2196         bus->current_slot = sd_bus_slot_unref(slot);
2197
2198         if (slot->floating) {
2199                 bus_slot_disconnect(slot);
2200                 sd_bus_slot_unref(slot);
2201         }
2202
2203         return bus_maybe_reply_error(m, r, &error_buffer);
2204 }
2205
2206 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2207         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2208         struct filter_callback *l;
2209         int r;
2210
2211         assert(bus);
2212         assert(m);
2213
2214         do {
2215                 bus->filter_callbacks_modified = false;
2216
2217                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2218                         sd_bus_slot *slot;
2219
2220                         if (bus->filter_callbacks_modified)
2221                                 break;
2222
2223                         /* Don't run this more than once per iteration */
2224                         if (l->last_iteration == bus->iteration_counter)
2225                                 continue;
2226
2227                         l->last_iteration = bus->iteration_counter;
2228
2229                         r = sd_bus_message_rewind(m, true);
2230                         if (r < 0)
2231                                 return r;
2232
2233                         slot = container_of(l, sd_bus_slot, filter_callback);
2234
2235                         bus->current_slot = sd_bus_slot_ref(slot);
2236                         r = l->callback(bus, m, slot->userdata, &error_buffer);
2237                         bus->current_slot = sd_bus_slot_unref(slot);
2238
2239                         r = bus_maybe_reply_error(m, r, &error_buffer);
2240                         if (r != 0)
2241                                 return r;
2242
2243                 }
2244
2245         } while (bus->filter_callbacks_modified);
2246
2247         return 0;
2248 }
2249
2250 static int process_match(sd_bus *bus, sd_bus_message *m) {
2251         int r;
2252
2253         assert(bus);
2254         assert(m);
2255
2256         do {
2257                 bus->match_callbacks_modified = false;
2258
2259                 r = bus_match_run(bus, &bus->match_callbacks, m);
2260                 if (r != 0)
2261                         return r;
2262
2263         } while (bus->match_callbacks_modified);
2264
2265         return 0;
2266 }
2267
2268 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2269         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2270         int r;
2271
2272         assert(bus);
2273         assert(m);
2274
2275         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2276                 return 0;
2277
2278         if (bus->manual_peer_interface)
2279                 return 0;
2280
2281         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2282                 return 0;
2283
2284         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2285                 return 0;
2286
2287         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2288                 return 1;
2289
2290         if (streq_ptr(m->member, "Ping"))
2291                 r = sd_bus_message_new_method_return(m, &reply);
2292         else if (streq_ptr(m->member, "GetMachineId")) {
2293                 sd_id128_t id;
2294                 char sid[33];
2295
2296                 r = sd_id128_get_machine(&id);
2297                 if (r < 0)
2298                         return r;
2299
2300                 r = sd_bus_message_new_method_return(m, &reply);
2301                 if (r < 0)
2302                         return r;
2303
2304                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2305         } else {
2306                 r = sd_bus_message_new_method_errorf(
2307                                 m, &reply,
2308                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2309                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2310         }
2311
2312         if (r < 0)
2313                 return r;
2314
2315         r = sd_bus_send(bus, reply, NULL);
2316         if (r < 0)
2317                 return r;
2318
2319         return 1;
2320 }
2321
2322 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2323         assert(bus);
2324         assert(m);
2325
2326         /* If we got a message with a file descriptor which we didn't
2327          * want to accept, then let's drop it. How can this even
2328          * happen? For example, when the kernel queues a message into
2329          * an activatable names's queue which allows fds, and then is
2330          * delivered to us later even though we ourselves did not
2331          * negotiate it. */
2332
2333         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2334                 return 0;
2335
2336         if (m->n_fds <= 0)
2337                 return 0;
2338
2339         if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2340                 return 0;
2341
2342         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2343                 return 1; /* just eat it up */
2344
2345         return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2346 }
2347
2348 static int process_message(sd_bus *bus, sd_bus_message *m) {
2349         int r;
2350
2351         assert(bus);
2352         assert(m);
2353
2354         bus->current_message = m;
2355         bus->iteration_counter++;
2356
2357         log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2358                   bus_message_type_to_string(m->header->type),
2359                   strna(sd_bus_message_get_sender(m)),
2360                   strna(sd_bus_message_get_destination(m)),
2361                   strna(sd_bus_message_get_path(m)),
2362                   strna(sd_bus_message_get_interface(m)),
2363                   strna(sd_bus_message_get_member(m)),
2364                   BUS_MESSAGE_COOKIE(m),
2365                   m->reply_cookie,
2366                   strna(m->error.message));
2367
2368         r = process_hello(bus, m);
2369         if (r != 0)
2370                 goto finish;
2371
2372         r = process_reply(bus, m);
2373         if (r != 0)
2374                 goto finish;
2375
2376         r = process_fd_check(bus, m);
2377         if (r != 0)
2378                 goto finish;
2379
2380         r = process_filter(bus, m);
2381         if (r != 0)
2382                 goto finish;
2383
2384         r = process_match(bus, m);
2385         if (r != 0)
2386                 goto finish;
2387
2388         r = process_builtin(bus, m);
2389         if (r != 0)
2390                 goto finish;
2391
2392         r = bus_process_object(bus, m);
2393
2394 finish:
2395         bus->current_message = NULL;
2396         return r;
2397 }
2398
2399 static int dispatch_track(sd_bus *bus) {
2400         assert(bus);
2401
2402         if (!bus->track_queue)
2403                 return 0;
2404
2405         bus_track_dispatch(bus->track_queue);
2406         return 1;
2407 }
2408
2409 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2410         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2411         int r;
2412
2413         assert(bus);
2414         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2415
2416         r = process_timeout(bus);
2417         if (r != 0)
2418                 goto null_message;
2419
2420         r = dispatch_wqueue(bus);
2421         if (r != 0)
2422                 goto null_message;
2423
2424         r = dispatch_track(bus);
2425         if (r != 0)
2426                 goto null_message;
2427
2428         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2429         if (r < 0)
2430                 return r;
2431         if (!m)
2432                 goto null_message;
2433
2434         r = process_message(bus, m);
2435         if (r != 0)
2436                 goto null_message;
2437
2438         if (ret) {
2439                 r = sd_bus_message_rewind(m, true);
2440                 if (r < 0)
2441                         return r;
2442
2443                 *ret = m;
2444                 m = NULL;
2445                 return 1;
2446         }
2447
2448         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2449
2450                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2451                           strna(sd_bus_message_get_sender(m)),
2452                           strna(sd_bus_message_get_path(m)),
2453                           strna(sd_bus_message_get_interface(m)),
2454                           strna(sd_bus_message_get_member(m)));
2455
2456                 r = sd_bus_reply_method_errorf(
2457                                 m,
2458                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2459                                 "Unknown object '%s'.", m->path);
2460                 if (r < 0)
2461                         return r;
2462         }
2463
2464         return 1;
2465
2466 null_message:
2467         if (r >= 0 && ret)
2468                 *ret = NULL;
2469
2470         return r;
2471 }
2472
2473 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2474         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2475         struct reply_callback *c;
2476         int r;
2477
2478         assert(bus);
2479         assert(bus->state == BUS_CLOSING);
2480
2481         c = hashmap_first(bus->reply_callbacks);
2482         if (c) {
2483                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2484                 sd_bus_slot *slot;
2485
2486                 /* First, fail all outstanding method calls */
2487                 r = bus_message_new_synthetic_error(
2488                                 bus,
2489                                 c->cookie,
2490                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2491                                 &m);
2492                 if (r < 0)
2493                         return r;
2494
2495                 r = bus_seal_synthetic_message(bus, m);
2496                 if (r < 0)
2497                         return r;
2498
2499                 if (c->timeout != 0) {
2500                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2501                         c->timeout = 0;
2502                 }
2503
2504                 hashmap_remove(bus->reply_callbacks, &c->cookie);
2505                 c->cookie = 0;
2506
2507                 slot = container_of(c, sd_bus_slot, reply_callback);
2508
2509                 bus->iteration_counter++;
2510
2511                 bus->current_message = m;
2512                 bus->current_slot = sd_bus_slot_ref(slot);
2513                 r = c->callback(bus, m, slot->userdata, &error_buffer);
2514                 bus->current_slot = sd_bus_slot_unref(slot);
2515                 bus->current_message = NULL;
2516
2517                 if (slot->floating) {
2518                         bus_slot_disconnect(slot);
2519                         sd_bus_slot_unref(slot);
2520                 }
2521
2522                 return bus_maybe_reply_error(m, r, &error_buffer);
2523         }
2524
2525         /* Then, synthesize a Disconnected message */
2526         r = sd_bus_message_new_signal(
2527                         bus,
2528                         &m,
2529                         "/org/freedesktop/DBus/Local",
2530                         "org.freedesktop.DBus.Local",
2531                         "Disconnected");
2532         if (r < 0)
2533                 return r;
2534
2535         m->sender = "org.freedesktop.DBus.Local";
2536
2537         r = bus_seal_synthetic_message(bus, m);
2538         if (r < 0)
2539                 return r;
2540
2541         sd_bus_close(bus);
2542
2543         bus->current_message = m;
2544         bus->iteration_counter++;
2545
2546         r = process_filter(bus, m);
2547         if (r != 0)
2548                 goto finish;
2549
2550         r = process_match(bus, m);
2551         if (r != 0)
2552                 goto finish;
2553
2554         if (ret) {
2555                 *ret = m;
2556                 m = NULL;
2557         }
2558
2559         r = 1;
2560
2561 finish:
2562         bus->current_message = NULL;
2563
2564         return r;
2565 }
2566
2567 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2568         BUS_DONT_DESTROY(bus);
2569         int r;
2570
2571         /* Returns 0 when we didn't do anything. This should cause the
2572          * caller to invoke sd_bus_wait() before returning the next
2573          * time. Returns > 0 when we did something, which possibly
2574          * means *ret is filled in with an unprocessed message. */
2575
2576         assert_return(bus, -EINVAL);
2577         assert_return(!bus_pid_changed(bus), -ECHILD);
2578
2579         /* We don't allow recursively invoking sd_bus_process(). */
2580         assert_return(!bus->current_message, -EBUSY);
2581         assert(!bus->current_slot);
2582
2583         switch (bus->state) {
2584
2585         case BUS_UNSET:
2586                 return -ENOTCONN;
2587
2588         case BUS_CLOSED:
2589                 return -ECONNRESET;
2590
2591         case BUS_OPENING:
2592                 r = bus_socket_process_opening(bus);
2593                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2594                         bus_enter_closing(bus);
2595                         r = 1;
2596                 } else if (r < 0)
2597                         return r;
2598                 if (ret)
2599                         *ret = NULL;
2600                 return r;
2601
2602         case BUS_AUTHENTICATING:
2603                 r = bus_socket_process_authenticating(bus);
2604                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2605                         bus_enter_closing(bus);
2606                         r = 1;
2607                 } else if (r < 0)
2608                         return r;
2609
2610                 if (ret)
2611                         *ret = NULL;
2612
2613                 return r;
2614
2615         case BUS_RUNNING:
2616         case BUS_HELLO:
2617                 r = process_running(bus, hint_priority, priority, ret);
2618                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2619                         bus_enter_closing(bus);
2620                         r = 1;
2621
2622                         if (ret)
2623                                 *ret = NULL;
2624                 }
2625
2626                 return r;
2627
2628         case BUS_CLOSING:
2629                 return process_closing(bus, ret);
2630         }
2631
2632         assert_not_reached("Unknown state");
2633 }
2634
2635 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2636         return bus_process_internal(bus, false, 0, ret);
2637 }
2638
2639 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2640         return bus_process_internal(bus, true, priority, ret);
2641 }
2642
2643 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2644         struct pollfd p[2] = {};
2645         int r, e, n;
2646         struct timespec ts;
2647         usec_t m = (usec_t) -1;
2648
2649         assert(bus);
2650
2651         if (bus->state == BUS_CLOSING)
2652                 return 1;
2653
2654         if (!BUS_IS_OPEN(bus->state))
2655                 return -ENOTCONN;
2656
2657         e = sd_bus_get_events(bus);
2658         if (e < 0)
2659                 return e;
2660
2661         if (need_more)
2662                 /* The caller really needs some more data, he doesn't
2663                  * care about what's already read, or any timeouts
2664                  * except its own.*/
2665                 e |= POLLIN;
2666         else {
2667                 usec_t until;
2668                 /* The caller wants to process if there's something to
2669                  * process, but doesn't care otherwise */
2670
2671                 r = sd_bus_get_timeout(bus, &until);
2672                 if (r < 0)
2673                         return r;
2674                 if (r > 0) {
2675                         usec_t nw;
2676                         nw = now(CLOCK_MONOTONIC);
2677                         m = until > nw ? until - nw : 0;
2678                 }
2679         }
2680
2681         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2682                 m = timeout_usec;
2683
2684         p[0].fd = bus->input_fd;
2685         if (bus->output_fd == bus->input_fd) {
2686                 p[0].events = e;
2687                 n = 1;
2688         } else {
2689                 p[0].events = e & POLLIN;
2690                 p[1].fd = bus->output_fd;
2691                 p[1].events = e & POLLOUT;
2692                 n = 2;
2693         }
2694
2695         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2696         if (r < 0)
2697                 return -errno;
2698
2699         return r > 0 ? 1 : 0;
2700 }
2701
2702 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2703
2704         assert_return(bus, -EINVAL);
2705         assert_return(!bus_pid_changed(bus), -ECHILD);
2706
2707         if (bus->state == BUS_CLOSING)
2708                 return 0;
2709
2710         if (!BUS_IS_OPEN(bus->state))
2711                 return -ENOTCONN;
2712
2713         if (bus->rqueue_size > 0)
2714                 return 0;
2715
2716         return bus_poll(bus, false, timeout_usec);
2717 }
2718
2719 _public_ int sd_bus_flush(sd_bus *bus) {
2720         int r;
2721
2722         assert_return(bus, -EINVAL);
2723         assert_return(!bus_pid_changed(bus), -ECHILD);
2724
2725         if (bus->state == BUS_CLOSING)
2726                 return 0;
2727
2728         if (!BUS_IS_OPEN(bus->state))
2729                 return -ENOTCONN;
2730
2731         r = bus_ensure_running(bus);
2732         if (r < 0)
2733                 return r;
2734
2735         if (bus->wqueue_size <= 0)
2736                 return 0;
2737
2738         for (;;) {
2739                 r = dispatch_wqueue(bus);
2740                 if (r < 0) {
2741                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2742                                 bus_enter_closing(bus);
2743                                 return -ECONNRESET;
2744                         }
2745
2746                         return r;
2747                 }
2748
2749                 if (bus->wqueue_size <= 0)
2750                         return 0;
2751
2752                 r = bus_poll(bus, false, (uint64_t) -1);
2753                 if (r < 0)
2754                         return r;
2755         }
2756 }
2757
2758 _public_ int sd_bus_add_filter(
2759                 sd_bus *bus,
2760                 sd_bus_slot **slot,
2761                 sd_bus_message_handler_t callback,
2762                 void *userdata) {
2763
2764         sd_bus_slot *s;
2765
2766         assert_return(bus, -EINVAL);
2767         assert_return(callback, -EINVAL);
2768         assert_return(!bus_pid_changed(bus), -ECHILD);
2769
2770         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2771         if (!s)
2772                 return -ENOMEM;
2773
2774         s->filter_callback.callback = callback;
2775
2776         bus->filter_callbacks_modified = true;
2777         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2778
2779         if (slot)
2780                 *slot = s;
2781
2782         return 0;
2783 }
2784
2785 _public_ int sd_bus_add_match(
2786                 sd_bus *bus,
2787                 sd_bus_slot **slot,
2788                 const char *match,
2789                 sd_bus_message_handler_t callback,
2790                 void *userdata) {
2791
2792         struct bus_match_component *components = NULL;
2793         unsigned n_components = 0;
2794         sd_bus_slot *s = NULL;
2795         int r = 0;
2796
2797         assert_return(bus, -EINVAL);
2798         assert_return(match, -EINVAL);
2799         assert_return(!bus_pid_changed(bus), -ECHILD);
2800
2801         r = bus_match_parse(match, &components, &n_components);
2802         if (r < 0)
2803                 goto finish;
2804
2805         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2806         if (!s) {
2807                 r = -ENOMEM;
2808                 goto finish;
2809         }
2810
2811         s->match_callback.callback = callback;
2812         s->match_callback.cookie = ++bus->match_cookie;
2813
2814         if (bus->bus_client) {
2815
2816                 if (!bus->is_kernel) {
2817                         /* When this is not a kernel transport, we
2818                          * store the original match string, so that we
2819                          * can use it to remove the match again */
2820
2821                         s->match_callback.match_string = strdup(match);
2822                         if (!s->match_callback.match_string) {
2823                                 r = -ENOMEM;
2824                                 goto finish;
2825                         }
2826                 }
2827
2828                 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2829                 if (r < 0)
2830                         goto finish;
2831         }
2832
2833         bus->match_callbacks_modified = true;
2834         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2835         if (r < 0)
2836                 goto finish;
2837
2838         if (slot)
2839                 *slot = s;
2840         s = NULL;
2841
2842 finish:
2843         bus_match_parse_free(components, n_components);
2844         sd_bus_slot_unref(s);
2845
2846         return r;
2847 }
2848
2849 int bus_remove_match_by_string(
2850                 sd_bus *bus,
2851                 const char *match,
2852                 sd_bus_message_handler_t callback,
2853                 void *userdata) {
2854
2855         struct bus_match_component *components = NULL;
2856         unsigned n_components = 0;
2857         struct match_callback *c;
2858         int r = 0;
2859
2860         assert_return(bus, -EINVAL);
2861         assert_return(match, -EINVAL);
2862         assert_return(!bus_pid_changed(bus), -ECHILD);
2863
2864         r = bus_match_parse(match, &components, &n_components);
2865         if (r < 0)
2866                 goto finish;
2867
2868         r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2869         if (r <= 0)
2870                 goto finish;
2871
2872         sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2873
2874 finish:
2875         bus_match_parse_free(components, n_components);
2876
2877         return r;
2878 }
2879
2880 bool bus_pid_changed(sd_bus *bus) {
2881         assert(bus);
2882
2883         /* We don't support people creating a bus connection and
2884          * keeping it around over a fork(). Let's complain. */
2885
2886         return bus->original_pid != getpid();
2887 }
2888
2889 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2890         sd_bus *bus = userdata;
2891         int r;
2892
2893         assert(bus);
2894
2895         r = sd_bus_process(bus, NULL);
2896         if (r < 0)
2897                 return r;
2898
2899         return 1;
2900 }
2901
2902 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2903         sd_bus *bus = userdata;
2904         int r;
2905
2906         assert(bus);
2907
2908         r = sd_bus_process(bus, NULL);
2909         if (r < 0)
2910                 return r;
2911
2912         return 1;
2913 }
2914
2915 static int prepare_callback(sd_event_source *s, void *userdata) {
2916         sd_bus *bus = userdata;
2917         int r, e;
2918         usec_t until;
2919
2920         assert(s);
2921         assert(bus);
2922
2923         e = sd_bus_get_events(bus);
2924         if (e < 0)
2925                 return e;
2926
2927         if (bus->output_fd != bus->input_fd) {
2928
2929                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2930                 if (r < 0)
2931                         return r;
2932
2933                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2934                 if (r < 0)
2935                         return r;
2936         } else {
2937                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2938                 if (r < 0)
2939                         return r;
2940         }
2941
2942         r = sd_bus_get_timeout(bus, &until);
2943         if (r < 0)
2944                 return r;
2945         if (r > 0) {
2946                 int j;
2947
2948                 j = sd_event_source_set_time(bus->time_event_source, until);
2949                 if (j < 0)
2950                         return j;
2951         }
2952
2953         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2954         if (r < 0)
2955                 return r;
2956
2957         return 1;
2958 }
2959
2960 static int quit_callback(sd_event_source *event, void *userdata) {
2961         sd_bus *bus = userdata;
2962
2963         assert(event);
2964
2965         sd_bus_flush(bus);
2966         sd_bus_close(bus);
2967
2968         return 1;
2969 }
2970
2971 static int attach_io_events(sd_bus *bus) {
2972         int r;
2973
2974         assert(bus);
2975
2976         if (bus->input_fd < 0)
2977                 return 0;
2978
2979         if (!bus->event)
2980                 return 0;
2981
2982         if (!bus->input_io_event_source) {
2983                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
2984                 if (r < 0)
2985                         return r;
2986
2987                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2988                 if (r < 0)
2989                         return r;
2990
2991                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2992         } else
2993                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2994
2995         if (r < 0)
2996                 return r;
2997
2998         if (bus->output_fd != bus->input_fd) {
2999                 assert(bus->output_fd >= 0);
3000
3001                 if (!bus->output_io_event_source) {
3002                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3003                         if (r < 0)
3004                                 return r;
3005
3006                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3007                 } else
3008                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3009
3010                 if (r < 0)
3011                         return r;
3012         }
3013
3014         return 0;
3015 }
3016
3017 static void detach_io_events(sd_bus *bus) {
3018         assert(bus);
3019
3020         if (bus->input_io_event_source) {
3021                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3022                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3023         }
3024
3025         if (bus->output_io_event_source) {
3026                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3027                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3028         }
3029 }
3030
3031 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3032         int r;
3033
3034         assert_return(bus, -EINVAL);
3035         assert_return(!bus->event, -EBUSY);
3036
3037         assert(!bus->input_io_event_source);
3038         assert(!bus->output_io_event_source);
3039         assert(!bus->time_event_source);
3040
3041         if (event)
3042                 bus->event = sd_event_ref(event);
3043         else  {
3044                 r = sd_event_default(&bus->event);
3045                 if (r < 0)
3046                         return r;
3047         }
3048
3049         bus->event_priority = priority;
3050
3051         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3052         if (r < 0)
3053                 goto fail;
3054
3055         r = sd_event_source_set_priority(bus->time_event_source, priority);
3056         if (r < 0)
3057                 goto fail;
3058
3059         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3060         if (r < 0)
3061                 goto fail;
3062
3063         r = attach_io_events(bus);
3064         if (r < 0)
3065                 goto fail;
3066
3067         return 0;
3068
3069 fail:
3070         sd_bus_detach_event(bus);
3071         return r;
3072 }
3073
3074 _public_ int sd_bus_detach_event(sd_bus *bus) {
3075         assert_return(bus, -EINVAL);
3076
3077         if (!bus->event)
3078                 return 0;
3079
3080         detach_io_events(bus);
3081
3082         if (bus->time_event_source) {
3083                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3084                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3085         }
3086
3087         if (bus->quit_event_source) {
3088                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3089                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3090         }
3091
3092         bus->event = sd_event_unref(bus->event);
3093         return 1;
3094 }
3095
3096 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3097         assert_return(bus, NULL);
3098
3099         return bus->event;
3100 }
3101
3102 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3103         assert_return(bus, NULL);
3104
3105         return bus->current_message;
3106 }
3107
3108 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3109         assert_return(bus, NULL);
3110
3111         return bus->current_slot;
3112 }
3113
3114 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3115         sd_bus *b = NULL;
3116         int r;
3117
3118         assert(bus_open);
3119         assert(default_bus);
3120
3121         if (!ret)
3122                 return !!*default_bus;
3123
3124         if (*default_bus) {
3125                 *ret = sd_bus_ref(*default_bus);
3126                 return 0;
3127         }
3128
3129         r = bus_open(&b);
3130         if (r < 0)
3131                 return r;
3132
3133         b->default_bus_ptr = default_bus;
3134         b->tid = gettid();
3135         *default_bus = b;
3136
3137         *ret = b;
3138         return 1;
3139 }
3140
3141 _public_ int sd_bus_default_system(sd_bus **ret) {
3142         static thread_local sd_bus *default_system_bus = NULL;
3143
3144         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3145 }
3146
3147 _public_ int sd_bus_default_user(sd_bus **ret) {
3148         static thread_local sd_bus *default_user_bus = NULL;
3149
3150         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3151 }
3152
3153 _public_ int sd_bus_default(sd_bus **ret) {
3154
3155         const char *e;
3156
3157         /* Let's try our best to reuse another cached connection. If
3158          * the starter bus type is set, connect via our normal
3159          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3160          * we can share the connection with the user/system default
3161          * bus. */
3162
3163         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3164         if (e) {
3165                 if (streq(e, "system"))
3166                         return sd_bus_default_system(ret);
3167                 else if (STR_IN_SET(e, "user", "session"))
3168                         return sd_bus_default_user(ret);
3169         }
3170
3171         /* No type is specified, so we have not other option than to
3172          * use the starter address if it is set. */
3173
3174         e = secure_getenv("DBUS_STARTER_ADDRESS");
3175         if (e) {
3176                 static thread_local sd_bus *default_starter_bus = NULL;
3177
3178                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3179         }
3180
3181         /* Finally, if nothing is set use the cached connection for
3182          * the right scope */
3183
3184         if (cg_pid_get_owner_uid(0, NULL) >= 0)
3185                 return sd_bus_default_user(ret);
3186         else
3187                 return sd_bus_default_system(ret);
3188 }
3189
3190 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3191         assert_return(b, -EINVAL);
3192         assert_return(tid, -EINVAL);
3193         assert_return(!bus_pid_changed(b), -ECHILD);
3194
3195         if (b->tid != 0) {
3196                 *tid = b->tid;
3197                 return 0;
3198         }
3199
3200         if (b->event)
3201                 return sd_event_get_tid(b->event, tid);
3202
3203         return -ENXIO;
3204 }
3205
3206 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3207         _cleanup_free_ char *e = NULL;
3208         char *ret;
3209
3210         assert_return(object_path_is_valid(prefix), -EINVAL);
3211         assert_return(external_id, -EINVAL);
3212         assert_return(ret_path, -EINVAL);
3213
3214         e = bus_label_escape(external_id);
3215         if (!e)
3216                 return -ENOMEM;
3217
3218         ret = strjoin(prefix, "/", e, NULL);
3219         if (!ret)
3220                 return -ENOMEM;
3221
3222         *ret_path = ret;
3223         return 0;
3224 }
3225
3226 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3227         const char *e;
3228         char *ret;
3229
3230         assert_return(object_path_is_valid(path), -EINVAL);
3231         assert_return(object_path_is_valid(prefix), -EINVAL);
3232         assert_return(external_id, -EINVAL);
3233
3234         e = object_path_startswith(path, prefix);
3235         if (!e) {
3236                 *external_id = NULL;
3237                 return 0;
3238         }
3239
3240         ret = bus_label_unescape(e);
3241         if (!ret)
3242                 return -ENOMEM;
3243
3244         *external_id = ret;
3245         return 1;
3246 }
3247
3248 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3249         sd_bus_creds *c;
3250         pid_t pid = 0;
3251         int r;
3252
3253         assert_return(bus, -EINVAL);
3254         assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3255         assert_return(ret, -EINVAL);
3256         assert_return(!bus_pid_changed(bus), -ECHILD);
3257
3258         if (bus->is_kernel)
3259                 return -ENOTSUP;
3260
3261         if (!BUS_IS_OPEN(bus->state))
3262                 return -ENOTCONN;
3263
3264         if (!bus->ucred_valid && !isempty(bus->label))
3265                 return -ENODATA;
3266
3267         c = bus_creds_new();
3268         if (!c)
3269                 return -ENOMEM;
3270
3271         if (bus->ucred_valid) {
3272                 pid = c->pid = bus->ucred.pid;
3273                 c->uid = bus->ucred.uid;
3274                 c->gid = bus->ucred.gid;
3275
3276                 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3277         }
3278
3279         if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3280                 c->label = strdup(bus->label);
3281                 if (!c->label) {
3282                         sd_bus_creds_unref(c);
3283                         return -ENOMEM;
3284                 }
3285
3286                 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3287         }
3288
3289         r = bus_creds_add_more(c, mask, pid, 0);
3290         if (r < 0)
3291                 return r;
3292
3293         *ret = c;
3294         return 0;
3295 }
3296
3297 _public_ int sd_bus_try_close(sd_bus *bus) {
3298         int r;
3299
3300         assert_return(bus, -EINVAL);
3301         assert_return(!bus_pid_changed(bus), -ECHILD);
3302
3303         if (!bus->is_kernel)
3304                 return -ENOTSUP;
3305
3306         if (!BUS_IS_OPEN(bus->state))
3307                 return -ENOTCONN;
3308
3309         if (bus->rqueue_size > 0)
3310                 return -EBUSY;
3311
3312         if (bus->wqueue_size > 0)
3313                 return -EBUSY;
3314
3315         r = bus_kernel_try_close(bus);
3316         if (r < 0)
3317                 return r;
3318
3319         sd_bus_close(bus);
3320         return 0;
3321 }
3322
3323 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3324         assert_return(bus, -EINVAL);
3325         assert_return(name, -EINVAL);
3326         assert_return(!bus_pid_changed(bus), -ECHILD);
3327
3328         *name = bus->connection_name;
3329         return 0;
3330 }