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