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 int process_closing(sd_bus *bus, sd_bus_message **ret) {
2509         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2510         struct reply_callback *c;
2511         int r;
2512
2513         assert(bus);
2514         assert(bus->state == BUS_CLOSING);
2515
2516         c = ordered_hashmap_first(bus->reply_callbacks);
2517         if (c) {
2518                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2519                 sd_bus_slot *slot;
2520
2521                 /* First, fail all outstanding method calls */
2522                 r = bus_message_new_synthetic_error(
2523                                 bus,
2524                                 c->cookie,
2525                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2526                                 &m);
2527                 if (r < 0)
2528                         return r;
2529
2530                 r = bus_seal_synthetic_message(bus, m);
2531                 if (r < 0)
2532                         return r;
2533
2534                 if (c->timeout != 0) {
2535                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2536                         c->timeout = 0;
2537                 }
2538
2539                 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2540                 c->cookie = 0;
2541
2542                 slot = container_of(c, sd_bus_slot, reply_callback);
2543
2544                 bus->iteration_counter++;
2545
2546                 bus->current_message = m;
2547                 bus->current_slot = sd_bus_slot_ref(slot);
2548                 bus->current_handler = c->callback;
2549                 bus->current_userdata = slot->userdata;
2550                 r = c->callback(bus, m, slot->userdata, &error_buffer);
2551                 bus->current_userdata = NULL;
2552                 bus->current_handler = NULL;
2553                 bus->current_slot = NULL;
2554                 bus->current_message = NULL;
2555
2556                 if (slot->floating) {
2557                         bus_slot_disconnect(slot);
2558                         sd_bus_slot_unref(slot);
2559                 }
2560
2561                 sd_bus_slot_unref(slot);
2562
2563                 return bus_maybe_reply_error(m, r, &error_buffer);
2564         }
2565
2566         /* Then, synthesize a Disconnected message */
2567         r = sd_bus_message_new_signal(
2568                         bus,
2569                         &m,
2570                         "/org/freedesktop/DBus/Local",
2571                         "org.freedesktop.DBus.Local",
2572                         "Disconnected");
2573         if (r < 0)
2574                 return r;
2575
2576         m->sender = "org.freedesktop.DBus.Local";
2577
2578         r = bus_seal_synthetic_message(bus, m);
2579         if (r < 0)
2580                 return r;
2581
2582         sd_bus_close(bus);
2583
2584         bus->current_message = m;
2585         bus->iteration_counter++;
2586
2587         r = process_filter(bus, m);
2588         if (r != 0)
2589                 goto finish;
2590
2591         r = process_match(bus, m);
2592         if (r != 0)
2593                 goto finish;
2594
2595         if (ret) {
2596                 *ret = m;
2597                 m = NULL;
2598         }
2599
2600         r = 1;
2601
2602 finish:
2603         bus->current_message = NULL;
2604
2605         return r;
2606 }
2607
2608 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2609         BUS_DONT_DESTROY(bus);
2610         int r;
2611
2612         /* Returns 0 when we didn't do anything. This should cause the
2613          * caller to invoke sd_bus_wait() before returning the next
2614          * time. Returns > 0 when we did something, which possibly
2615          * means *ret is filled in with an unprocessed message. */
2616
2617         assert_return(bus, -EINVAL);
2618         assert_return(!bus_pid_changed(bus), -ECHILD);
2619
2620         /* We don't allow recursively invoking sd_bus_process(). */
2621         assert_return(!bus->current_message, -EBUSY);
2622         assert(!bus->current_slot);
2623
2624         switch (bus->state) {
2625
2626         case BUS_UNSET:
2627                 return -ENOTCONN;
2628
2629         case BUS_CLOSED:
2630                 return -ECONNRESET;
2631
2632         case BUS_OPENING:
2633                 r = bus_socket_process_opening(bus);
2634                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2635                         bus_enter_closing(bus);
2636                         r = 1;
2637                 } else if (r < 0)
2638                         return r;
2639                 if (ret)
2640                         *ret = NULL;
2641                 return r;
2642
2643         case BUS_AUTHENTICATING:
2644                 r = bus_socket_process_authenticating(bus);
2645                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2646                         bus_enter_closing(bus);
2647                         r = 1;
2648                 } else if (r < 0)
2649                         return r;
2650
2651                 if (ret)
2652                         *ret = NULL;
2653
2654                 return r;
2655
2656         case BUS_RUNNING:
2657         case BUS_HELLO:
2658                 r = process_running(bus, hint_priority, priority, ret);
2659                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2660                         bus_enter_closing(bus);
2661                         r = 1;
2662
2663                         if (ret)
2664                                 *ret = NULL;
2665                 }
2666
2667                 return r;
2668
2669         case BUS_CLOSING:
2670                 return process_closing(bus, ret);
2671         }
2672
2673         assert_not_reached("Unknown state");
2674 }
2675
2676 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2677         return bus_process_internal(bus, false, 0, ret);
2678 }
2679
2680 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2681         return bus_process_internal(bus, true, priority, ret);
2682 }
2683
2684 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2685         struct pollfd p[2] = {};
2686         int r, e, n;
2687         struct timespec ts;
2688         usec_t m = USEC_INFINITY;
2689
2690         assert(bus);
2691
2692         if (bus->state == BUS_CLOSING)
2693                 return 1;
2694
2695         if (!BUS_IS_OPEN(bus->state))
2696                 return -ENOTCONN;
2697
2698         e = sd_bus_get_events(bus);
2699         if (e < 0)
2700                 return e;
2701
2702         if (need_more)
2703                 /* The caller really needs some more data, he doesn't
2704                  * care about what's already read, or any timeouts
2705                  * except its own.*/
2706                 e |= POLLIN;
2707         else {
2708                 usec_t until;
2709                 /* The caller wants to process if there's something to
2710                  * process, but doesn't care otherwise */
2711
2712                 r = sd_bus_get_timeout(bus, &until);
2713                 if (r < 0)
2714                         return r;
2715                 if (r > 0) {
2716                         usec_t nw;
2717                         nw = now(CLOCK_MONOTONIC);
2718                         m = until > nw ? until - nw : 0;
2719                 }
2720         }
2721
2722         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2723                 m = timeout_usec;
2724
2725         p[0].fd = bus->input_fd;
2726         if (bus->output_fd == bus->input_fd) {
2727                 p[0].events = e;
2728                 n = 1;
2729         } else {
2730                 p[0].events = e & POLLIN;
2731                 p[1].fd = bus->output_fd;
2732                 p[1].events = e & POLLOUT;
2733                 n = 2;
2734         }
2735
2736         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2737         if (r < 0)
2738                 return -errno;
2739
2740         return r > 0 ? 1 : 0;
2741 }
2742
2743 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2744
2745         assert_return(bus, -EINVAL);
2746         assert_return(!bus_pid_changed(bus), -ECHILD);
2747
2748         if (bus->state == BUS_CLOSING)
2749                 return 0;
2750
2751         if (!BUS_IS_OPEN(bus->state))
2752                 return -ENOTCONN;
2753
2754         if (bus->rqueue_size > 0)
2755                 return 0;
2756
2757         return bus_poll(bus, false, timeout_usec);
2758 }
2759
2760 _public_ int sd_bus_flush(sd_bus *bus) {
2761         int r;
2762
2763         assert_return(bus, -EINVAL);
2764         assert_return(!bus_pid_changed(bus), -ECHILD);
2765
2766         if (bus->state == BUS_CLOSING)
2767                 return 0;
2768
2769         if (!BUS_IS_OPEN(bus->state))
2770                 return -ENOTCONN;
2771
2772         r = bus_ensure_running(bus);
2773         if (r < 0)
2774                 return r;
2775
2776         if (bus->wqueue_size <= 0)
2777                 return 0;
2778
2779         for (;;) {
2780                 r = dispatch_wqueue(bus);
2781                 if (r < 0) {
2782                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2783                                 bus_enter_closing(bus);
2784                                 return -ECONNRESET;
2785                         }
2786
2787                         return r;
2788                 }
2789
2790                 if (bus->wqueue_size <= 0)
2791                         return 0;
2792
2793                 r = bus_poll(bus, false, (uint64_t) -1);
2794                 if (r < 0)
2795                         return r;
2796         }
2797 }
2798
2799 _public_ int sd_bus_add_filter(
2800                 sd_bus *bus,
2801                 sd_bus_slot **slot,
2802                 sd_bus_message_handler_t callback,
2803                 void *userdata) {
2804
2805         sd_bus_slot *s;
2806
2807         assert_return(bus, -EINVAL);
2808         assert_return(callback, -EINVAL);
2809         assert_return(!bus_pid_changed(bus), -ECHILD);
2810
2811         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2812         if (!s)
2813                 return -ENOMEM;
2814
2815         s->filter_callback.callback = callback;
2816
2817         bus->filter_callbacks_modified = true;
2818         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2819
2820         if (slot)
2821                 *slot = s;
2822
2823         return 0;
2824 }
2825
2826 _public_ int sd_bus_add_match(
2827                 sd_bus *bus,
2828                 sd_bus_slot **slot,
2829                 const char *match,
2830                 sd_bus_message_handler_t callback,
2831                 void *userdata) {
2832
2833         struct bus_match_component *components = NULL;
2834         unsigned n_components = 0;
2835         sd_bus_slot *s = NULL;
2836         int r = 0;
2837
2838         assert_return(bus, -EINVAL);
2839         assert_return(match, -EINVAL);
2840         assert_return(!bus_pid_changed(bus), -ECHILD);
2841
2842         r = bus_match_parse(match, &components, &n_components);
2843         if (r < 0)
2844                 goto finish;
2845
2846         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2847         if (!s) {
2848                 r = -ENOMEM;
2849                 goto finish;
2850         }
2851
2852         s->match_callback.callback = callback;
2853         s->match_callback.cookie = ++bus->match_cookie;
2854
2855         if (bus->bus_client) {
2856
2857                 if (!bus->is_kernel) {
2858                         /* When this is not a kernel transport, we
2859                          * store the original match string, so that we
2860                          * can use it to remove the match again */
2861
2862                         s->match_callback.match_string = strdup(match);
2863                         if (!s->match_callback.match_string) {
2864                                 r = -ENOMEM;
2865                                 goto finish;
2866                         }
2867                 }
2868
2869                 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2870                 if (r < 0)
2871                         goto finish;
2872         }
2873
2874         bus->match_callbacks_modified = true;
2875         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2876         if (r < 0)
2877                 goto finish;
2878
2879         if (slot)
2880                 *slot = s;
2881         s = NULL;
2882
2883 finish:
2884         bus_match_parse_free(components, n_components);
2885         sd_bus_slot_unref(s);
2886
2887         return r;
2888 }
2889
2890 int bus_remove_match_by_string(
2891                 sd_bus *bus,
2892                 const char *match,
2893                 sd_bus_message_handler_t callback,
2894                 void *userdata) {
2895
2896         struct bus_match_component *components = NULL;
2897         unsigned n_components = 0;
2898         struct match_callback *c;
2899         int r = 0;
2900
2901         assert_return(bus, -EINVAL);
2902         assert_return(match, -EINVAL);
2903         assert_return(!bus_pid_changed(bus), -ECHILD);
2904
2905         r = bus_match_parse(match, &components, &n_components);
2906         if (r < 0)
2907                 goto finish;
2908
2909         r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2910         if (r <= 0)
2911                 goto finish;
2912
2913         sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2914
2915 finish:
2916         bus_match_parse_free(components, n_components);
2917
2918         return r;
2919 }
2920
2921 bool bus_pid_changed(sd_bus *bus) {
2922         assert(bus);
2923
2924         /* We don't support people creating a bus connection and
2925          * keeping it around over a fork(). Let's complain. */
2926
2927         return bus->original_pid != getpid();
2928 }
2929
2930 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2931         sd_bus *bus = userdata;
2932         int r;
2933
2934         assert(bus);
2935
2936         r = sd_bus_process(bus, NULL);
2937         if (r < 0)
2938                 return r;
2939
2940         return 1;
2941 }
2942
2943 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2944         sd_bus *bus = userdata;
2945         int r;
2946
2947         assert(bus);
2948
2949         r = sd_bus_process(bus, NULL);
2950         if (r < 0)
2951                 return r;
2952
2953         return 1;
2954 }
2955
2956 static int prepare_callback(sd_event_source *s, void *userdata) {
2957         sd_bus *bus = userdata;
2958         int r, e;
2959         usec_t until;
2960
2961         assert(s);
2962         assert(bus);
2963
2964         e = sd_bus_get_events(bus);
2965         if (e < 0)
2966                 return e;
2967
2968         if (bus->output_fd != bus->input_fd) {
2969
2970                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2971                 if (r < 0)
2972                         return r;
2973
2974                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2975                 if (r < 0)
2976                         return r;
2977         } else {
2978                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2979                 if (r < 0)
2980                         return r;
2981         }
2982
2983         r = sd_bus_get_timeout(bus, &until);
2984         if (r < 0)
2985                 return r;
2986         if (r > 0) {
2987                 int j;
2988
2989                 j = sd_event_source_set_time(bus->time_event_source, until);
2990                 if (j < 0)
2991                         return j;
2992         }
2993
2994         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2995         if (r < 0)
2996                 return r;
2997
2998         return 1;
2999 }
3000
3001 static int quit_callback(sd_event_source *event, void *userdata) {
3002         sd_bus *bus = userdata;
3003
3004         assert(event);
3005
3006         sd_bus_flush(bus);
3007         sd_bus_close(bus);
3008
3009         return 1;
3010 }
3011
3012 static int attach_io_events(sd_bus *bus) {
3013         int r;
3014
3015         assert(bus);
3016
3017         if (bus->input_fd < 0)
3018                 return 0;
3019
3020         if (!bus->event)
3021                 return 0;
3022
3023         if (!bus->input_io_event_source) {
3024                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3025                 if (r < 0)
3026                         return r;
3027
3028                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3029                 if (r < 0)
3030                         return r;
3031
3032                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3033                 if (r < 0)
3034                         return r;
3035
3036                 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3037         } else
3038                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3039
3040         if (r < 0)
3041                 return r;
3042
3043         if (bus->output_fd != bus->input_fd) {
3044                 assert(bus->output_fd >= 0);
3045
3046                 if (!bus->output_io_event_source) {
3047                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3048                         if (r < 0)
3049                                 return r;
3050
3051                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3052                         if (r < 0)
3053                                 return r;
3054
3055                         r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3056                 } else
3057                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3058
3059                 if (r < 0)
3060                         return r;
3061         }
3062
3063         return 0;
3064 }
3065
3066 static void detach_io_events(sd_bus *bus) {
3067         assert(bus);
3068
3069         if (bus->input_io_event_source) {
3070                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3071                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3072         }
3073
3074         if (bus->output_io_event_source) {
3075                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3076                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3077         }
3078 }
3079
3080 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3081         int r;
3082
3083         assert_return(bus, -EINVAL);
3084         assert_return(!bus->event, -EBUSY);
3085
3086         assert(!bus->input_io_event_source);
3087         assert(!bus->output_io_event_source);
3088         assert(!bus->time_event_source);
3089
3090         if (event)
3091                 bus->event = sd_event_ref(event);
3092         else  {
3093                 r = sd_event_default(&bus->event);
3094                 if (r < 0)
3095                         return r;
3096         }
3097
3098         bus->event_priority = priority;
3099
3100         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3101         if (r < 0)
3102                 goto fail;
3103
3104         r = sd_event_source_set_priority(bus->time_event_source, priority);
3105         if (r < 0)
3106                 goto fail;
3107
3108         r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3109         if (r < 0)
3110                 goto fail;
3111
3112         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3113         if (r < 0)
3114                 goto fail;
3115
3116         r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3117         if (r < 0)
3118                 goto fail;
3119
3120         r = attach_io_events(bus);
3121         if (r < 0)
3122                 goto fail;
3123
3124         return 0;
3125
3126 fail:
3127         sd_bus_detach_event(bus);
3128         return r;
3129 }
3130
3131 _public_ int sd_bus_detach_event(sd_bus *bus) {
3132         assert_return(bus, -EINVAL);
3133
3134         if (!bus->event)
3135                 return 0;
3136
3137         detach_io_events(bus);
3138
3139         if (bus->time_event_source) {
3140                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3141                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3142         }
3143
3144         if (bus->quit_event_source) {
3145                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3146                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3147         }
3148
3149         bus->event = sd_event_unref(bus->event);
3150         return 1;
3151 }
3152
3153 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3154         assert_return(bus, NULL);
3155
3156         return bus->event;
3157 }
3158
3159 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3160         assert_return(bus, NULL);
3161
3162         return bus->current_message;
3163 }
3164
3165 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3166         assert_return(bus, NULL);
3167
3168         return bus->current_slot;
3169 }
3170
3171 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3172         assert_return(bus, NULL);
3173
3174         return bus->current_handler;
3175 }
3176
3177 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3178         assert_return(bus, NULL);
3179
3180         return bus->current_userdata;
3181 }
3182
3183 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3184         sd_bus *b = NULL;
3185         int r;
3186
3187         assert(bus_open);
3188         assert(default_bus);
3189
3190         if (!ret)
3191                 return !!*default_bus;
3192
3193         if (*default_bus) {
3194                 *ret = sd_bus_ref(*default_bus);
3195                 return 0;
3196         }
3197
3198         r = bus_open(&b);
3199         if (r < 0)
3200                 return r;
3201
3202         b->default_bus_ptr = default_bus;
3203         b->tid = gettid();
3204         *default_bus = b;
3205
3206         *ret = b;
3207         return 1;
3208 }
3209
3210 _public_ int sd_bus_default_system(sd_bus **ret) {
3211         static thread_local sd_bus *default_system_bus = NULL;
3212
3213         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3214 }
3215
3216 _public_ int sd_bus_default_user(sd_bus **ret) {
3217         static thread_local sd_bus *default_user_bus = NULL;
3218
3219         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3220 }
3221
3222 _public_ int sd_bus_default(sd_bus **ret) {
3223
3224         const char *e;
3225
3226         /* Let's try our best to reuse another cached connection. If
3227          * the starter bus type is set, connect via our normal
3228          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3229          * we can share the connection with the user/system default
3230          * bus. */
3231
3232         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3233         if (e) {
3234                 if (streq(e, "system"))
3235                         return sd_bus_default_system(ret);
3236                 else if (STR_IN_SET(e, "user", "session"))
3237                         return sd_bus_default_user(ret);
3238         }
3239
3240         /* No type is specified, so we have not other option than to
3241          * use the starter address if it is set. */
3242
3243         e = secure_getenv("DBUS_STARTER_ADDRESS");
3244         if (e) {
3245                 static thread_local sd_bus *default_starter_bus = NULL;
3246
3247                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3248         }
3249
3250         /* Finally, if nothing is set use the cached connection for
3251          * the right scope */
3252
3253         if (cg_pid_get_owner_uid(0, NULL) >= 0)
3254                 return sd_bus_default_user(ret);
3255         else
3256                 return sd_bus_default_system(ret);
3257 }
3258
3259 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3260         assert_return(b, -EINVAL);
3261         assert_return(tid, -EINVAL);
3262         assert_return(!bus_pid_changed(b), -ECHILD);
3263
3264         if (b->tid != 0) {
3265                 *tid = b->tid;
3266                 return 0;
3267         }
3268
3269         if (b->event)
3270                 return sd_event_get_tid(b->event, tid);
3271
3272         return -ENXIO;
3273 }
3274
3275 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3276         _cleanup_free_ char *e = NULL;
3277         char *ret;
3278
3279         assert_return(object_path_is_valid(prefix), -EINVAL);
3280         assert_return(external_id, -EINVAL);
3281         assert_return(ret_path, -EINVAL);
3282
3283         e = bus_label_escape(external_id);
3284         if (!e)
3285                 return -ENOMEM;
3286
3287         ret = strjoin(prefix, "/", e, NULL);
3288         if (!ret)
3289                 return -ENOMEM;
3290
3291         *ret_path = ret;
3292         return 0;
3293 }
3294
3295 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3296         const char *e;
3297         char *ret;
3298
3299         assert_return(object_path_is_valid(path), -EINVAL);
3300         assert_return(object_path_is_valid(prefix), -EINVAL);
3301         assert_return(external_id, -EINVAL);
3302
3303         e = object_path_startswith(path, prefix);
3304         if (!e) {
3305                 *external_id = NULL;
3306                 return 0;
3307         }
3308
3309         ret = bus_label_unescape(e);
3310         if (!ret)
3311                 return -ENOMEM;
3312
3313         *external_id = ret;
3314         return 1;
3315 }
3316
3317 _public_ int sd_bus_try_close(sd_bus *bus) {
3318         int r;
3319
3320         assert_return(bus, -EINVAL);
3321         assert_return(!bus_pid_changed(bus), -ECHILD);
3322
3323         if (!bus->is_kernel)
3324                 return -ENOTSUP;
3325
3326         if (!BUS_IS_OPEN(bus->state))
3327                 return -ENOTCONN;
3328
3329         if (bus->rqueue_size > 0)
3330                 return -EBUSY;
3331
3332         if (bus->wqueue_size > 0)
3333                 return -EBUSY;
3334
3335         r = bus_kernel_try_close(bus);
3336         if (r < 0)
3337                 return r;
3338
3339         sd_bus_close(bus);
3340         return 0;
3341 }
3342
3343 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3344         assert_return(bus, -EINVAL);
3345         assert_return(description, -EINVAL);
3346         assert_return(bus->description, -ENXIO);
3347         assert_return(!bus_pid_changed(bus), -ECHILD);
3348
3349         *description = bus->description;
3350         return 0;
3351 }
3352
3353 int bus_get_root_path(sd_bus *bus) {
3354         int r;
3355
3356         if (bus->cgroup_root)
3357                 return 0;
3358
3359         r = cg_get_root_path(&bus->cgroup_root);
3360         if (r == -ENOENT) {
3361                 bus->cgroup_root = strdup("/");
3362                 if (!bus->cgroup_root)
3363                         return -ENOMEM;
3364
3365                 r = 0;
3366         }
3367
3368         return r;
3369 }