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