src/libsystemd/sd-bus/sd-bus.c

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