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

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <endian.h>
  23 #include <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                 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1128                         return sd_bus_open_user(ret);
1129                 else
1130                         return sd_bus_open_system(ret);
1131         }
1132
1133         r = sd_bus_new(&b);
1134         if (r < 0)
1135                 return r;
1136
1137         r = sd_bus_set_address(b, e);
1138         if (r < 0)
1139                 goto fail;
1140
1141         b->bus_client = true;
1142
1143         /* We don't know whether the bus is trusted or not, so better
1144          * be safe, and authenticate everything */
1145         b->trusted = false;
1146         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1147         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1148
1149         r = sd_bus_start(b);
1150         if (r < 0)
1151                 goto fail;
1152
1153         *ret = b;
1154         return 0;
1155
1156 fail:
1157         bus_free(b);
1158         return r;
1159 }
1160
1161 int bus_set_address_system(sd_bus *b) {
1162         const char *e;
1163         assert(b);
1164
1165         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1166         if (e)
1167                 return sd_bus_set_address(b, e);
1168
1169         return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1170 }
1171
1172 _public_ int sd_bus_open_system(sd_bus **ret) {
1173         sd_bus *b;
1174         int r;
1175
1176         assert_return(ret, -EINVAL);
1177
1178         r = sd_bus_new(&b);
1179         if (r < 0)
1180                 return r;
1181
1182         r = bus_set_address_system(b);
1183         if (r < 0)
1184                 goto fail;
1185
1186         b->bus_client = true;
1187         b->is_system = true;
1188
1189         /* Let's do per-method access control on the system bus. We
1190          * need the caller's UID and capability set for that. */
1191         b->trusted = false;
1192         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1193         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1194
1195         r = sd_bus_start(b);
1196         if (r < 0)
1197                 goto fail;
1198
1199         *ret = b;
1200         return 0;
1201
1202 fail:
1203         bus_free(b);
1204         return r;
1205 }
1206
1207 int bus_set_address_user(sd_bus *b) {
1208         const char *e;
1209
1210         assert(b);
1211
1212         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1213         if (e)
1214                 return sd_bus_set_address(b, e);
1215
1216         e = secure_getenv("XDG_RUNTIME_DIR");
1217         if (e) {
1218                 _cleanup_free_ char *ee = NULL;
1219
1220                 ee = bus_address_escape(e);
1221                 if (!ee)
1222                         return -ENOMEM;
1223
1224 #ifdef ENABLE_KDBUS
1225                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1226 #else
1227                 (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);
1228 #endif
1229         } else {
1230 #ifdef ENABLE_KDBUS
1231                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1232 #else
1233                 return -ECONNREFUSED;
1234 #endif
1235         }
1236
1237         if (!b->address)
1238                 return -ENOMEM;
1239
1240         return 0;
1241 }
1242
1243 _public_ int sd_bus_open_user(sd_bus **ret) {
1244         sd_bus *b;
1245         int r;
1246
1247         assert_return(ret, -EINVAL);
1248
1249         r = sd_bus_new(&b);
1250         if (r < 0)
1251                 return r;
1252
1253         r = bus_set_address_user(b);
1254         if (r < 0)
1255                 return r;
1256
1257         b->bus_client = true;
1258         b->is_user = true;
1259
1260         /* We don't do any per-method access control on the user
1261          * bus. */
1262         b->trusted = true;
1263
1264         r = sd_bus_start(b);
1265         if (r < 0)
1266                 goto fail;
1267
1268         *ret = b;
1269         return 0;
1270
1271 fail:
1272         bus_free(b);
1273         return r;
1274 }
1275
1276 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1277         _cleanup_free_ char *e = NULL;
1278         char *m = NULL, *c = NULL;
1279
1280         assert(b);
1281         assert(host);
1282
1283         /* Let's see if we shall enter some container */
1284         m = strchr(host, ':');
1285         if (m) {
1286                 m++;
1287
1288                 /* Let's make sure this is not a port of some kind,
1289                  * and is a valid machine name. */
1290                 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1291                         char *t;
1292
1293                         /* Cut out the host part */
1294                         t = strndupa(host, m - host - 1);
1295                         e = bus_address_escape(t);
1296                         if (!e)
1297                                 return -ENOMEM;
1298
1299                         c = strjoina(",argv4=--machine=", m);
1300                 }
1301         }
1302
1303         if (!e) {
1304                 e = bus_address_escape(host);
1305                 if (!e)
1306                         return -ENOMEM;
1307         }
1308
1309         b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1310         if (!b->address)
1311                 return -ENOMEM;
1312
1313         return 0;
1314  }
1315
1316 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1317         sd_bus *bus;
1318         int r;
1319
1320         assert_return(host, -EINVAL);
1321         assert_return(ret, -EINVAL);
1322
1323         r = sd_bus_new(&bus);
1324         if (r < 0)
1325                 return r;
1326
1327         r = bus_set_address_system_remote(bus, host);
1328         if (r < 0)
1329                 goto fail;
1330
1331         bus->bus_client = true;
1332         bus->trusted = false;
1333         bus->is_system = true;
1334
1335         r = sd_bus_start(bus);
1336         if (r < 0)
1337                 goto fail;
1338
1339         *ret = bus;
1340         return 0;
1341
1342 fail:
1343         bus_free(bus);
1344         return r;
1345 }
1346
1347 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1348         _cleanup_free_ char *e = NULL;
1349
1350         assert(b);
1351         assert(machine);
1352
1353         e = bus_address_escape(machine);
1354         if (!e)
1355                 return -ENOMEM;
1356
1357 #ifdef ENABLE_KDBUS
1358         b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1359 #else
1360         b->address = strjoin("x-machine-unix:machine=", e, NULL);
1361 #endif
1362         if (!b->address)
1363                 return -ENOMEM;
1364
1365         return 0;
1366 }
1367
1368 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1369         sd_bus *bus;
1370         int r;
1371
1372         assert_return(machine, -EINVAL);
1373         assert_return(ret, -EINVAL);
1374         assert_return(machine_name_is_valid(machine), -EINVAL);
1375
1376         r = sd_bus_new(&bus);
1377         if (r < 0)
1378                 return r;
1379
1380         r = bus_set_address_system_machine(bus, machine);
1381         if (r < 0)
1382                 goto fail;
1383
1384         bus->bus_client = true;
1385         bus->trusted = false;
1386         bus->is_system = true;
1387
1388         r = sd_bus_start(bus);
1389         if (r < 0)
1390                 goto fail;
1391
1392         *ret = bus;
1393         return 0;
1394
1395 fail:
1396         bus_free(bus);
1397         return r;
1398 }
1399
1400 _public_ void sd_bus_close(sd_bus *bus) {
1401
1402         if (!bus)
1403                 return;
1404         if (bus->state == BUS_CLOSED)
1405                 return;
1406         if (bus_pid_changed(bus))
1407                 return;
1408
1409         bus->state = BUS_CLOSED;
1410
1411         sd_bus_detach_event(bus);
1412
1413         /* Drop all queued messages so that they drop references to
1414          * the bus object and the bus may be freed */
1415         bus_reset_queues(bus);
1416
1417         if (!bus->is_kernel)
1418                 bus_close_fds(bus);
1419
1420         /* We'll leave the fd open in case this is a kernel bus, since
1421          * there might still be memblocks around that reference this
1422          * bus, and they might need to invoke the KDBUS_CMD_FREE
1423          * ioctl on the fd when they are freed. */
1424 }
1425
1426 static void bus_enter_closing(sd_bus *bus) {
1427         assert(bus);
1428
1429         if (bus->state != BUS_OPENING &&
1430             bus->state != BUS_AUTHENTICATING &&
1431             bus->state != BUS_HELLO &&
1432             bus->state != BUS_RUNNING)
1433                 return;
1434
1435         bus->state = BUS_CLOSING;
1436 }
1437
1438 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1439         assert_return(bus, NULL);
1440
1441         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1442
1443         return bus;
1444 }
1445
1446 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1447         unsigned i;
1448
1449         if (!bus)
1450                 return NULL;
1451
1452         i = REFCNT_DEC(bus->n_ref);
1453         if (i > 0)
1454                 return NULL;
1455
1456         bus_free(bus);
1457         return NULL;
1458 }
1459
1460 _public_ int sd_bus_is_open(sd_bus *bus) {
1461
1462         assert_return(bus, -EINVAL);
1463         assert_return(!bus_pid_changed(bus), -ECHILD);
1464
1465         return BUS_IS_OPEN(bus->state);
1466 }
1467
1468 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1469         int r;
1470
1471         assert_return(bus, -EINVAL);
1472         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1473         assert_return(!bus_pid_changed(bus), -ECHILD);
1474
1475         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1476                 return 0;
1477
1478         if (type == SD_BUS_TYPE_UNIX_FD) {
1479                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1480                         return 0;
1481
1482                 r = bus_ensure_running(bus);
1483                 if (r < 0)
1484                         return r;
1485
1486                 return bus->can_fds;
1487         }
1488
1489         return bus_type_is_valid(type);
1490 }
1491
1492 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1493         int r;
1494
1495         assert_return(bus, -EINVAL);
1496         assert_return(id, -EINVAL);
1497         assert_return(!bus_pid_changed(bus), -ECHILD);
1498
1499         r = bus_ensure_running(bus);
1500         if (r < 0)
1501                 return r;
1502
1503         *id = bus->server_id;
1504         return 0;
1505 }
1506
1507 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1508         assert(b);
1509         assert(m);
1510
1511         if (m->sealed) {
1512                 /* If we copy the same message to multiple
1513                  * destinations, avoid using the same cookie
1514                  * numbers. */
1515                 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1516                 return 0;
1517         }
1518
1519         if (timeout == 0)
1520                 timeout = BUS_DEFAULT_TIMEOUT;
1521
1522         return bus_message_seal(m, ++b->cookie, timeout);
1523 }
1524
1525 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1526         assert(b);
1527
1528         /* Do packet version and endianness already match? */
1529         if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1530             (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1531                 return 0;
1532
1533         /* No? Then remarshal! */
1534         return bus_message_remarshal(b, m);
1535 }
1536
1537 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1538         assert(b);
1539         assert(m);
1540
1541         /* Fake some timestamps, if they were requested, and not
1542          * already initialized */
1543         if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1544                 if (m->realtime <= 0)
1545                         m->realtime = now(CLOCK_REALTIME);
1546
1547                 if (m->monotonic <= 0)
1548                         m->monotonic = now(CLOCK_MONOTONIC);
1549         }
1550
1551         /* The bus specification says the serial number cannot be 0,
1552          * hence let's fill something in for synthetic messages. Since
1553          * synthetic messages might have a fake sender and we don't
1554          * want to interfere with the real sender's serial numbers we
1555          * pick a fixed, artificial one. We use (uint32_t) -1 rather
1556          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1557          * even though kdbus can do 64bit. */
1558         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1559 }
1560
1561 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1562         int r;
1563
1564         assert(bus);
1565         assert(m);
1566
1567         if (bus->is_kernel)
1568                 r = bus_kernel_write_message(bus, m, hint_sync_call);
1569         else
1570                 r = bus_socket_write_message(bus, m, idx);
1571
1572         if (r <= 0)
1573                 return r;
1574
1575         if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1576                 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1577                           bus_message_type_to_string(m->header->type),
1578                           strna(sd_bus_message_get_sender(m)),
1579                           strna(sd_bus_message_get_destination(m)),
1580                           strna(sd_bus_message_get_path(m)),
1581                           strna(sd_bus_message_get_interface(m)),
1582                           strna(sd_bus_message_get_member(m)),
1583                           BUS_MESSAGE_COOKIE(m),
1584                           m->reply_cookie,
1585                           strna(m->error.message));
1586
1587         return r;
1588 }
1589
1590 static int dispatch_wqueue(sd_bus *bus) {
1591         int r, ret = 0;
1592
1593         assert(bus);
1594         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1595
1596         while (bus->wqueue_size > 0) {
1597
1598                 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1599                 if (r < 0)
1600                         return r;
1601                 else if (r == 0)
1602                         /* Didn't do anything this time */
1603                         return ret;
1604                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1605                         /* Fully written. Let's drop the entry from
1606                          * the queue.
1607                          *
1608                          * This isn't particularly optimized, but
1609                          * well, this is supposed to be our worst-case
1610                          * buffer only, and the socket buffer is
1611                          * supposed to be our primary buffer, and if
1612                          * it got full, then all bets are off
1613                          * anyway. */
1614
1615                         bus->wqueue_size --;
1616                         sd_bus_message_unref(bus->wqueue[0]);
1617                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1618                         bus->windex = 0;
1619
1620                         ret = 1;
1621                 }
1622         }
1623
1624         return ret;
1625 }
1626
1627 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1628         assert(bus);
1629
1630         if (bus->is_kernel)
1631                 return bus_kernel_read_message(bus, hint_priority, priority);
1632         else
1633                 return bus_socket_read_message(bus);
1634 }
1635
1636 int bus_rqueue_make_room(sd_bus *bus) {
1637         assert(bus);
1638
1639         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1640                 return -ENOBUFS;
1641
1642         if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1643                 return -ENOMEM;
1644
1645         return 0;
1646 }
1647
1648 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1649         int r, ret = 0;
1650
1651         assert(bus);
1652         assert(m);
1653         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1654
1655         /* Note that the priority logic is only available on kdbus,
1656          * where the rqueue is unused. We check the rqueue here
1657          * anyway, because it's simple... */
1658
1659         for (;;) {
1660                 if (bus->rqueue_size > 0) {
1661                         /* Dispatch a queued message */
1662
1663                         *m = bus->rqueue[0];
1664                         bus->rqueue_size --;
1665                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1666                         return 1;
1667                 }
1668
1669                 /* Try to read a new message */
1670                 r = bus_read_message(bus, hint_priority, priority);
1671                 if (r < 0)
1672                         return r;
1673                 if (r == 0)
1674                         return ret;
1675
1676                 ret = 1;
1677         }
1678 }
1679
1680 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1681         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1682         int r;
1683
1684         assert_return(bus, -EINVAL);
1685         assert_return(m, -EINVAL);
1686         assert_return(!bus_pid_changed(bus), -ECHILD);
1687         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1688
1689         if (!BUS_IS_OPEN(bus->state))
1690                 return -ENOTCONN;
1691
1692         if (m->n_fds > 0) {
1693                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1694                 if (r < 0)
1695                         return r;
1696                 if (r == 0)
1697                         return -ENOTSUP;
1698         }
1699
1700         /* If the cookie number isn't kept, then we know that no reply
1701          * is expected */
1702         if (!cookie && !m->sealed)
1703                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1704
1705         r = bus_seal_message(bus, m, 0);
1706         if (r < 0)
1707                 return r;
1708
1709         /* Remarshall if we have to. This will possibly unref the
1710          * message and place a replacement in m */
1711         r = bus_remarshal_message(bus, &m);
1712         if (r < 0)
1713                 return r;
1714
1715         /* If this is a reply and no reply was requested, then let's
1716          * suppress this, if we can */
1717         if (m->dont_send)
1718                 goto finish;
1719
1720         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1721                 size_t idx = 0;
1722
1723                 r = bus_write_message(bus, m, hint_sync_call, &idx);
1724                 if (r < 0) {
1725                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1726                                 bus_enter_closing(bus);
1727                                 return -ECONNRESET;
1728                         }
1729
1730                         return r;
1731                 }
1732
1733                 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1734                         /* Wasn't fully written. So let's remember how
1735                          * much was written. Note that the first entry
1736                          * of the wqueue array is always allocated so
1737                          * that we always can remember how much was
1738                          * written. */
1739                         bus->wqueue[0] = sd_bus_message_ref(m);
1740                         bus->wqueue_size = 1;
1741                         bus->windex = idx;
1742                 }
1743
1744         } else {
1745                 /* Just append it to the queue. */
1746
1747                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1748                         return -ENOBUFS;
1749
1750                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1751                         return -ENOMEM;
1752
1753                 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1754         }
1755
1756 finish:
1757         if (cookie)
1758                 *cookie = BUS_MESSAGE_COOKIE(m);
1759
1760         return 1;
1761 }
1762
1763 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1764         return bus_send_internal(bus, m, cookie, false);
1765 }
1766
1767 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1768         int r;
1769
1770         assert_return(bus, -EINVAL);
1771         assert_return(m, -EINVAL);
1772         assert_return(!bus_pid_changed(bus), -ECHILD);
1773
1774         if (!BUS_IS_OPEN(bus->state))
1775                 return -ENOTCONN;
1776
1777         if (!streq_ptr(m->destination, destination)) {
1778
1779                 if (!destination)
1780                         return -EEXIST;
1781
1782                 r = sd_bus_message_set_destination(m, destination);
1783                 if (r < 0)
1784                         return r;
1785         }
1786
1787         return sd_bus_send(bus, m, cookie);
1788 }
1789
1790 static usec_t calc_elapse(uint64_t usec) {
1791         if (usec == (uint64_t) -1)
1792                 return 0;
1793
1794         return now(CLOCK_MONOTONIC) + usec;
1795 }
1796
1797 static int timeout_compare(const void *a, const void *b) {
1798         const struct reply_callback *x = a, *y = b;
1799
1800         if (x->timeout != 0 && y->timeout == 0)
1801                 return -1;
1802
1803         if (x->timeout == 0 && y->timeout != 0)
1804                 return 1;
1805
1806         if (x->timeout < y->timeout)
1807                 return -1;
1808
1809         if (x->timeout > y->timeout)
1810                 return 1;
1811
1812         return 0;
1813 }
1814
1815 _public_ int sd_bus_call_async(
1816                 sd_bus *bus,
1817                 sd_bus_slot **slot,
1818                 sd_bus_message *_m,
1819                 sd_bus_message_handler_t callback,
1820                 void *userdata,
1821                 uint64_t usec) {
1822
1823         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1824         _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1825         int r;
1826
1827         assert_return(bus, -EINVAL);
1828         assert_return(m, -EINVAL);
1829         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1830         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1831         assert_return(callback, -EINVAL);
1832         assert_return(!bus_pid_changed(bus), -ECHILD);
1833         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1834
1835         if (!BUS_IS_OPEN(bus->state))
1836                 return -ENOTCONN;
1837
1838         r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1839         if (r < 0)
1840                 return r;
1841
1842         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1843         if (r < 0)
1844                 return r;
1845
1846         r = bus_seal_message(bus, m, usec);
1847         if (r < 0)
1848                 return r;
1849
1850         r = bus_remarshal_message(bus, &m);
1851         if (r < 0)
1852                 return r;
1853
1854         s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1855         if (!s)
1856                 return -ENOMEM;
1857
1858         s->reply_callback.callback = callback;
1859
1860         s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1861         r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1862         if (r < 0) {
1863                 s->reply_callback.cookie = 0;
1864                 return r;
1865         }
1866
1867         s->reply_callback.timeout = calc_elapse(m->timeout);
1868         if (s->reply_callback.timeout != 0) {
1869                 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1870                 if (r < 0) {
1871                         s->reply_callback.timeout = 0;
1872                         return r;
1873                 }
1874         }
1875
1876         r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1877         if (r < 0)
1878                 return r;
1879
1880         if (slot)
1881                 *slot = s;
1882         s = NULL;
1883
1884         return r;
1885 }
1886
1887 int bus_ensure_running(sd_bus *bus) {
1888         int r;
1889
1890         assert(bus);
1891
1892         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1893                 return -ENOTCONN;
1894         if (bus->state == BUS_RUNNING)
1895                 return 1;
1896
1897         for (;;) {
1898                 r = sd_bus_process(bus, NULL);
1899                 if (r < 0)
1900                         return r;
1901                 if (bus->state == BUS_RUNNING)
1902                         return 1;
1903                 if (r > 0)
1904                         continue;
1905
1906                 r = sd_bus_wait(bus, (uint64_t) -1);
1907                 if (r < 0)
1908                         return r;
1909         }
1910 }
1911
1912 _public_ int sd_bus_call(
1913                 sd_bus *bus,
1914                 sd_bus_message *_m,
1915                 uint64_t usec,
1916                 sd_bus_error *error,
1917                 sd_bus_message **reply) {
1918
1919         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1920         usec_t timeout;
1921         uint64_t cookie;
1922         unsigned i;
1923         int r;
1924
1925         assert_return(bus, -EINVAL);
1926         assert_return(m, -EINVAL);
1927         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1928         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1929         assert_return(!bus_error_is_dirty(error), -EINVAL);
1930         assert_return(!bus_pid_changed(bus), -ECHILD);
1931         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1932
1933         if (!BUS_IS_OPEN(bus->state))
1934                 return -ENOTCONN;
1935
1936         r = bus_ensure_running(bus);
1937         if (r < 0)
1938                 return r;
1939
1940         i = bus->rqueue_size;
1941
1942         r = bus_seal_message(bus, m, usec);
1943         if (r < 0)
1944                 return r;
1945
1946         r = bus_remarshal_message(bus, &m);
1947         if (r < 0)
1948                 return r;
1949
1950         r = bus_send_internal(bus, m, &cookie, true);
1951         if (r < 0)
1952                 return r;
1953
1954         timeout = calc_elapse(m->timeout);
1955
1956         for (;;) {
1957                 usec_t left;
1958
1959                 while (i < bus->rqueue_size) {
1960                         sd_bus_message *incoming = NULL;
1961
1962                         incoming = bus->rqueue[i];
1963
1964                         if (incoming->reply_cookie == cookie) {
1965                                 /* Found a match! */
1966
1967                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1968                                 bus->rqueue_size--;
1969
1970                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1971
1972                                         if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1973                                                 if (reply)
1974                                                         *reply = incoming;
1975                                                 else
1976                                                         sd_bus_message_unref(incoming);
1977
1978                                                 return 1;
1979                                         }
1980
1981                                         r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1982
1983                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1984                                         r = sd_bus_error_copy(error, &incoming->error);
1985                                 else
1986                                         r = -EIO;
1987
1988                                 sd_bus_message_unref(incoming);
1989                                 return r;
1990
1991                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1992                                    bus->unique_name &&
1993                                    incoming->sender &&
1994                                    streq(bus->unique_name, incoming->sender)) {
1995
1996                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1997                                 bus->rqueue_size--;
1998
1999                                 /* Our own message? Somebody is trying
2000                                  * to send its own client a message,
2001                                  * let's not dead-lock, let's fail
2002                                  * immediately. */
2003
2004                                 sd_bus_message_unref(incoming);
2005                                 return -ELOOP;
2006                         }
2007
2008                         /* Try to read more, right-away */
2009                         i++;
2010                 }
2011
2012                 r = bus_read_message(bus, false, 0);
2013                 if (r < 0) {
2014                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2015                                 bus_enter_closing(bus);
2016                                 return -ECONNRESET;
2017                         }
2018
2019                         return r;
2020                 }
2021                 if (r > 0)
2022                         continue;
2023
2024                 if (timeout > 0) {
2025                         usec_t n;
2026
2027                         n = now(CLOCK_MONOTONIC);
2028                         if (n >= timeout)
2029                                 return -ETIMEDOUT;
2030
2031                         left = timeout - n;
2032                 } else
2033                         left = (uint64_t) -1;
2034
2035                 r = bus_poll(bus, true, left);
2036                 if (r < 0)
2037                         return r;
2038                 if (r == 0)
2039                         return -ETIMEDOUT;
2040
2041                 r = dispatch_wqueue(bus);
2042                 if (r < 0) {
2043                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2044                                 bus_enter_closing(bus);
2045                                 return -ECONNRESET;
2046                         }
2047
2048                         return r;
2049                 }
2050         }
2051 }
2052
2053 _public_ int sd_bus_get_fd(sd_bus *bus) {
2054
2055         assert_return(bus, -EINVAL);
2056         assert_return(bus->input_fd == bus->output_fd, -EPERM);
2057         assert_return(!bus_pid_changed(bus), -ECHILD);
2058
2059         return bus->input_fd;
2060 }
2061
2062 _public_ int sd_bus_get_events(sd_bus *bus) {
2063         int flags = 0;
2064
2065         assert_return(bus, -EINVAL);
2066         assert_return(!bus_pid_changed(bus), -ECHILD);
2067
2068         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2069                 return -ENOTCONN;
2070
2071         if (bus->state == BUS_OPENING)
2072                 flags |= POLLOUT;
2073         else if (bus->state == BUS_AUTHENTICATING) {
2074
2075                 if (bus_socket_auth_needs_write(bus))
2076                         flags |= POLLOUT;
2077
2078                 flags |= POLLIN;
2079
2080         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2081                 if (bus->rqueue_size <= 0)
2082                         flags |= POLLIN;
2083                 if (bus->wqueue_size > 0)
2084                         flags |= POLLOUT;
2085         }
2086
2087         return flags;
2088 }
2089
2090 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2091         struct reply_callback *c;
2092
2093         assert_return(bus, -EINVAL);
2094         assert_return(timeout_usec, -EINVAL);
2095         assert_return(!bus_pid_changed(bus), -ECHILD);
2096
2097         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2098                 return -ENOTCONN;
2099
2100         if (bus->track_queue) {
2101                 *timeout_usec = 0;
2102                 return 1;
2103         }
2104
2105         if (bus->state == BUS_CLOSING) {
2106                 *timeout_usec = 0;
2107                 return 1;
2108         }
2109
2110         if (bus->state == BUS_AUTHENTICATING) {
2111                 *timeout_usec = bus->auth_timeout;
2112                 return 1;
2113         }
2114
2115         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2116                 *timeout_usec = (uint64_t) -1;
2117                 return 0;
2118         }
2119
2120         if (bus->rqueue_size > 0) {
2121                 *timeout_usec = 0;
2122                 return 1;
2123         }
2124
2125         c = prioq_peek(bus->reply_callbacks_prioq);
2126         if (!c) {
2127                 *timeout_usec = (uint64_t) -1;
2128                 return 0;
2129         }
2130
2131         if (c->timeout == 0) {
2132                 *timeout_usec = (uint64_t) -1;
2133                 return 0;
2134         }
2135
2136         *timeout_usec = c->timeout;
2137         return 1;
2138 }
2139
2140 static int process_timeout(sd_bus *bus) {
2141         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2142         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2143         struct reply_callback *c;
2144         sd_bus_slot *slot;
2145         usec_t n;
2146         int r;
2147
2148         assert(bus);
2149
2150         c = prioq_peek(bus->reply_callbacks_prioq);
2151         if (!c)
2152                 return 0;
2153
2154         n = now(CLOCK_MONOTONIC);
2155         if (c->timeout > n)
2156                 return 0;
2157
2158         r = bus_message_new_synthetic_error(
2159                         bus,
2160                         c->cookie,
2161                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2162                         &m);
2163         if (r < 0)
2164                 return r;
2165
2166         r = bus_seal_synthetic_message(bus, m);
2167         if (r < 0)
2168                 return r;
2169
2170         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2171         c->timeout = 0;
2172
2173         ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2174         c->cookie = 0;
2175
2176         slot = container_of(c, sd_bus_slot, reply_callback);
2177
2178         bus->iteration_counter ++;
2179
2180         bus->current_message = m;
2181         bus->current_slot = sd_bus_slot_ref(slot);
2182         bus->current_handler = c->callback;
2183         bus->current_userdata = slot->userdata;
2184         r = c->callback(bus, m, slot->userdata, &error_buffer);
2185         bus->current_userdata = NULL;
2186         bus->current_handler = NULL;
2187         bus->current_slot = NULL;
2188         bus->current_message = NULL;
2189
2190         if (slot->floating) {
2191                 bus_slot_disconnect(slot);
2192                 sd_bus_slot_unref(slot);
2193         }
2194
2195         sd_bus_slot_unref(slot);
2196
2197         return bus_maybe_reply_error(m, r, &error_buffer);
2198 }
2199
2200 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2201         assert(bus);
2202         assert(m);
2203
2204         if (bus->state != BUS_HELLO)
2205                 return 0;
2206
2207         /* Let's make sure the first message on the bus is the HELLO
2208          * reply. But note that we don't actually parse the message
2209          * here (we leave that to the usual handling), we just verify
2210          * we don't let any earlier msg through. */
2211
2212         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2213             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2214                 return -EIO;
2215
2216         if (m->reply_cookie != 1)
2217                 return -EIO;
2218
2219         return 0;
2220 }
2221
2222 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2223         _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2224         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2225         struct reply_callback *c;
2226         sd_bus_slot *slot;
2227         int r;
2228
2229         assert(bus);
2230         assert(m);
2231
2232         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2233             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2234                 return 0;
2235
2236         if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2237                 return 0;
2238
2239         if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2240                 return 0;
2241
2242         c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2243         if (!c)
2244                 return 0;
2245
2246         c->cookie = 0;
2247
2248         slot = container_of(c, sd_bus_slot, reply_callback);
2249
2250         if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2251
2252                 /* If the reply contained a file descriptor which we
2253                  * didn't want we pass an error instead. */
2254
2255                 r = bus_message_new_synthetic_error(
2256                                 bus,
2257                                 m->reply_cookie,
2258                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2259                                 &synthetic_reply);
2260                 if (r < 0)
2261                         return r;
2262
2263                 /* Copy over original timestamp */
2264                 synthetic_reply->realtime = m->realtime;
2265                 synthetic_reply->monotonic = m->monotonic;
2266                 synthetic_reply->seqnum = m->seqnum;
2267
2268                 r = bus_seal_synthetic_message(bus, synthetic_reply);
2269                 if (r < 0)
2270                         return r;
2271
2272                 m = synthetic_reply;
2273         } else {
2274                 r = sd_bus_message_rewind(m, true);
2275                 if (r < 0)
2276                         return r;
2277         }
2278
2279         if (c->timeout != 0) {
2280                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2281                 c->timeout = 0;
2282         }
2283
2284         bus->current_slot = sd_bus_slot_ref(slot);
2285         bus->current_handler = c->callback;
2286         bus->current_userdata = slot->userdata;
2287         r = c->callback(bus, m, slot->userdata, &error_buffer);
2288         bus->current_userdata = NULL;
2289         bus->current_handler = NULL;
2290         bus->current_slot = NULL;
2291
2292         if (slot->floating) {
2293                 bus_slot_disconnect(slot);
2294                 sd_bus_slot_unref(slot);
2295         }
2296
2297         sd_bus_slot_unref(slot);
2298
2299         return bus_maybe_reply_error(m, r, &error_buffer);
2300 }
2301
2302 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2303         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2304         struct filter_callback *l;
2305         int r;
2306
2307         assert(bus);
2308         assert(m);
2309
2310         do {
2311                 bus->filter_callbacks_modified = false;
2312
2313                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2314                         sd_bus_slot *slot;
2315
2316                         if (bus->filter_callbacks_modified)
2317                                 break;
2318
2319                         /* Don't run this more than once per iteration */
2320                         if (l->last_iteration == bus->iteration_counter)
2321                                 continue;
2322
2323                         l->last_iteration = bus->iteration_counter;
2324
2325                         r = sd_bus_message_rewind(m, true);
2326                         if (r < 0)
2327                                 return r;
2328
2329                         slot = container_of(l, sd_bus_slot, filter_callback);
2330
2331                         bus->current_slot = sd_bus_slot_ref(slot);
2332                         bus->current_handler = l->callback;
2333                         bus->current_userdata = slot->userdata;
2334                         r = l->callback(bus, m, slot->userdata, &error_buffer);
2335                         bus->current_userdata = NULL;
2336                         bus->current_handler = NULL;
2337                         bus->current_slot = sd_bus_slot_unref(slot);
2338
2339                         r = bus_maybe_reply_error(m, r, &error_buffer);
2340                         if (r != 0)
2341                                 return r;
2342
2343                 }
2344
2345         } while (bus->filter_callbacks_modified);
2346
2347         return 0;
2348 }
2349
2350 static int process_match(sd_bus *bus, sd_bus_message *m) {
2351         int r;
2352
2353         assert(bus);
2354         assert(m);
2355
2356         do {
2357                 bus->match_callbacks_modified = false;
2358
2359                 r = bus_match_run(bus, &bus->match_callbacks, m);
2360                 if (r != 0)
2361                         return r;
2362
2363         } while (bus->match_callbacks_modified);
2364
2365         return 0;
2366 }
2367
2368 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2369         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2370         int r;
2371
2372         assert(bus);
2373         assert(m);
2374
2375         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2376                 return 0;
2377
2378         if (bus->manual_peer_interface)
2379                 return 0;
2380
2381         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2382                 return 0;
2383
2384         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2385                 return 0;
2386
2387         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2388                 return 1;
2389
2390         if (streq_ptr(m->member, "Ping"))
2391                 r = sd_bus_message_new_method_return(m, &reply);
2392         else if (streq_ptr(m->member, "GetMachineId")) {
2393                 sd_id128_t id;
2394                 char sid[33];
2395
2396                 r = sd_id128_get_machine(&id);
2397                 if (r < 0)
2398                         return r;
2399
2400                 r = sd_bus_message_new_method_return(m, &reply);
2401                 if (r < 0)
2402                         return r;
2403
2404                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2405         } else {
2406                 r = sd_bus_message_new_method_errorf(
2407                                 m, &reply,
2408                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2409                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2410         }
2411
2412         if (r < 0)
2413                 return r;
2414
2415         r = sd_bus_send(bus, reply, NULL);
2416         if (r < 0)
2417                 return r;
2418
2419         return 1;
2420 }
2421
2422 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2423         assert(bus);
2424         assert(m);
2425
2426         /* If we got a message with a file descriptor which we didn't
2427          * want to accept, then let's drop it. How can this even
2428          * happen? For example, when the kernel queues a message into
2429          * an activatable names's queue which allows fds, and then is
2430          * delivered to us later even though we ourselves did not
2431          * negotiate it. */
2432
2433         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2434                 return 0;
2435
2436         if (m->n_fds <= 0)
2437                 return 0;
2438
2439         if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2440                 return 0;
2441
2442         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2443                 return 1; /* just eat it up */
2444
2445         return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2446 }
2447
2448 static int process_message(sd_bus *bus, sd_bus_message *m) {
2449         int r;
2450
2451         assert(bus);
2452         assert(m);
2453
2454         bus->current_message = m;
2455         bus->iteration_counter++;
2456
2457         log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2458                   bus_message_type_to_string(m->header->type),
2459                   strna(sd_bus_message_get_sender(m)),
2460                   strna(sd_bus_message_get_destination(m)),
2461                   strna(sd_bus_message_get_path(m)),
2462                   strna(sd_bus_message_get_interface(m)),
2463                   strna(sd_bus_message_get_member(m)),
2464                   BUS_MESSAGE_COOKIE(m),
2465                   m->reply_cookie,
2466                   strna(m->error.message));
2467
2468         r = process_hello(bus, m);
2469         if (r != 0)
2470                 goto finish;
2471
2472         r = process_reply(bus, m);
2473         if (r != 0)
2474                 goto finish;
2475
2476         r = process_fd_check(bus, m);
2477         if (r != 0)
2478                 goto finish;
2479
2480         r = process_filter(bus, m);
2481         if (r != 0)
2482                 goto finish;
2483
2484         r = process_match(bus, m);
2485         if (r != 0)
2486                 goto finish;
2487
2488         r = process_builtin(bus, m);
2489         if (r != 0)
2490                 goto finish;
2491
2492         r = bus_process_object(bus, m);
2493
2494 finish:
2495         bus->current_message = NULL;
2496         return r;
2497 }
2498
2499 static int dispatch_track(sd_bus *bus) {
2500         assert(bus);
2501
2502         if (!bus->track_queue)
2503                 return 0;
2504
2505         bus_track_dispatch(bus->track_queue);
2506         return 1;
2507 }
2508
2509 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2510         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2511         int r;
2512
2513         assert(bus);
2514         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2515
2516         r = process_timeout(bus);
2517         if (r != 0)
2518                 goto null_message;
2519
2520         r = dispatch_wqueue(bus);
2521         if (r != 0)
2522                 goto null_message;
2523
2524         r = dispatch_track(bus);
2525         if (r != 0)
2526                 goto null_message;
2527
2528         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2529         if (r < 0)
2530                 return r;
2531         if (!m)
2532                 goto null_message;
2533
2534         r = process_message(bus, m);
2535         if (r != 0)
2536                 goto null_message;
2537
2538         if (ret) {
2539                 r = sd_bus_message_rewind(m, true);
2540                 if (r < 0)
2541                         return r;
2542
2543                 *ret = m;
2544                 m = NULL;
2545                 return 1;
2546         }
2547
2548         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2549
2550                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2551                           strna(sd_bus_message_get_sender(m)),
2552                           strna(sd_bus_message_get_path(m)),
2553                           strna(sd_bus_message_get_interface(m)),
2554                           strna(sd_bus_message_get_member(m)));
2555
2556                 r = sd_bus_reply_method_errorf(
2557                                 m,
2558                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2559                                 "Unknown object '%s'.", m->path);
2560                 if (r < 0)
2561                         return r;
2562         }
2563
2564         return 1;
2565
2566 null_message:
2567         if (r >= 0 && ret)
2568                 *ret = NULL;
2569
2570         return r;
2571 }
2572
2573 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2574         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2575         struct reply_callback *c;
2576         int r;
2577
2578         assert(bus);
2579         assert(bus->state == BUS_CLOSING);
2580
2581         c = ordered_hashmap_first(bus->reply_callbacks);
2582         if (c) {
2583                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2584                 sd_bus_slot *slot;
2585
2586                 /* First, fail all outstanding method calls */
2587                 r = bus_message_new_synthetic_error(
2588                                 bus,
2589                                 c->cookie,
2590                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2591                                 &m);
2592                 if (r < 0)
2593                         return r;
2594
2595                 r = bus_seal_synthetic_message(bus, m);
2596                 if (r < 0)
2597                         return r;
2598
2599                 if (c->timeout != 0) {
2600                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2601                         c->timeout = 0;
2602                 }
2603
2604                 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2605                 c->cookie = 0;
2606
2607                 slot = container_of(c, sd_bus_slot, reply_callback);
2608
2609                 bus->iteration_counter++;
2610
2611                 bus->current_message = m;
2612                 bus->current_slot = sd_bus_slot_ref(slot);
2613                 bus->current_handler = c->callback;
2614                 bus->current_userdata = slot->userdata;
2615                 r = c->callback(bus, m, slot->userdata, &error_buffer);
2616                 bus->current_userdata = NULL;
2617                 bus->current_handler = NULL;
2618                 bus->current_slot = NULL;
2619                 bus->current_message = NULL;
2620
2621                 if (slot->floating) {
2622                         bus_slot_disconnect(slot);
2623                         sd_bus_slot_unref(slot);
2624                 }
2625
2626                 sd_bus_slot_unref(slot);
2627
2628                 return bus_maybe_reply_error(m, r, &error_buffer);
2629         }
2630
2631         /* Then, synthesize a Disconnected message */
2632         r = sd_bus_message_new_signal(
2633                         bus,
2634                         &m,
2635                         "/org/freedesktop/DBus/Local",
2636                         "org.freedesktop.DBus.Local",
2637                         "Disconnected");
2638         if (r < 0)
2639                 return r;
2640
2641         bus_message_set_sender_local(bus, m);
2642
2643         r = bus_seal_synthetic_message(bus, m);
2644         if (r < 0)
2645                 return r;
2646
2647         sd_bus_close(bus);
2648
2649         bus->current_message = m;
2650         bus->iteration_counter++;
2651
2652         r = process_filter(bus, m);
2653         if (r != 0)
2654                 goto finish;
2655
2656         r = process_match(bus, m);
2657         if (r != 0)
2658                 goto finish;
2659
2660         if (ret) {
2661                 *ret = m;
2662                 m = NULL;
2663         }
2664
2665         r = 1;
2666
2667 finish:
2668         bus->current_message = NULL;
2669
2670         return r;
2671 }
2672
2673 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2674         BUS_DONT_DESTROY(bus);
2675         int r;
2676
2677         /* Returns 0 when we didn't do anything. This should cause the
2678          * caller to invoke sd_bus_wait() before returning the next
2679          * time. Returns > 0 when we did something, which possibly
2680          * means *ret is filled in with an unprocessed message. */
2681
2682         assert_return(bus, -EINVAL);
2683         assert_return(!bus_pid_changed(bus), -ECHILD);
2684
2685         /* We don't allow recursively invoking sd_bus_process(). */
2686         assert_return(!bus->current_message, -EBUSY);
2687         assert(!bus->current_slot);
2688
2689         switch (bus->state) {
2690
2691         case BUS_UNSET:
2692                 return -ENOTCONN;
2693
2694         case BUS_CLOSED:
2695                 return -ECONNRESET;
2696
2697         case BUS_OPENING:
2698                 r = bus_socket_process_opening(bus);
2699                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2700                         bus_enter_closing(bus);
2701                         r = 1;
2702                 } else if (r < 0)
2703                         return r;
2704                 if (ret)
2705                         *ret = NULL;
2706                 return r;
2707
2708         case BUS_AUTHENTICATING:
2709                 r = bus_socket_process_authenticating(bus);
2710                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2711                         bus_enter_closing(bus);
2712                         r = 1;
2713                 } else if (r < 0)
2714                         return r;
2715
2716                 if (ret)
2717                         *ret = NULL;
2718
2719                 return r;
2720
2721         case BUS_RUNNING:
2722         case BUS_HELLO:
2723                 r = process_running(bus, hint_priority, priority, ret);
2724                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2725                         bus_enter_closing(bus);
2726                         r = 1;
2727
2728                         if (ret)
2729                                 *ret = NULL;
2730                 }
2731
2732                 return r;
2733
2734         case BUS_CLOSING:
2735                 return process_closing(bus, ret);
2736         }
2737
2738         assert_not_reached("Unknown state");
2739 }
2740
2741 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2742         return bus_process_internal(bus, false, 0, ret);
2743 }
2744
2745 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2746         return bus_process_internal(bus, true, priority, ret);
2747 }
2748
2749 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2750         struct pollfd p[2] = {};
2751         int r, e, n;
2752         struct timespec ts;
2753         usec_t m = USEC_INFINITY;
2754
2755         assert(bus);
2756
2757         if (bus->state == BUS_CLOSING)
2758                 return 1;
2759
2760         if (!BUS_IS_OPEN(bus->state))
2761                 return -ENOTCONN;
2762
2763         e = sd_bus_get_events(bus);
2764         if (e < 0)
2765                 return e;
2766
2767         if (need_more)
2768                 /* The caller really needs some more data, he doesn't
2769                  * care about what's already read, or any timeouts
2770                  * except its own. */
2771                 e |= POLLIN;
2772         else {
2773                 usec_t until;
2774                 /* The caller wants to process if there's something to
2775                  * process, but doesn't care otherwise */
2776
2777                 r = sd_bus_get_timeout(bus, &until);
2778                 if (r < 0)
2779                         return r;
2780                 if (r > 0) {
2781                         usec_t nw;
2782                         nw = now(CLOCK_MONOTONIC);
2783                         m = until > nw ? until - nw : 0;
2784                 }
2785         }
2786
2787         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2788                 m = timeout_usec;
2789
2790         p[0].fd = bus->input_fd;
2791         if (bus->output_fd == bus->input_fd) {
2792                 p[0].events = e;
2793                 n = 1;
2794         } else {
2795                 p[0].events = e & POLLIN;
2796                 p[1].fd = bus->output_fd;
2797                 p[1].events = e & POLLOUT;
2798                 n = 2;
2799         }
2800
2801         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2802         if (r < 0)
2803                 return -errno;
2804
2805         return r > 0 ? 1 : 0;
2806 }
2807
2808 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2809
2810         assert_return(bus, -EINVAL);
2811         assert_return(!bus_pid_changed(bus), -ECHILD);
2812
2813         if (bus->state == BUS_CLOSING)
2814                 return 0;
2815
2816         if (!BUS_IS_OPEN(bus->state))
2817                 return -ENOTCONN;
2818
2819         if (bus->rqueue_size > 0)
2820                 return 0;
2821
2822         return bus_poll(bus, false, timeout_usec);
2823 }
2824
2825 _public_ int sd_bus_flush(sd_bus *bus) {
2826         int r;
2827
2828         assert_return(bus, -EINVAL);
2829         assert_return(!bus_pid_changed(bus), -ECHILD);
2830
2831         if (bus->state == BUS_CLOSING)
2832                 return 0;
2833
2834         if (!BUS_IS_OPEN(bus->state))
2835                 return -ENOTCONN;
2836
2837         r = bus_ensure_running(bus);
2838         if (r < 0)
2839                 return r;
2840
2841         if (bus->wqueue_size <= 0)
2842                 return 0;
2843
2844         for (;;) {
2845                 r = dispatch_wqueue(bus);
2846                 if (r < 0) {
2847                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2848                                 bus_enter_closing(bus);
2849                                 return -ECONNRESET;
2850                         }
2851
2852                         return r;
2853                 }
2854
2855                 if (bus->wqueue_size <= 0)
2856                         return 0;
2857
2858                 r = bus_poll(bus, false, (uint64_t) -1);
2859                 if (r < 0)
2860                         return r;
2861         }
2862 }
2863
2864 _public_ int sd_bus_add_filter(
2865                 sd_bus *bus,
2866                 sd_bus_slot **slot,
2867                 sd_bus_message_handler_t callback,
2868                 void *userdata) {
2869
2870         sd_bus_slot *s;
2871
2872         assert_return(bus, -EINVAL);
2873         assert_return(callback, -EINVAL);
2874         assert_return(!bus_pid_changed(bus), -ECHILD);
2875
2876         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2877         if (!s)
2878                 return -ENOMEM;
2879
2880         s->filter_callback.callback = callback;
2881
2882         bus->filter_callbacks_modified = true;
2883         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2884
2885         if (slot)
2886                 *slot = s;
2887
2888         return 0;
2889 }
2890
2891 _public_ int sd_bus_add_match(
2892                 sd_bus *bus,
2893                 sd_bus_slot **slot,
2894                 const char *match,
2895                 sd_bus_message_handler_t callback,
2896                 void *userdata) {
2897
2898         struct bus_match_component *components = NULL;
2899         unsigned n_components = 0;
2900         sd_bus_slot *s = NULL;
2901         int r = 0;
2902
2903         assert_return(bus, -EINVAL);
2904         assert_return(match, -EINVAL);
2905         assert_return(!bus_pid_changed(bus), -ECHILD);
2906
2907         r = bus_match_parse(match, &components, &n_components);
2908         if (r < 0)
2909                 goto finish;
2910
2911         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2912         if (!s) {
2913                 r = -ENOMEM;
2914                 goto finish;
2915         }
2916
2917         s->match_callback.callback = callback;
2918         s->match_callback.cookie = ++bus->match_cookie;
2919
2920         if (bus->bus_client) {
2921
2922                 if (!bus->is_kernel) {
2923                         /* When this is not a kernel transport, we
2924                          * store the original match string, so that we
2925                          * can use it to remove the match again */
2926
2927                         s->match_callback.match_string = strdup(match);
2928                         if (!s->match_callback.match_string) {
2929                                 r = -ENOMEM;
2930                                 goto finish;
2931                         }
2932                 }
2933
2934                 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2935                 if (r < 0)
2936                         goto finish;
2937         }
2938
2939         bus->match_callbacks_modified = true;
2940         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2941         if (r < 0)
2942                 goto finish;
2943
2944         if (slot)
2945                 *slot = s;
2946         s = NULL;
2947
2948 finish:
2949         bus_match_parse_free(components, n_components);
2950         sd_bus_slot_unref(s);
2951
2952         return r;
2953 }
2954
2955 int bus_remove_match_by_string(
2956                 sd_bus *bus,
2957                 const char *match,
2958                 sd_bus_message_handler_t callback,
2959                 void *userdata) {
2960
2961         struct bus_match_component *components = NULL;
2962         unsigned n_components = 0;
2963         struct match_callback *c;
2964         int r = 0;
2965
2966         assert_return(bus, -EINVAL);
2967         assert_return(match, -EINVAL);
2968         assert_return(!bus_pid_changed(bus), -ECHILD);
2969
2970         r = bus_match_parse(match, &components, &n_components);
2971         if (r < 0)
2972                 goto finish;
2973
2974         r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2975         if (r <= 0)
2976                 goto finish;
2977
2978         sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2979
2980 finish:
2981         bus_match_parse_free(components, n_components);
2982
2983         return r;
2984 }
2985
2986 bool bus_pid_changed(sd_bus *bus) {
2987         assert(bus);
2988
2989         /* We don't support people creating a bus connection and
2990          * keeping it around over a fork(). Let's complain. */
2991
2992         return bus->original_pid != getpid();
2993 }
2994
2995 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2996         sd_bus *bus = userdata;
2997         int r;
2998
2999         assert(bus);
3000
3001         r = sd_bus_process(bus, NULL);
3002         if (r < 0)
3003                 return r;
3004
3005         return 1;
3006 }
3007
3008 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3009         sd_bus *bus = userdata;
3010         int r;
3011
3012         assert(bus);
3013
3014         r = sd_bus_process(bus, NULL);
3015         if (r < 0)
3016                 return r;
3017
3018         return 1;
3019 }
3020
3021 static int prepare_callback(sd_event_source *s, void *userdata) {
3022         sd_bus *bus = userdata;
3023         int r, e;
3024         usec_t until;
3025
3026         assert(s);
3027         assert(bus);
3028
3029         e = sd_bus_get_events(bus);
3030         if (e < 0)
3031                 return e;
3032
3033         if (bus->output_fd != bus->input_fd) {
3034
3035                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3036                 if (r < 0)
3037                         return r;
3038
3039                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3040                 if (r < 0)
3041                         return r;
3042         } else {
3043                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3044                 if (r < 0)
3045                         return r;
3046         }
3047
3048         r = sd_bus_get_timeout(bus, &until);
3049         if (r < 0)
3050                 return r;
3051         if (r > 0) {
3052                 int j;
3053
3054                 j = sd_event_source_set_time(bus->time_event_source, until);
3055                 if (j < 0)
3056                         return j;
3057         }
3058
3059         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3060         if (r < 0)
3061                 return r;
3062
3063         return 1;
3064 }
3065
3066 static int quit_callback(sd_event_source *event, void *userdata) {
3067         sd_bus *bus = userdata;
3068
3069         assert(event);
3070
3071         sd_bus_flush(bus);
3072         sd_bus_close(bus);
3073
3074         return 1;
3075 }
3076
3077 static int attach_io_events(sd_bus *bus) {
3078         int r;
3079
3080         assert(bus);
3081
3082         if (bus->input_fd < 0)
3083                 return 0;
3084
3085         if (!bus->event)
3086                 return 0;
3087
3088         if (!bus->input_io_event_source) {
3089                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3090                 if (r < 0)
3091                         return r;
3092
3093                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3094                 if (r < 0)
3095                         return r;
3096
3097                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3098                 if (r < 0)
3099                         return r;
3100
3101                 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3102         } else
3103                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3104
3105         if (r < 0)
3106                 return r;
3107
3108         if (bus->output_fd != bus->input_fd) {
3109                 assert(bus->output_fd >= 0);
3110
3111                 if (!bus->output_io_event_source) {
3112                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3113                         if (r < 0)
3114                                 return r;
3115
3116                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3117                         if (r < 0)
3118                                 return r;
3119
3120                         r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3121                 } else
3122                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3123
3124                 if (r < 0)
3125                         return r;
3126         }
3127
3128         return 0;
3129 }
3130
3131 static void detach_io_events(sd_bus *bus) {
3132         assert(bus);
3133
3134         if (bus->input_io_event_source) {
3135                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3136                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3137         }
3138
3139         if (bus->output_io_event_source) {
3140                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3141                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3142         }
3143 }
3144
3145 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3146         int r;
3147
3148         assert_return(bus, -EINVAL);
3149         assert_return(!bus->event, -EBUSY);
3150
3151         assert(!bus->input_io_event_source);
3152         assert(!bus->output_io_event_source);
3153         assert(!bus->time_event_source);
3154
3155         if (event)
3156                 bus->event = sd_event_ref(event);
3157         else  {
3158                 r = sd_event_default(&bus->event);
3159                 if (r < 0)
3160                         return r;
3161         }
3162
3163         bus->event_priority = priority;
3164
3165         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3166         if (r < 0)
3167                 goto fail;
3168
3169         r = sd_event_source_set_priority(bus->time_event_source, priority);
3170         if (r < 0)
3171                 goto fail;
3172
3173         r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3174         if (r < 0)
3175                 goto fail;
3176
3177         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3178         if (r < 0)
3179                 goto fail;
3180
3181         r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3182         if (r < 0)
3183                 goto fail;
3184
3185         r = attach_io_events(bus);
3186         if (r < 0)
3187                 goto fail;
3188
3189         return 0;
3190
3191 fail:
3192         sd_bus_detach_event(bus);
3193         return r;
3194 }
3195
3196 _public_ int sd_bus_detach_event(sd_bus *bus) {
3197         assert_return(bus, -EINVAL);
3198
3199         if (!bus->event)
3200                 return 0;
3201
3202         detach_io_events(bus);
3203
3204         if (bus->time_event_source) {
3205                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3206                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3207         }
3208
3209         if (bus->quit_event_source) {
3210                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3211                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3212         }
3213
3214         bus->event = sd_event_unref(bus->event);
3215         return 1;
3216 }
3217
3218 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3219         assert_return(bus, NULL);
3220
3221         return bus->event;
3222 }
3223
3224 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3225         assert_return(bus, NULL);
3226
3227         return bus->current_message;
3228 }
3229
3230 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3231         assert_return(bus, NULL);
3232
3233         return bus->current_slot;
3234 }
3235
3236 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3237         assert_return(bus, NULL);
3238
3239         return bus->current_handler;
3240 }
3241
3242 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3243         assert_return(bus, NULL);
3244
3245         return bus->current_userdata;
3246 }
3247
3248 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3249         sd_bus *b = NULL;
3250         int r;
3251
3252         assert(bus_open);
3253         assert(default_bus);
3254
3255         if (!ret)
3256                 return !!*default_bus;
3257
3258         if (*default_bus) {
3259                 *ret = sd_bus_ref(*default_bus);
3260                 return 0;
3261         }
3262
3263         r = bus_open(&b);
3264         if (r < 0)
3265                 return r;
3266
3267         b->default_bus_ptr = default_bus;
3268         b->tid = gettid();
3269         *default_bus = b;
3270
3271         *ret = b;
3272         return 1;
3273 }
3274
3275 _public_ int sd_bus_default_system(sd_bus **ret) {
3276         static thread_local sd_bus *default_system_bus = NULL;
3277
3278         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3279 }
3280
3281 _public_ int sd_bus_default_user(sd_bus **ret) {
3282         static thread_local sd_bus *default_user_bus = NULL;
3283
3284         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3285 }
3286
3287 _public_ int sd_bus_default(sd_bus **ret) {
3288
3289         const char *e;
3290
3291         /* Let's try our best to reuse another cached connection. If
3292          * the starter bus type is set, connect via our normal
3293          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3294          * we can share the connection with the user/system default
3295          * bus. */
3296
3297         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3298         if (e) {
3299                 if (streq(e, "system"))
3300                         return sd_bus_default_system(ret);
3301                 else if (STR_IN_SET(e, "user", "session"))
3302                         return sd_bus_default_user(ret);
3303         }
3304
3305         /* No type is specified, so we have not other option than to
3306          * use the starter address if it is set. */
3307
3308         e = secure_getenv("DBUS_STARTER_ADDRESS");
3309         if (e) {
3310                 static thread_local sd_bus *default_starter_bus = NULL;
3311
3312                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3313         }
3314
3315         /* Finally, if nothing is set use the cached connection for
3316          * the right scope */
3317
3318         if (cg_pid_get_owner_uid(0, NULL) >= 0)
3319                 return sd_bus_default_user(ret);
3320         else
3321                 return sd_bus_default_system(ret);
3322 }
3323
3324 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3325         assert_return(b, -EINVAL);
3326         assert_return(tid, -EINVAL);
3327         assert_return(!bus_pid_changed(b), -ECHILD);
3328
3329         if (b->tid != 0) {
3330                 *tid = b->tid;
3331                 return 0;
3332         }
3333
3334         if (b->event)
3335                 return sd_event_get_tid(b->event, tid);
3336
3337         return -ENXIO;
3338 }
3339
3340 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3341         _cleanup_free_ char *e = NULL;
3342         char *ret;
3343
3344         assert_return(object_path_is_valid(prefix), -EINVAL);
3345         assert_return(external_id, -EINVAL);
3346         assert_return(ret_path, -EINVAL);
3347
3348         e = bus_label_escape(external_id);
3349         if (!e)
3350                 return -ENOMEM;
3351
3352         ret = strjoin(prefix, "/", e, NULL);
3353         if (!ret)
3354                 return -ENOMEM;
3355
3356         *ret_path = ret;
3357         return 0;
3358 }
3359
3360 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3361         const char *e;
3362         char *ret;
3363
3364         assert_return(object_path_is_valid(path), -EINVAL);
3365         assert_return(object_path_is_valid(prefix), -EINVAL);
3366         assert_return(external_id, -EINVAL);
3367
3368         e = object_path_startswith(path, prefix);
3369         if (!e) {
3370                 *external_id = NULL;
3371                 return 0;
3372         }
3373
3374         ret = bus_label_unescape(e);
3375         if (!ret)
3376                 return -ENOMEM;
3377
3378         *external_id = ret;
3379         return 1;
3380 }
3381
3382 _public_ int sd_bus_try_close(sd_bus *bus) {
3383         int r;
3384
3385         assert_return(bus, -EINVAL);
3386         assert_return(!bus_pid_changed(bus), -ECHILD);
3387
3388         if (!bus->is_kernel)
3389                 return -ENOTSUP;
3390
3391         if (!BUS_IS_OPEN(bus->state))
3392                 return -ENOTCONN;
3393
3394         if (bus->rqueue_size > 0)
3395                 return -EBUSY;
3396
3397         if (bus->wqueue_size > 0)
3398                 return -EBUSY;
3399
3400         r = bus_kernel_try_close(bus);
3401         if (r < 0)
3402                 return r;
3403
3404         sd_bus_close(bus);
3405         return 0;
3406 }
3407
3408 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3409         assert_return(bus, -EINVAL);
3410         assert_return(description, -EINVAL);
3411         assert_return(bus->description, -ENXIO);
3412         assert_return(!bus_pid_changed(bus), -ECHILD);
3413
3414         *description = bus->description;
3415         return 0;
3416 }
3417
3418 int bus_get_root_path(sd_bus *bus) {
3419         int r;
3420
3421         if (bus->cgroup_root)
3422                 return 0;
3423
3424         r = cg_get_root_path(&bus->cgroup_root);
3425         if (r == -ENOENT) {
3426                 bus->cgroup_root = strdup("/");
3427                 if (!bus->cgroup_root)
3428                         return -ENOMEM;
3429
3430                 r = 0;
3431         }
3432
3433         return r;
3434 }
3435
3436 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3437         int r;
3438
3439         assert_return(bus, -EINVAL);
3440         assert_return(scope, -EINVAL);
3441         assert_return(!bus_pid_changed(bus), -ECHILD);
3442
3443         if (bus->is_kernel) {
3444                 _cleanup_free_ char *n = NULL;
3445                 const char *dash;
3446
3447                 r = bus_kernel_get_bus_name(bus, &n);
3448                 if (r < 0)
3449                         return r;
3450
3451                 if (streq(n, "0-system")) {
3452                         *scope = "system";
3453                         return 0;
3454                 }
3455
3456                 dash = strchr(n, '-');
3457                 if (streq_ptr(dash, "-user")) {
3458                         *scope = "user";
3459                         return 0;
3460                 }
3461         }
3462
3463         if (bus->is_user) {
3464                 *scope = "user";
3465                 return 0;
3466         }
3467
3468         if (bus->is_system) {
3469                 *scope = "system";
3470                 return 0;
3471         }
3472
3473         return -ENODATA;
3474 }
3475
3476 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3477
3478         assert_return(bus, -EINVAL);
3479         assert_return(address, -EINVAL);
3480         assert_return(!bus_pid_changed(bus), -ECHILD);
3481
3482         if (bus->address) {
3483                 *address = bus->address;
3484                 return 0;
3485         }
3486
3487         return -ENODATA;
3488 }
3489
3490 int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3491         assert_return(bus, -EINVAL);
3492         assert_return(mask, -EINVAL);
3493         assert_return(!bus_pid_changed(bus), -ECHILD);
3494
3495         *mask = bus->creds_mask;
3496         return 0;
3497 }
3498
3499 int sd_bus_is_bus_client(sd_bus *bus) {
3500         assert_return(bus, -EINVAL);
3501         assert_return(!bus_pid_changed(bus), -ECHILD);
3502
3503         return bus->bus_client;
3504 }
3505
3506 int sd_bus_is_server(sd_bus *bus) {
3507         assert_return(bus, -EINVAL);
3508         assert_return(!bus_pid_changed(bus), -ECHILD);
3509
3510         return bus->is_server;
3511 }
3512
3513 int sd_bus_is_anonymous(sd_bus *bus) {
3514         assert_return(bus, -EINVAL);
3515         assert_return(!bus_pid_changed(bus), -ECHILD);
3516
3517         return bus->anonymous_auth;
3518 }
3519
3520 int sd_bus_is_trusted(sd_bus *bus) {
3521         assert_return(bus, -EINVAL);
3522         assert_return(!bus_pid_changed(bus), -ECHILD);
3523
3524         return bus->trusted;
3525 }
3526
3527 int sd_bus_is_monitor(sd_bus *bus) {
3528         assert_return(bus, -EINVAL);
3529         assert_return(!bus_pid_changed(bus), -ECHILD);
3530
3531         return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3532 }