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