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