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