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