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

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