src/libelogind/sd-bus/sd-bus.c

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