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

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