src/libsystemd/sd-bus/sd-bus.c

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