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