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

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