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