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(bus, -EINVAL);
1696         assert_return(m, -EINVAL);
1697         assert_return(!bus_pid_changed(bus), -ECHILD);
1698         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1699
1700         if (!BUS_IS_OPEN(bus->state))
1701                 return -ENOTCONN;
1702
1703         if (m->n_fds > 0) {
1704                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1705                 if (r < 0)
1706                         return r;
1707                 if (r == 0)
1708                         return -EOPNOTSUPP;
1709         }
1710
1711         /* If the cookie number isn't kept, then we know that no reply
1712          * is expected */
1713         if (!cookie && !m->sealed)
1714                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1715
1716         r = bus_seal_message(bus, m, 0);
1717         if (r < 0)
1718                 return r;
1719
1720         /* Remarshall if we have to. This will possibly unref the
1721          * message and place a replacement in m */
1722         r = bus_remarshal_message(bus, &m);
1723         if (r < 0)
1724                 return r;
1725
1726         /* If this is a reply and no reply was requested, then let's
1727          * suppress this, if we can */
1728         if (m->dont_send)
1729                 goto finish;
1730
1731         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1732                 size_t idx = 0;
1733
1734                 r = bus_write_message(bus, m, hint_sync_call, &idx);
1735                 if (r < 0) {
1736                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1737                                 bus_enter_closing(bus);
1738                                 return -ECONNRESET;
1739                         }
1740
1741                         return r;
1742                 }
1743
1744                 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1745                         /* Wasn't fully written. So let's remember how
1746                          * much was written. Note that the first entry
1747                          * of the wqueue array is always allocated so
1748                          * that we always can remember how much was
1749                          * written. */
1750                         bus->wqueue[0] = sd_bus_message_ref(m);
1751                         bus->wqueue_size = 1;
1752                         bus->windex = idx;
1753                 }
1754
1755         } else {
1756                 /* Just append it to the queue. */
1757
1758                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1759                         return -ENOBUFS;
1760
1761                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1762                         return -ENOMEM;
1763
1764                 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1765         }
1766
1767 finish:
1768         if (cookie)
1769                 *cookie = BUS_MESSAGE_COOKIE(m);
1770
1771         return 1;
1772 }
1773
1774 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1775         return bus_send_internal(bus, m, cookie, false);
1776 }
1777
1778 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1779         int r;
1780
1781         assert_return(bus, -EINVAL);
1782         assert_return(m, -EINVAL);
1783         assert_return(!bus_pid_changed(bus), -ECHILD);
1784
1785         if (!BUS_IS_OPEN(bus->state))
1786                 return -ENOTCONN;
1787
1788         if (!streq_ptr(m->destination, destination)) {
1789
1790                 if (!destination)
1791                         return -EEXIST;
1792
1793                 r = sd_bus_message_set_destination(m, destination);
1794                 if (r < 0)
1795                         return r;
1796         }
1797
1798         return sd_bus_send(bus, m, cookie);
1799 }
1800
1801 static usec_t calc_elapse(uint64_t usec) {
1802         if (usec == (uint64_t) -1)
1803                 return 0;
1804
1805         return now(CLOCK_MONOTONIC) + usec;
1806 }
1807
1808 static int timeout_compare(const void *a, const void *b) {
1809         const struct reply_callback *x = a, *y = b;
1810
1811         if (x->timeout != 0 && y->timeout == 0)
1812                 return -1;
1813
1814         if (x->timeout == 0 && y->timeout != 0)
1815                 return 1;
1816
1817         if (x->timeout < y->timeout)
1818                 return -1;
1819
1820         if (x->timeout > y->timeout)
1821                 return 1;
1822
1823         return 0;
1824 }
1825
1826 _public_ int sd_bus_call_async(
1827                 sd_bus *bus,
1828                 sd_bus_slot **slot,
1829                 sd_bus_message *_m,
1830                 sd_bus_message_handler_t callback,
1831                 void *userdata,
1832                 uint64_t usec) {
1833
1834         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1835         _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1836         int r;
1837
1838         assert_return(bus, -EINVAL);
1839         assert_return(m, -EINVAL);
1840         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1841         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1842         assert_return(callback, -EINVAL);
1843         assert_return(!bus_pid_changed(bus), -ECHILD);
1844         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1845
1846         if (!BUS_IS_OPEN(bus->state))
1847                 return -ENOTCONN;
1848
1849         r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1850         if (r < 0)
1851                 return r;
1852
1853         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1854         if (r < 0)
1855                 return r;
1856
1857         r = bus_seal_message(bus, m, usec);
1858         if (r < 0)
1859                 return r;
1860
1861         r = bus_remarshal_message(bus, &m);
1862         if (r < 0)
1863                 return r;
1864
1865         s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1866         if (!s)
1867                 return -ENOMEM;
1868
1869         s->reply_callback.callback = callback;
1870
1871         s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1872         r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1873         if (r < 0) {
1874                 s->reply_callback.cookie = 0;
1875                 return r;
1876         }
1877
1878         s->reply_callback.timeout = calc_elapse(m->timeout);
1879         if (s->reply_callback.timeout != 0) {
1880                 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1881                 if (r < 0) {
1882                         s->reply_callback.timeout = 0;
1883                         return r;
1884                 }
1885         }
1886
1887         r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1888         if (r < 0)
1889                 return r;
1890
1891         if (slot)
1892                 *slot = s;
1893         s = NULL;
1894
1895         return r;
1896 }
1897
1898 int bus_ensure_running(sd_bus *bus) {
1899         int r;
1900
1901         assert(bus);
1902
1903         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1904                 return -ENOTCONN;
1905         if (bus->state == BUS_RUNNING)
1906                 return 1;
1907
1908         for (;;) {
1909                 r = sd_bus_process(bus, NULL);
1910                 if (r < 0)
1911                         return r;
1912                 if (bus->state == BUS_RUNNING)
1913                         return 1;
1914                 if (r > 0)
1915                         continue;
1916
1917                 r = sd_bus_wait(bus, (uint64_t) -1);
1918                 if (r < 0)
1919                         return r;
1920         }
1921 }
1922
1923 _public_ int sd_bus_call(
1924                 sd_bus *bus,
1925                 sd_bus_message *_m,
1926                 uint64_t usec,
1927                 sd_bus_error *error,
1928                 sd_bus_message **reply) {
1929
1930         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1931         usec_t timeout;
1932         uint64_t cookie;
1933         unsigned i;
1934         int r;
1935
1936         assert_return(bus, -EINVAL);
1937         assert_return(m, -EINVAL);
1938         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1939         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1940         assert_return(!bus_error_is_dirty(error), -EINVAL);
1941         assert_return(!bus_pid_changed(bus), -ECHILD);
1942         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1943
1944         if (!BUS_IS_OPEN(bus->state))
1945                 return -ENOTCONN;
1946
1947         r = bus_ensure_running(bus);
1948         if (r < 0)
1949                 return r;
1950
1951         i = bus->rqueue_size;
1952
1953         r = bus_seal_message(bus, m, usec);
1954         if (r < 0)
1955                 return r;
1956
1957         r = bus_remarshal_message(bus, &m);
1958         if (r < 0)
1959                 return r;
1960
1961         r = bus_send_internal(bus, m, &cookie, true);
1962         if (r < 0)
1963                 return r;
1964
1965         timeout = calc_elapse(m->timeout);
1966
1967         for (;;) {
1968                 usec_t left;
1969
1970                 while (i < bus->rqueue_size) {
1971                         sd_bus_message *incoming = NULL;
1972
1973                         incoming = bus->rqueue[i];
1974
1975                         if (incoming->reply_cookie == cookie) {
1976                                 /* Found a match! */
1977
1978                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1979                                 bus->rqueue_size--;
1980
1981                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1982
1983                                         if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
1984                                                 if (reply)
1985                                                         *reply = incoming;
1986                                                 else
1987                                                         sd_bus_message_unref(incoming);
1988
1989                                                 return 1;
1990                                         }
1991
1992                                         r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
1993
1994                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1995                                         r = sd_bus_error_copy(error, &incoming->error);
1996                                 else
1997                                         r = -EIO;
1998
1999                                 sd_bus_message_unref(incoming);
2000                                 return r;
2001
2002                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2003                                    bus->unique_name &&
2004                                    incoming->sender &&
2005                                    streq(bus->unique_name, incoming->sender)) {
2006
2007                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2008                                 bus->rqueue_size--;
2009
2010                                 /* Our own message? Somebody is trying
2011                                  * to send its own client a message,
2012                                  * let's not dead-lock, let's fail
2013                                  * immediately. */
2014
2015                                 sd_bus_message_unref(incoming);
2016                                 return -ELOOP;
2017                         }
2018
2019                         /* Try to read more, right-away */
2020                         i++;
2021                 }
2022
2023                 r = bus_read_message(bus, false, 0);
2024                 if (r < 0) {
2025                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2026                                 bus_enter_closing(bus);
2027                                 return -ECONNRESET;
2028                         }
2029
2030                         return r;
2031                 }
2032                 if (r > 0)
2033                         continue;
2034
2035                 if (timeout > 0) {
2036                         usec_t n;
2037
2038                         n = now(CLOCK_MONOTONIC);
2039                         if (n >= timeout)
2040                                 return -ETIMEDOUT;
2041
2042                         left = timeout - n;
2043                 } else
2044                         left = (uint64_t) -1;
2045
2046                 r = bus_poll(bus, true, left);
2047                 if (r < 0)
2048                         return r;
2049                 if (r == 0)
2050                         return -ETIMEDOUT;
2051
2052                 r = dispatch_wqueue(bus);
2053                 if (r < 0) {
2054                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2055                                 bus_enter_closing(bus);
2056                                 return -ECONNRESET;
2057                         }
2058
2059                         return r;
2060                 }
2061         }
2062 }
2063
2064 _public_ int sd_bus_get_fd(sd_bus *bus) {
2065
2066         assert_return(bus, -EINVAL);
2067         assert_return(bus->input_fd == bus->output_fd, -EPERM);
2068         assert_return(!bus_pid_changed(bus), -ECHILD);
2069
2070         return bus->input_fd;
2071 }
2072
2073 _public_ int sd_bus_get_events(sd_bus *bus) {
2074         int flags = 0;
2075
2076         assert_return(bus, -EINVAL);
2077         assert_return(!bus_pid_changed(bus), -ECHILD);
2078
2079         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2080                 return -ENOTCONN;
2081
2082         if (bus->state == BUS_OPENING)
2083                 flags |= POLLOUT;
2084         else if (bus->state == BUS_AUTHENTICATING) {
2085
2086                 if (bus_socket_auth_needs_write(bus))
2087                         flags |= POLLOUT;
2088
2089                 flags |= POLLIN;
2090
2091         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2092                 if (bus->rqueue_size <= 0)
2093                         flags |= POLLIN;
2094                 if (bus->wqueue_size > 0)
2095                         flags |= POLLOUT;
2096         }
2097
2098         return flags;
2099 }
2100
2101 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2102         struct reply_callback *c;
2103
2104         assert_return(bus, -EINVAL);
2105         assert_return(timeout_usec, -EINVAL);
2106         assert_return(!bus_pid_changed(bus), -ECHILD);
2107
2108         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2109                 return -ENOTCONN;
2110
2111         if (bus->track_queue) {
2112                 *timeout_usec = 0;
2113                 return 1;
2114         }
2115
2116         if (bus->state == BUS_CLOSING) {
2117                 *timeout_usec = 0;
2118                 return 1;
2119         }
2120
2121         if (bus->state == BUS_AUTHENTICATING) {
2122                 *timeout_usec = bus->auth_timeout;
2123                 return 1;
2124         }
2125
2126         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2127                 *timeout_usec = (uint64_t) -1;
2128                 return 0;
2129         }
2130
2131         if (bus->rqueue_size > 0) {
2132                 *timeout_usec = 0;
2133                 return 1;
2134         }
2135
2136         c = prioq_peek(bus->reply_callbacks_prioq);
2137         if (!c) {
2138                 *timeout_usec = (uint64_t) -1;
2139                 return 0;
2140         }
2141
2142         if (c->timeout == 0) {
2143                 *timeout_usec = (uint64_t) -1;
2144                 return 0;
2145         }
2146
2147         *timeout_usec = c->timeout;
2148         return 1;
2149 }
2150
2151 static int process_timeout(sd_bus *bus) {
2152         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2153         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2154         struct reply_callback *c;
2155         sd_bus_slot *slot;
2156         usec_t n;
2157         int r;
2158
2159         assert(bus);
2160
2161         c = prioq_peek(bus->reply_callbacks_prioq);
2162         if (!c)
2163                 return 0;
2164
2165         n = now(CLOCK_MONOTONIC);
2166         if (c->timeout > n)
2167                 return 0;
2168
2169         r = bus_message_new_synthetic_error(
2170                         bus,
2171                         c->cookie,
2172                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2173                         &m);
2174         if (r < 0)
2175                 return r;
2176
2177         r = bus_seal_synthetic_message(bus, m);
2178         if (r < 0)
2179                 return r;
2180
2181         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2182         c->timeout = 0;
2183
2184         ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2185         c->cookie = 0;
2186
2187         slot = container_of(c, sd_bus_slot, reply_callback);
2188
2189         bus->iteration_counter ++;
2190
2191         bus->current_message = m;
2192         bus->current_slot = sd_bus_slot_ref(slot);
2193         bus->current_handler = c->callback;
2194         bus->current_userdata = slot->userdata;
2195         r = c->callback(m, slot->userdata, &error_buffer);
2196         bus->current_userdata = NULL;
2197         bus->current_handler = NULL;
2198         bus->current_slot = NULL;
2199         bus->current_message = NULL;
2200
2201         if (slot->floating) {
2202                 bus_slot_disconnect(slot);
2203                 sd_bus_slot_unref(slot);
2204         }
2205
2206         sd_bus_slot_unref(slot);
2207
2208         return bus_maybe_reply_error(m, r, &error_buffer);
2209 }
2210
2211 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2212         assert(bus);
2213         assert(m);
2214
2215         if (bus->state != BUS_HELLO)
2216                 return 0;
2217
2218         /* Let's make sure the first message on the bus is the HELLO
2219          * reply. But note that we don't actually parse the message
2220          * here (we leave that to the usual handling), we just verify
2221          * we don't let any earlier msg through. */
2222
2223         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2224             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2225                 return -EIO;
2226
2227         if (m->reply_cookie != 1)
2228                 return -EIO;
2229
2230         return 0;
2231 }
2232
2233 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2234         _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2235         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2236         struct reply_callback *c;
2237         sd_bus_slot *slot;
2238         int r;
2239
2240         assert(bus);
2241         assert(m);
2242
2243         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2244             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2245                 return 0;
2246
2247         if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2248                 return 0;
2249
2250         if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2251                 return 0;
2252
2253         c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2254         if (!c)
2255                 return 0;
2256
2257         c->cookie = 0;
2258
2259         slot = container_of(c, sd_bus_slot, reply_callback);
2260
2261         if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2262
2263                 /* If the reply contained a file descriptor which we
2264                  * didn't want we pass an error instead. */
2265
2266                 r = bus_message_new_synthetic_error(
2267                                 bus,
2268                                 m->reply_cookie,
2269                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2270                                 &synthetic_reply);
2271                 if (r < 0)
2272                         return r;
2273
2274                 /* Copy over original timestamp */
2275                 synthetic_reply->realtime = m->realtime;
2276                 synthetic_reply->monotonic = m->monotonic;
2277                 synthetic_reply->seqnum = m->seqnum;
2278
2279                 r = bus_seal_synthetic_message(bus, synthetic_reply);
2280                 if (r < 0)
2281                         return r;
2282
2283                 m = synthetic_reply;
2284         } else {
2285                 r = sd_bus_message_rewind(m, true);
2286                 if (r < 0)
2287                         return r;
2288         }
2289
2290         if (c->timeout != 0) {
2291                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2292                 c->timeout = 0;
2293         }
2294
2295         bus->current_slot = sd_bus_slot_ref(slot);
2296         bus->current_handler = c->callback;
2297         bus->current_userdata = slot->userdata;
2298         r = c->callback(m, slot->userdata, &error_buffer);
2299         bus->current_userdata = NULL;
2300         bus->current_handler = NULL;
2301         bus->current_slot = NULL;
2302
2303         if (slot->floating) {
2304                 bus_slot_disconnect(slot);
2305                 sd_bus_slot_unref(slot);
2306         }
2307
2308         sd_bus_slot_unref(slot);
2309
2310         return bus_maybe_reply_error(m, r, &error_buffer);
2311 }
2312
2313 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2314         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2315         struct filter_callback *l;
2316         int r;
2317
2318         assert(bus);
2319         assert(m);
2320
2321         do {
2322                 bus->filter_callbacks_modified = false;
2323
2324                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2325                         sd_bus_slot *slot;
2326
2327                         if (bus->filter_callbacks_modified)
2328                                 break;
2329
2330                         /* Don't run this more than once per iteration */
2331                         if (l->last_iteration == bus->iteration_counter)
2332                                 continue;
2333
2334                         l->last_iteration = bus->iteration_counter;
2335
2336                         r = sd_bus_message_rewind(m, true);
2337                         if (r < 0)
2338                                 return r;
2339
2340                         slot = container_of(l, sd_bus_slot, filter_callback);
2341
2342                         bus->current_slot = sd_bus_slot_ref(slot);
2343                         bus->current_handler = l->callback;
2344                         bus->current_userdata = slot->userdata;
2345                         r = l->callback(m, slot->userdata, &error_buffer);
2346                         bus->current_userdata = NULL;
2347                         bus->current_handler = NULL;
2348                         bus->current_slot = sd_bus_slot_unref(slot);
2349
2350                         r = bus_maybe_reply_error(m, r, &error_buffer);
2351                         if (r != 0)
2352                                 return r;
2353
2354                 }
2355
2356         } while (bus->filter_callbacks_modified);
2357
2358         return 0;
2359 }
2360
2361 static int process_match(sd_bus *bus, sd_bus_message *m) {
2362         int r;
2363
2364         assert(bus);
2365         assert(m);
2366
2367         do {
2368                 bus->match_callbacks_modified = false;
2369
2370                 r = bus_match_run(bus, &bus->match_callbacks, m);
2371                 if (r != 0)
2372                         return r;
2373
2374         } while (bus->match_callbacks_modified);
2375
2376         return 0;
2377 }
2378
2379 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2380         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2381         int r;
2382
2383         assert(bus);
2384         assert(m);
2385
2386         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2387                 return 0;
2388
2389         if (bus->manual_peer_interface)
2390                 return 0;
2391
2392         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2393                 return 0;
2394
2395         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2396                 return 0;
2397
2398         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2399                 return 1;
2400
2401         if (streq_ptr(m->member, "Ping"))
2402                 r = sd_bus_message_new_method_return(m, &reply);
2403         else if (streq_ptr(m->member, "GetMachineId")) {
2404                 sd_id128_t id;
2405                 char sid[33];
2406
2407                 r = sd_id128_get_machine(&id);
2408                 if (r < 0)
2409                         return r;
2410
2411                 r = sd_bus_message_new_method_return(m, &reply);
2412                 if (r < 0)
2413                         return r;
2414
2415                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2416         } else {
2417                 r = sd_bus_message_new_method_errorf(
2418                                 m, &reply,
2419                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2420                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2421         }
2422
2423         if (r < 0)
2424                 return r;
2425
2426         r = sd_bus_send(bus, reply, NULL);
2427         if (r < 0)
2428                 return r;
2429
2430         return 1;
2431 }
2432
2433 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2434         assert(bus);
2435         assert(m);
2436
2437         /* If we got a message with a file descriptor which we didn't
2438          * want to accept, then let's drop it. How can this even
2439          * happen? For example, when the kernel queues a message into
2440          * an activatable names's queue which allows fds, and then is
2441          * delivered to us later even though we ourselves did not
2442          * negotiate it. */
2443
2444         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2445                 return 0;
2446
2447         if (m->n_fds <= 0)
2448                 return 0;
2449
2450         if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2451                 return 0;
2452
2453         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2454                 return 1; /* just eat it up */
2455
2456         return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2457 }
2458
2459 static int process_message(sd_bus *bus, sd_bus_message *m) {
2460         int r;
2461
2462         assert(bus);
2463         assert(m);
2464
2465         bus->current_message = m;
2466         bus->iteration_counter++;
2467
2468         log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
2469                   bus_message_type_to_string(m->header->type),
2470                   strna(sd_bus_message_get_sender(m)),
2471                   strna(sd_bus_message_get_destination(m)),
2472                   strna(sd_bus_message_get_path(m)),
2473                   strna(sd_bus_message_get_interface(m)),
2474                   strna(sd_bus_message_get_member(m)),
2475                   BUS_MESSAGE_COOKIE(m),
2476                   m->reply_cookie,
2477                   strna(m->error.message));
2478
2479         r = process_hello(bus, m);
2480         if (r != 0)
2481                 goto finish;
2482
2483         r = process_reply(bus, m);
2484         if (r != 0)
2485                 goto finish;
2486
2487         r = process_fd_check(bus, m);
2488         if (r != 0)
2489                 goto finish;
2490
2491         r = process_filter(bus, m);
2492         if (r != 0)
2493                 goto finish;
2494
2495         r = process_match(bus, m);
2496         if (r != 0)
2497                 goto finish;
2498
2499         r = process_builtin(bus, m);
2500         if (r != 0)
2501                 goto finish;
2502
2503         r = bus_process_object(bus, m);
2504
2505 finish:
2506         bus->current_message = NULL;
2507         return r;
2508 }
2509
2510 static int dispatch_track(sd_bus *bus) {
2511         assert(bus);
2512
2513         if (!bus->track_queue)
2514                 return 0;
2515
2516         bus_track_dispatch(bus->track_queue);
2517         return 1;
2518 }
2519
2520 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2521         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2522         int r;
2523
2524         assert(bus);
2525         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2526
2527         r = process_timeout(bus);
2528         if (r != 0)
2529                 goto null_message;
2530
2531         r = dispatch_wqueue(bus);
2532         if (r != 0)
2533                 goto null_message;
2534
2535         r = dispatch_track(bus);
2536         if (r != 0)
2537                 goto null_message;
2538
2539         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2540         if (r < 0)
2541                 return r;
2542         if (!m)
2543                 goto null_message;
2544
2545         r = process_message(bus, m);
2546         if (r != 0)
2547                 goto null_message;
2548
2549         if (ret) {
2550                 r = sd_bus_message_rewind(m, true);
2551                 if (r < 0)
2552                         return r;
2553
2554                 *ret = m;
2555                 m = NULL;
2556                 return 1;
2557         }
2558
2559         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2560
2561                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2562                           strna(sd_bus_message_get_sender(m)),
2563                           strna(sd_bus_message_get_path(m)),
2564                           strna(sd_bus_message_get_interface(m)),
2565                           strna(sd_bus_message_get_member(m)));
2566
2567                 r = sd_bus_reply_method_errorf(
2568                                 m,
2569                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2570                                 "Unknown object '%s'.", m->path);
2571                 if (r < 0)
2572                         return r;
2573         }
2574
2575         return 1;
2576
2577 null_message:
2578         if (r >= 0 && ret)
2579                 *ret = NULL;
2580
2581         return r;
2582 }
2583
2584 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2585         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2586         struct reply_callback *c;
2587         int r;
2588
2589         assert(bus);
2590         assert(bus->state == BUS_CLOSING);
2591
2592         c = ordered_hashmap_first(bus->reply_callbacks);
2593         if (c) {
2594                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2595                 sd_bus_slot *slot;
2596
2597                 /* First, fail all outstanding method calls */
2598                 r = bus_message_new_synthetic_error(
2599                                 bus,
2600                                 c->cookie,
2601                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2602                                 &m);
2603                 if (r < 0)
2604                         return r;
2605
2606                 r = bus_seal_synthetic_message(bus, m);
2607                 if (r < 0)
2608                         return r;
2609
2610                 if (c->timeout != 0) {
2611                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2612                         c->timeout = 0;
2613                 }
2614
2615                 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2616                 c->cookie = 0;
2617
2618                 slot = container_of(c, sd_bus_slot, reply_callback);
2619
2620                 bus->iteration_counter++;
2621
2622                 bus->current_message = m;
2623                 bus->current_slot = sd_bus_slot_ref(slot);
2624                 bus->current_handler = c->callback;
2625                 bus->current_userdata = slot->userdata;
2626                 r = c->callback(m, slot->userdata, &error_buffer);
2627                 bus->current_userdata = NULL;
2628                 bus->current_handler = NULL;
2629                 bus->current_slot = NULL;
2630                 bus->current_message = NULL;
2631
2632                 if (slot->floating) {
2633                         bus_slot_disconnect(slot);
2634                         sd_bus_slot_unref(slot);
2635                 }
2636
2637                 sd_bus_slot_unref(slot);
2638
2639                 return bus_maybe_reply_error(m, r, &error_buffer);
2640         }
2641
2642         /* Then, synthesize a Disconnected message */
2643         r = sd_bus_message_new_signal(
2644                         bus,
2645                         &m,
2646                         "/org/freedesktop/DBus/Local",
2647                         "org.freedesktop.DBus.Local",
2648                         "Disconnected");
2649         if (r < 0)
2650                 return r;
2651
2652         bus_message_set_sender_local(bus, m);
2653
2654         r = bus_seal_synthetic_message(bus, m);
2655         if (r < 0)
2656                 return r;
2657
2658         sd_bus_close(bus);
2659
2660         bus->current_message = m;
2661         bus->iteration_counter++;
2662
2663         r = process_filter(bus, m);
2664         if (r != 0)
2665                 goto finish;
2666
2667         r = process_match(bus, m);
2668         if (r != 0)
2669                 goto finish;
2670
2671         if (ret) {
2672                 *ret = m;
2673                 m = NULL;
2674         }
2675
2676         r = 1;
2677
2678 finish:
2679         bus->current_message = NULL;
2680
2681         return r;
2682 }
2683
2684 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2685         BUS_DONT_DESTROY(bus);
2686         int r;
2687
2688         /* Returns 0 when we didn't do anything. This should cause the
2689          * caller to invoke sd_bus_wait() before returning the next
2690          * time. Returns > 0 when we did something, which possibly
2691          * means *ret is filled in with an unprocessed message. */
2692
2693         assert_return(bus, -EINVAL);
2694         assert_return(!bus_pid_changed(bus), -ECHILD);
2695
2696         /* We don't allow recursively invoking sd_bus_process(). */
2697         assert_return(!bus->current_message, -EBUSY);
2698         assert(!bus->current_slot);
2699
2700         switch (bus->state) {
2701
2702         case BUS_UNSET:
2703                 return -ENOTCONN;
2704
2705         case BUS_CLOSED:
2706                 return -ECONNRESET;
2707
2708         case BUS_OPENING:
2709                 r = bus_socket_process_opening(bus);
2710                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2711                         bus_enter_closing(bus);
2712                         r = 1;
2713                 } else if (r < 0)
2714                         return r;
2715                 if (ret)
2716                         *ret = NULL;
2717                 return r;
2718
2719         case BUS_AUTHENTICATING:
2720                 r = bus_socket_process_authenticating(bus);
2721                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2722                         bus_enter_closing(bus);
2723                         r = 1;
2724                 } else if (r < 0)
2725                         return r;
2726
2727                 if (ret)
2728                         *ret = NULL;
2729
2730                 return r;
2731
2732         case BUS_RUNNING:
2733         case BUS_HELLO:
2734                 r = process_running(bus, hint_priority, priority, ret);
2735                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2736                         bus_enter_closing(bus);
2737                         r = 1;
2738
2739                         if (ret)
2740                                 *ret = NULL;
2741                 }
2742
2743                 return r;
2744
2745         case BUS_CLOSING:
2746                 return process_closing(bus, ret);
2747         }
2748
2749         assert_not_reached("Unknown state");
2750 }
2751
2752 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2753         return bus_process_internal(bus, false, 0, ret);
2754 }
2755
2756 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2757         return bus_process_internal(bus, true, priority, ret);
2758 }
2759
2760 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2761         struct pollfd p[2] = {};
2762         int r, e, n;
2763         struct timespec ts;
2764         usec_t m = USEC_INFINITY;
2765
2766         assert(bus);
2767
2768         if (bus->state == BUS_CLOSING)
2769                 return 1;
2770
2771         if (!BUS_IS_OPEN(bus->state))
2772                 return -ENOTCONN;
2773
2774         e = sd_bus_get_events(bus);
2775         if (e < 0)
2776                 return e;
2777
2778         if (need_more)
2779                 /* The caller really needs some more data, he doesn't
2780                  * care about what's already read, or any timeouts
2781                  * except its own. */
2782                 e |= POLLIN;
2783         else {
2784                 usec_t until;
2785                 /* The caller wants to process if there's something to
2786                  * process, but doesn't care otherwise */
2787
2788                 r = sd_bus_get_timeout(bus, &until);
2789                 if (r < 0)
2790                         return r;
2791                 if (r > 0) {
2792                         usec_t nw;
2793                         nw = now(CLOCK_MONOTONIC);
2794                         m = until > nw ? until - nw : 0;
2795                 }
2796         }
2797
2798         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2799                 m = timeout_usec;
2800
2801         p[0].fd = bus->input_fd;
2802         if (bus->output_fd == bus->input_fd) {
2803                 p[0].events = e;
2804                 n = 1;
2805         } else {
2806                 p[0].events = e & POLLIN;
2807                 p[1].fd = bus->output_fd;
2808                 p[1].events = e & POLLOUT;
2809                 n = 2;
2810         }
2811
2812         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2813         if (r < 0)
2814                 return -errno;
2815
2816         return r > 0 ? 1 : 0;
2817 }
2818
2819 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2820
2821         assert_return(bus, -EINVAL);
2822         assert_return(!bus_pid_changed(bus), -ECHILD);
2823
2824         if (bus->state == BUS_CLOSING)
2825                 return 0;
2826
2827         if (!BUS_IS_OPEN(bus->state))
2828                 return -ENOTCONN;
2829
2830         if (bus->rqueue_size > 0)
2831                 return 0;
2832
2833         return bus_poll(bus, false, timeout_usec);
2834 }
2835
2836 _public_ int sd_bus_flush(sd_bus *bus) {
2837         int r;
2838
2839         assert_return(bus, -EINVAL);
2840         assert_return(!bus_pid_changed(bus), -ECHILD);
2841
2842         if (bus->state == BUS_CLOSING)
2843                 return 0;
2844
2845         if (!BUS_IS_OPEN(bus->state))
2846                 return -ENOTCONN;
2847
2848         r = bus_ensure_running(bus);
2849         if (r < 0)
2850                 return r;
2851
2852         if (bus->wqueue_size <= 0)
2853                 return 0;
2854
2855         for (;;) {
2856                 r = dispatch_wqueue(bus);
2857                 if (r < 0) {
2858                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2859                                 bus_enter_closing(bus);
2860                                 return -ECONNRESET;
2861                         }
2862
2863                         return r;
2864                 }
2865
2866                 if (bus->wqueue_size <= 0)
2867                         return 0;
2868
2869                 r = bus_poll(bus, false, (uint64_t) -1);
2870                 if (r < 0)
2871                         return r;
2872         }
2873 }
2874
2875 _public_ int sd_bus_add_filter(
2876                 sd_bus *bus,
2877                 sd_bus_slot **slot,
2878                 sd_bus_message_handler_t callback,
2879                 void *userdata) {
2880
2881         sd_bus_slot *s;
2882
2883         assert_return(bus, -EINVAL);
2884         assert_return(callback, -EINVAL);
2885         assert_return(!bus_pid_changed(bus), -ECHILD);
2886
2887         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2888         if (!s)
2889                 return -ENOMEM;
2890
2891         s->filter_callback.callback = callback;
2892
2893         bus->filter_callbacks_modified = true;
2894         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2895
2896         if (slot)
2897                 *slot = s;
2898
2899         return 0;
2900 }
2901
2902 _public_ int sd_bus_add_match(
2903                 sd_bus *bus,
2904                 sd_bus_slot **slot,
2905                 const char *match,
2906                 sd_bus_message_handler_t callback,
2907                 void *userdata) {
2908
2909         struct bus_match_component *components = NULL;
2910         unsigned n_components = 0;
2911         sd_bus_slot *s = NULL;
2912         int r = 0;
2913
2914         assert_return(bus, -EINVAL);
2915         assert_return(match, -EINVAL);
2916         assert_return(!bus_pid_changed(bus), -ECHILD);
2917
2918         r = bus_match_parse(match, &components, &n_components);
2919         if (r < 0)
2920                 goto finish;
2921
2922         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2923         if (!s) {
2924                 r = -ENOMEM;
2925                 goto finish;
2926         }
2927
2928         s->match_callback.callback = callback;
2929         s->match_callback.cookie = ++bus->match_cookie;
2930
2931         if (bus->bus_client) {
2932
2933                 if (!bus->is_kernel) {
2934                         /* When this is not a kernel transport, we
2935                          * store the original match string, so that we
2936                          * can use it to remove the match again */
2937
2938                         s->match_callback.match_string = strdup(match);
2939                         if (!s->match_callback.match_string) {
2940                                 r = -ENOMEM;
2941                                 goto finish;
2942                         }
2943                 }
2944
2945                 r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
2946                 if (r < 0)
2947                         goto finish;
2948         }
2949
2950         bus->match_callbacks_modified = true;
2951         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
2952         if (r < 0)
2953                 goto finish;
2954
2955         if (slot)
2956                 *slot = s;
2957         s = NULL;
2958
2959 finish:
2960         bus_match_parse_free(components, n_components);
2961         sd_bus_slot_unref(s);
2962
2963         return r;
2964 }
2965
2966 int bus_remove_match_by_string(
2967                 sd_bus *bus,
2968                 const char *match,
2969                 sd_bus_message_handler_t callback,
2970                 void *userdata) {
2971
2972         struct bus_match_component *components = NULL;
2973         unsigned n_components = 0;
2974         struct match_callback *c;
2975         int r = 0;
2976
2977         assert_return(bus, -EINVAL);
2978         assert_return(match, -EINVAL);
2979         assert_return(!bus_pid_changed(bus), -ECHILD);
2980
2981         r = bus_match_parse(match, &components, &n_components);
2982         if (r < 0)
2983                 goto finish;
2984
2985         r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
2986         if (r <= 0)
2987                 goto finish;
2988
2989         sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
2990
2991 finish:
2992         bus_match_parse_free(components, n_components);
2993
2994         return r;
2995 }
2996
2997 bool bus_pid_changed(sd_bus *bus) {
2998         assert(bus);
2999
3000         /* We don't support people creating a bus connection and
3001          * keeping it around over a fork(). Let's complain. */
3002
3003         return bus->original_pid != getpid();
3004 }
3005
3006 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3007         sd_bus *bus = userdata;
3008         int r;
3009
3010         assert(bus);
3011
3012         r = sd_bus_process(bus, NULL);
3013         if (r < 0)
3014                 return r;
3015
3016         return 1;
3017 }
3018
3019 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3020         sd_bus *bus = userdata;
3021         int r;
3022
3023         assert(bus);
3024
3025         r = sd_bus_process(bus, NULL);
3026         if (r < 0)
3027                 return r;
3028
3029         return 1;
3030 }
3031
3032 static int prepare_callback(sd_event_source *s, void *userdata) {
3033         sd_bus *bus = userdata;
3034         int r, e;
3035         usec_t until;
3036
3037         assert(s);
3038         assert(bus);
3039
3040         e = sd_bus_get_events(bus);
3041         if (e < 0)
3042                 return e;
3043
3044         if (bus->output_fd != bus->input_fd) {
3045
3046                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3047                 if (r < 0)
3048                         return r;
3049
3050                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3051                 if (r < 0)
3052                         return r;
3053         } else {
3054                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3055                 if (r < 0)
3056                         return r;
3057         }
3058
3059         r = sd_bus_get_timeout(bus, &until);
3060         if (r < 0)
3061                 return r;
3062         if (r > 0) {
3063                 int j;
3064
3065                 j = sd_event_source_set_time(bus->time_event_source, until);
3066                 if (j < 0)
3067                         return j;
3068         }
3069
3070         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3071         if (r < 0)
3072                 return r;
3073
3074         return 1;
3075 }
3076
3077 static int quit_callback(sd_event_source *event, void *userdata) {
3078         sd_bus *bus = userdata;
3079
3080         assert(event);
3081
3082         sd_bus_flush(bus);
3083         sd_bus_close(bus);
3084
3085         return 1;
3086 }
3087
3088 static int attach_io_events(sd_bus *bus) {
3089         int r;
3090
3091         assert(bus);
3092
3093         if (bus->input_fd < 0)
3094                 return 0;
3095
3096         if (!bus->event)
3097                 return 0;
3098
3099         if (!bus->input_io_event_source) {
3100                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3101                 if (r < 0)
3102                         return r;
3103
3104                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3105                 if (r < 0)
3106                         return r;
3107
3108                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3109                 if (r < 0)
3110                         return r;
3111
3112                 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3113         } else
3114                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3115
3116         if (r < 0)
3117                 return r;
3118
3119         if (bus->output_fd != bus->input_fd) {
3120                 assert(bus->output_fd >= 0);
3121
3122                 if (!bus->output_io_event_source) {
3123                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3124                         if (r < 0)
3125                                 return r;
3126
3127                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3128                         if (r < 0)
3129                                 return r;
3130
3131                         r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3132                 } else
3133                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3134
3135                 if (r < 0)
3136                         return r;
3137         }
3138
3139         return 0;
3140 }
3141
3142 static void detach_io_events(sd_bus *bus) {
3143         assert(bus);
3144
3145         if (bus->input_io_event_source) {
3146                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3147                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3148         }
3149
3150         if (bus->output_io_event_source) {
3151                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3152                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3153         }
3154 }
3155
3156 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3157         int r;
3158
3159         assert_return(bus, -EINVAL);
3160         assert_return(!bus->event, -EBUSY);
3161
3162         assert(!bus->input_io_event_source);
3163         assert(!bus->output_io_event_source);
3164         assert(!bus->time_event_source);
3165
3166         if (event)
3167                 bus->event = sd_event_ref(event);
3168         else  {
3169                 r = sd_event_default(&bus->event);
3170                 if (r < 0)
3171                         return r;
3172         }
3173
3174         bus->event_priority = priority;
3175
3176         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3177         if (r < 0)
3178                 goto fail;
3179
3180         r = sd_event_source_set_priority(bus->time_event_source, priority);
3181         if (r < 0)
3182                 goto fail;
3183
3184         r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3185         if (r < 0)
3186                 goto fail;
3187
3188         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3189         if (r < 0)
3190                 goto fail;
3191
3192         r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3193         if (r < 0)
3194                 goto fail;
3195
3196         r = attach_io_events(bus);
3197         if (r < 0)
3198                 goto fail;
3199
3200         return 0;
3201
3202 fail:
3203         sd_bus_detach_event(bus);
3204         return r;
3205 }
3206
3207 _public_ int sd_bus_detach_event(sd_bus *bus) {
3208         assert_return(bus, -EINVAL);
3209
3210         if (!bus->event)
3211                 return 0;
3212
3213         detach_io_events(bus);
3214
3215         if (bus->time_event_source) {
3216                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3217                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3218         }
3219
3220         if (bus->quit_event_source) {
3221                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3222                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3223         }
3224
3225         bus->event = sd_event_unref(bus->event);
3226         return 1;
3227 }
3228
3229 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3230         assert_return(bus, NULL);
3231
3232         return bus->event;
3233 }
3234
3235 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3236         assert_return(bus, NULL);
3237
3238         return bus->current_message;
3239 }
3240
3241 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3242         assert_return(bus, NULL);
3243
3244         return bus->current_slot;
3245 }
3246
3247 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3248         assert_return(bus, NULL);
3249
3250         return bus->current_handler;
3251 }
3252
3253 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3254         assert_return(bus, NULL);
3255
3256         return bus->current_userdata;
3257 }
3258
3259 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3260         sd_bus *b = NULL;
3261         int r;
3262
3263         assert(bus_open);
3264         assert(default_bus);
3265
3266         if (!ret)
3267                 return !!*default_bus;
3268
3269         if (*default_bus) {
3270                 *ret = sd_bus_ref(*default_bus);
3271                 return 0;
3272         }
3273
3274         r = bus_open(&b);
3275         if (r < 0)
3276                 return r;
3277
3278         b->default_bus_ptr = default_bus;
3279         b->tid = gettid();
3280         *default_bus = b;
3281
3282         *ret = b;
3283         return 1;
3284 }
3285
3286 _public_ int sd_bus_default_system(sd_bus **ret) {
3287         static thread_local sd_bus *default_system_bus = NULL;
3288
3289         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3290 }
3291
3292 _public_ int sd_bus_default_user(sd_bus **ret) {
3293         static thread_local sd_bus *default_user_bus = NULL;
3294
3295         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3296 }
3297
3298 _public_ int sd_bus_default(sd_bus **ret) {
3299
3300         const char *e;
3301
3302         /* Let's try our best to reuse another cached connection. If
3303          * the starter bus type is set, connect via our normal
3304          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3305          * we can share the connection with the user/system default
3306          * bus. */
3307
3308         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3309         if (e) {
3310                 if (streq(e, "system"))
3311                         return sd_bus_default_system(ret);
3312                 else if (STR_IN_SET(e, "user", "session"))
3313                         return sd_bus_default_user(ret);
3314         }
3315
3316         /* No type is specified, so we have not other option than to
3317          * use the starter address if it is set. */
3318
3319         e = secure_getenv("DBUS_STARTER_ADDRESS");
3320         if (e) {
3321                 static thread_local sd_bus *default_starter_bus = NULL;
3322
3323                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3324         }
3325
3326         /* Finally, if nothing is set use the cached connection for
3327          * the right scope */
3328
3329         return sd_bus_default_system(ret);
3330 }
3331
3332 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3333         assert_return(b, -EINVAL);
3334         assert_return(tid, -EINVAL);
3335         assert_return(!bus_pid_changed(b), -ECHILD);
3336
3337         if (b->tid != 0) {
3338                 *tid = b->tid;
3339                 return 0;
3340         }
3341
3342         if (b->event)
3343                 return sd_event_get_tid(b->event, tid);
3344
3345         return -ENXIO;
3346 }
3347
3348 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3349         _cleanup_free_ char *e = NULL;
3350         char *ret;
3351
3352         assert_return(object_path_is_valid(prefix), -EINVAL);
3353         assert_return(external_id, -EINVAL);
3354         assert_return(ret_path, -EINVAL);
3355
3356         e = bus_label_escape(external_id);
3357         if (!e)
3358                 return -ENOMEM;
3359
3360         ret = strjoin(prefix, "/", e, NULL);
3361         if (!ret)
3362                 return -ENOMEM;
3363
3364         *ret_path = ret;
3365         return 0;
3366 }
3367
3368 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3369         const char *e;
3370         char *ret;
3371
3372         assert_return(object_path_is_valid(path), -EINVAL);
3373         assert_return(object_path_is_valid(prefix), -EINVAL);
3374         assert_return(external_id, -EINVAL);
3375
3376         e = object_path_startswith(path, prefix);
3377         if (!e) {
3378                 *external_id = NULL;
3379                 return 0;
3380         }
3381
3382         ret = bus_label_unescape(e);
3383         if (!ret)
3384                 return -ENOMEM;
3385
3386         *external_id = ret;
3387         return 1;
3388 }
3389
3390 _public_ int sd_bus_try_close(sd_bus *bus) {
3391         int r;
3392
3393         assert_return(bus, -EINVAL);
3394         assert_return(!bus_pid_changed(bus), -ECHILD);
3395
3396         if (!bus->is_kernel)
3397                 return -EOPNOTSUPP;
3398
3399         if (!BUS_IS_OPEN(bus->state))
3400                 return -ENOTCONN;
3401
3402         if (bus->rqueue_size > 0)
3403                 return -EBUSY;
3404
3405         if (bus->wqueue_size > 0)
3406                 return -EBUSY;
3407
3408         r = bus_kernel_try_close(bus);
3409         if (r < 0)
3410                 return r;
3411
3412         sd_bus_close(bus);
3413         return 0;
3414 }
3415
3416 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3417         assert_return(bus, -EINVAL);
3418         assert_return(description, -EINVAL);
3419         assert_return(bus->description, -ENXIO);
3420         assert_return(!bus_pid_changed(bus), -ECHILD);
3421
3422         *description = bus->description;
3423         return 0;
3424 }
3425
3426 int bus_get_root_path(sd_bus *bus) {
3427         int r;
3428
3429         if (bus->cgroup_root)
3430                 return 0;
3431
3432         r = cg_get_root_path(&bus->cgroup_root);
3433         if (r == -ENOENT) {
3434                 bus->cgroup_root = strdup("/");
3435                 if (!bus->cgroup_root)
3436                         return -ENOMEM;
3437
3438                 r = 0;
3439         }
3440
3441         return r;
3442 }
3443
3444 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3445         int r;
3446
3447         assert_return(bus, -EINVAL);
3448         assert_return(scope, -EINVAL);
3449         assert_return(!bus_pid_changed(bus), -ECHILD);
3450
3451         if (bus->is_kernel) {
3452                 _cleanup_free_ char *n = NULL;
3453                 const char *dash;
3454
3455                 r = bus_kernel_get_bus_name(bus, &n);
3456                 if (r < 0)
3457                         return r;
3458
3459                 if (streq(n, "0-system")) {
3460                         *scope = "system";
3461                         return 0;
3462                 }
3463
3464                 dash = strchr(n, '-');
3465                 if (streq_ptr(dash, "-user")) {
3466                         *scope = "user";
3467                         return 0;
3468                 }
3469         }
3470
3471         if (bus->is_user) {
3472                 *scope = "user";
3473                 return 0;
3474         }
3475
3476         if (bus->is_system) {
3477                 *scope = "system";
3478                 return 0;
3479         }
3480
3481         return -ENODATA;
3482 }
3483
3484 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3485
3486         assert_return(bus, -EINVAL);
3487         assert_return(address, -EINVAL);
3488         assert_return(!bus_pid_changed(bus), -ECHILD);
3489
3490         if (bus->address) {
3491                 *address = bus->address;
3492                 return 0;
3493         }
3494
3495         return -ENODATA;
3496 }
3497
3498 int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3499         assert_return(bus, -EINVAL);
3500         assert_return(mask, -EINVAL);
3501         assert_return(!bus_pid_changed(bus), -ECHILD);
3502
3503         *mask = bus->creds_mask;
3504         return 0;
3505 }
3506
3507 int sd_bus_is_bus_client(sd_bus *bus) {
3508         assert_return(bus, -EINVAL);
3509         assert_return(!bus_pid_changed(bus), -ECHILD);
3510
3511         return bus->bus_client;
3512 }
3513
3514 int sd_bus_is_server(sd_bus *bus) {
3515         assert_return(bus, -EINVAL);
3516         assert_return(!bus_pid_changed(bus), -ECHILD);
3517
3518         return bus->is_server;
3519 }
3520
3521 int sd_bus_is_anonymous(sd_bus *bus) {
3522         assert_return(bus, -EINVAL);
3523         assert_return(!bus_pid_changed(bus), -ECHILD);
3524
3525         return bus->anonymous_auth;
3526 }
3527
3528 int sd_bus_is_trusted(sd_bus *bus) {
3529         assert_return(bus, -EINVAL);
3530         assert_return(!bus_pid_changed(bus), -ECHILD);
3531
3532         return bus->trusted;
3533 }
3534
3535 int sd_bus_is_monitor(sd_bus *bus) {
3536         assert_return(bus, -EINVAL);
3537         assert_return(!bus_pid_changed(bus), -ECHILD);
3538
3539         return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3540 }