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