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

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