src/libsystemd-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
  38 #include "sd-bus.h"
  39 #include "bus-internal.h"
  40 #include "bus-message.h"
  41 #include "bus-type.h"
  42 #include "bus-socket.h"
  43 #include "bus-kernel.h"
  44 #include "bus-control.h"
  45 #include "bus-introspect.h"
  46 #include "bus-signature.h"
  47 #include "bus-objects.h"
  48 #include "bus-util.h"
  49 #include "bus-container.h"
  50
  51 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
  52
  53 static void bus_close_fds(sd_bus *b) {
  54         assert(b);
  55
  56         if (b->input_fd >= 0)
  57                 close_nointr_nofail(b->input_fd);
  58
  59         if (b->output_fd >= 0 && b->output_fd != b->input_fd)
  60                 close_nointr_nofail(b->output_fd);
  61
  62         b->input_fd = b->output_fd = -1;
  63 }
  64
  65 static void bus_node_destroy(sd_bus *b, struct node *n) {
  66         struct node_callback *c;
  67         struct node_vtable *v;
  68         struct node_enumerator *e;
  69
  70         assert(b);
  71
  72         if (!n)
  73                 return;
  74
  75         while (n->child)
  76                 bus_node_destroy(b, n->child);
  77
  78         while ((c = n->callbacks)) {
  79                 LIST_REMOVE(callbacks, n->callbacks, c);
  80                 free(c);
  81         }
  82
  83         while ((v = n->vtables)) {
  84                 LIST_REMOVE(vtables, n->vtables, v);
  85                 free(v->interface);
  86                 free(v);
  87         }
  88
  89         while ((e = n->enumerators)) {
  90                 LIST_REMOVE(enumerators, n->enumerators, e);
  91                 free(e);
  92         }
  93
  94         if (n->parent)
  95                 LIST_REMOVE(siblings, n->parent->child, n);
  96
  97         assert_se(hashmap_remove(b->nodes, n->path) == n);
  98         free(n->path);
  99         free(n);
 100 }
 101
 102 static void bus_reset_queues(sd_bus *b) {
 103         unsigned i;
 104
 105         assert(b);
 106
 107         for (i = 0; i < b->rqueue_size; i++)
 108                 sd_bus_message_unref(b->rqueue[i]);
 109         free(b->rqueue);
 110
 111         for (i = 0; i < b->wqueue_size; i++)
 112                 sd_bus_message_unref(b->wqueue[i]);
 113         free(b->wqueue);
 114
 115         b->rqueue = b->wqueue = NULL;
 116         b->rqueue_size = b->wqueue_size = 0;
 117 }
 118
 119 static void bus_free(sd_bus *b) {
 120         struct filter_callback *f;
 121         struct node *n;
 122
 123         assert(b);
 124
 125         sd_bus_detach_event(b);
 126
 127         bus_close_fds(b);
 128
 129         if (b->kdbus_buffer)
 130                 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
 131
 132         free(b->rbuffer);
 133         free(b->unique_name);
 134         free(b->auth_buffer);
 135         free(b->address);
 136         free(b->kernel);
 137         free(b->machine);
 138
 139         free(b->exec_path);
 140         strv_free(b->exec_argv);
 141
 142         close_many(b->fds, b->n_fds);
 143         free(b->fds);
 144
 145         bus_reset_queues(b);
 146
 147         hashmap_free_free(b->reply_callbacks);
 148         prioq_free(b->reply_callbacks_prioq);
 149
 150         while ((f = b->filter_callbacks)) {
 151                 LIST_REMOVE(callbacks, b->filter_callbacks, f);
 152                 free(f);
 153         }
 154
 155         bus_match_free(&b->match_callbacks);
 156
 157         hashmap_free_free(b->vtable_methods);
 158         hashmap_free_free(b->vtable_properties);
 159
 160         while ((n = hashmap_first(b->nodes)))
 161                 bus_node_destroy(b, n);
 162
 163         hashmap_free(b->nodes);
 164
 165         bus_kernel_flush_memfd(b);
 166
 167         assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
 168
 169         free(b);
 170 }
 171
 172 _public_ int sd_bus_new(sd_bus **ret) {
 173         sd_bus *r;
 174
 175         assert_return(ret, -EINVAL);
 176
 177         r = new0(sd_bus, 1);
 178         if (!r)
 179                 return -ENOMEM;
 180
 181         r->n_ref = REFCNT_INIT;
 182         r->input_fd = r->output_fd = -1;
 183         r->message_version = 1;
 184         r->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
 185         r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
 186         r->attach_flags |= KDBUS_ATTACH_NAMES;
 187         r->original_pid = getpid();
 188
 189         assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
 190
 191         /* We guarantee that wqueue always has space for at least one
 192          * entry */
 193         r->wqueue = new(sd_bus_message*, 1);
 194         if (!r->wqueue) {
 195                 free(r);
 196                 return -ENOMEM;
 197         }
 198
 199         *ret = r;
 200         return 0;
 201 }
 202
 203 _public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
 204         char *a;
 205
 206         assert_return(bus, -EINVAL);
 207         assert_return(bus->state == BUS_UNSET, -EPERM);
 208         assert_return(address, -EINVAL);
 209         assert_return(!bus_pid_changed(bus), -ECHILD);
 210
 211         a = strdup(address);
 212         if (!a)
 213                 return -ENOMEM;
 214
 215         free(bus->address);
 216         bus->address = a;
 217
 218         return 0;
 219 }
 220
 221 _public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
 222         assert_return(bus, -EINVAL);
 223         assert_return(bus->state == BUS_UNSET, -EPERM);
 224         assert_return(input_fd >= 0, -EINVAL);
 225         assert_return(output_fd >= 0, -EINVAL);
 226         assert_return(!bus_pid_changed(bus), -ECHILD);
 227
 228         bus->input_fd = input_fd;
 229         bus->output_fd = output_fd;
 230         return 0;
 231 }
 232
 233 _public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
 234         char *p, **a;
 235
 236         assert_return(bus, -EINVAL);
 237         assert_return(bus->state == BUS_UNSET, -EPERM);
 238         assert_return(path, -EINVAL);
 239         assert_return(!strv_isempty(argv), -EINVAL);
 240         assert_return(!bus_pid_changed(bus), -ECHILD);
 241
 242         p = strdup(path);
 243         if (!p)
 244                 return -ENOMEM;
 245
 246         a = strv_copy(argv);
 247         if (!a) {
 248                 free(p);
 249                 return -ENOMEM;
 250         }
 251
 252         free(bus->exec_path);
 253         strv_free(bus->exec_argv);
 254
 255         bus->exec_path = p;
 256         bus->exec_argv = a;
 257
 258         return 0;
 259 }
 260
 261 _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
 262         assert_return(bus, -EINVAL);
 263         assert_return(bus->state == BUS_UNSET, -EPERM);
 264         assert_return(!bus_pid_changed(bus), -ECHILD);
 265
 266         bus->bus_client = !!b;
 267         return 0;
 268 }
 269
 270 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
 271         assert_return(bus, -EINVAL);
 272         assert_return(bus->state == BUS_UNSET, -EPERM);
 273         assert_return(!bus_pid_changed(bus), -ECHILD);
 274
 275         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
 276         return 0;
 277 }
 278
 279 _public_ int sd_bus_negotiate_attach_timestamp(sd_bus *bus, int b) {
 280         assert_return(bus, -EINVAL);
 281         assert_return(bus->state == BUS_UNSET, -EPERM);
 282         assert_return(!bus_pid_changed(bus), -ECHILD);
 283
 284         SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b);
 285         return 0;
 286 }
 287
 288 _public_ int sd_bus_negotiate_attach_creds(sd_bus *bus, uint64_t mask) {
 289         assert_return(bus, -EINVAL);
 290         assert_return(mask <= _SD_BUS_CREDS_MAX, -EINVAL);
 291         assert_return(bus->state == BUS_UNSET, -EPERM);
 292         assert_return(!bus_pid_changed(bus), -ECHILD);
 293
 294         /* The well knowns we need unconditionally, so that matches can work */
 295         bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME;
 296
 297         return kdbus_translate_attach_flags(bus->creds_mask, &bus->creds_mask);
 298 }
 299
 300 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
 301         assert_return(bus, -EINVAL);
 302         assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
 303         assert_return(bus->state == BUS_UNSET, -EPERM);
 304         assert_return(!bus_pid_changed(bus), -ECHILD);
 305
 306         bus->is_server = !!b;
 307         bus->server_id = server_id;
 308         return 0;
 309 }
 310
 311 _public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
 312         assert_return(bus, -EINVAL);
 313         assert_return(bus->state == BUS_UNSET, -EPERM);
 314         assert_return(!bus_pid_changed(bus), -ECHILD);
 315
 316         bus->anonymous_auth = !!b;
 317         return 0;
 318 }
 319
 320 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {
 321         const char *s;
 322         int r;
 323
 324         assert(bus);
 325         assert(bus->state == BUS_HELLO || bus->state == BUS_CLOSING);
 326         assert(reply);
 327
 328         r = sd_bus_message_get_errno(reply);
 329         if (r < 0)
 330                 return r;
 331         if (r > 0)
 332                 return -r;
 333
 334         r = sd_bus_message_read(reply, "s", &s);
 335         if (r < 0)
 336                 return r;
 337
 338         if (!service_name_is_valid(s) || s[0] != ':')
 339                 return -EBADMSG;
 340
 341         bus->unique_name = strdup(s);
 342         if (!bus->unique_name)
 343                 return -ENOMEM;
 344
 345         if (bus->state == BUS_HELLO)
 346                 bus->state = BUS_RUNNING;
 347
 348         return 1;
 349 }
 350
 351 static int bus_send_hello(sd_bus *bus) {
 352         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 353         int r;
 354
 355         assert(bus);
 356
 357         if (!bus->bus_client || bus->is_kernel)
 358                 return 0;
 359
 360         r = sd_bus_message_new_method_call(
 361                         bus,
 362                         "org.freedesktop.DBus",
 363                         "/",
 364                         "org.freedesktop.DBus",
 365                         "Hello",
 366                         &m);
 367         if (r < 0)
 368                 return r;
 369
 370         return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
 371 }
 372
 373 int bus_start_running(sd_bus *bus) {
 374         assert(bus);
 375
 376         if (bus->bus_client && !bus->is_kernel) {
 377                 bus->state = BUS_HELLO;
 378                 return 1;
 379         }
 380
 381         bus->state = BUS_RUNNING;
 382         return 1;
 383 }
 384
 385 static int parse_address_key(const char **p, const char *key, char **value) {
 386         size_t l, n = 0;
 387         const char *a;
 388         char *r = NULL;
 389
 390         assert(p);
 391         assert(*p);
 392         assert(value);
 393
 394         if (key) {
 395                 l = strlen(key);
 396                 if (strncmp(*p, key, l) != 0)
 397                         return 0;
 398
 399                 if ((*p)[l] != '=')
 400                         return 0;
 401
 402                 if (*value)
 403                         return -EINVAL;
 404
 405                 a = *p + l + 1;
 406         } else
 407                 a = *p;
 408
 409         while (*a != ';' && *a != ',' && *a != 0) {
 410                 char c, *t;
 411
 412                 if (*a == '%') {
 413                         int x, y;
 414
 415                         x = unhexchar(a[1]);
 416                         if (x < 0) {
 417                                 free(r);
 418                                 return x;
 419                         }
 420
 421                         y = unhexchar(a[2]);
 422                         if (y < 0) {
 423                                 free(r);
 424                                 return y;
 425                         }
 426
 427                         c = (char) ((x << 4) | y);
 428                         a += 3;
 429                 } else {
 430                         c = *a;
 431                         a++;
 432                 }
 433
 434                 t = realloc(r, n + 2);
 435                 if (!t) {
 436                         free(r);
 437                         return -ENOMEM;
 438                 }
 439
 440                 r = t;
 441                 r[n++] = c;
 442         }
 443
 444         if (!r) {
 445                 r = strdup("");
 446                 if (!r)
 447                         return -ENOMEM;
 448         } else
 449                 r[n] = 0;
 450
 451         if (*a == ',')
 452                 a++;
 453
 454         *p = a;
 455
 456         free(*value);
 457         *value = r;
 458
 459         return 1;
 460 }
 461
 462 static void skip_address_key(const char **p) {
 463         assert(p);
 464         assert(*p);
 465
 466         *p += strcspn(*p, ",");
 467
 468         if (**p == ',')
 469                 (*p) ++;
 470 }
 471
 472 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
 473         _cleanup_free_ char *path = NULL, *abstract = NULL;
 474         size_t l;
 475         int r;
 476
 477         assert(b);
 478         assert(p);
 479         assert(*p);
 480         assert(guid);
 481
 482         while (**p != 0 && **p != ';') {
 483                 r = parse_address_key(p, "guid", guid);
 484                 if (r < 0)
 485                         return r;
 486                 else if (r > 0)
 487                         continue;
 488
 489                 r = parse_address_key(p, "path", &path);
 490                 if (r < 0)
 491                         return r;
 492                 else if (r > 0)
 493                         continue;
 494
 495                 r = parse_address_key(p, "abstract", &abstract);
 496                 if (r < 0)
 497                         return r;
 498                 else if (r > 0)
 499                         continue;
 500
 501                 skip_address_key(p);
 502         }
 503
 504         if (!path && !abstract)
 505                 return -EINVAL;
 506
 507         if (path && abstract)
 508                 return -EINVAL;
 509
 510         if (path) {
 511                 l = strlen(path);
 512                 if (l > sizeof(b->sockaddr.un.sun_path))
 513                         return -E2BIG;
 514
 515                 b->sockaddr.un.sun_family = AF_UNIX;
 516                 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
 517                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
 518         } else if (abstract) {
 519                 l = strlen(abstract);
 520                 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
 521                         return -E2BIG;
 522
 523                 b->sockaddr.un.sun_family = AF_UNIX;
 524                 b->sockaddr.un.sun_path[0] = 0;
 525                 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
 526                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
 527         }
 528
 529         return 0;
 530 }
 531
 532 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
 533         _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
 534         int r;
 535         struct addrinfo *result, hints = {
 536                 .ai_socktype = SOCK_STREAM,
 537                 .ai_flags = AI_ADDRCONFIG,
 538         };
 539
 540         assert(b);
 541         assert(p);
 542         assert(*p);
 543         assert(guid);
 544
 545         while (**p != 0 && **p != ';') {
 546                 r = parse_address_key(p, "guid", guid);
 547                 if (r < 0)
 548                         return r;
 549                 else if (r > 0)
 550                         continue;
 551
 552                 r = parse_address_key(p, "host", &host);
 553                 if (r < 0)
 554                         return r;
 555                 else if (r > 0)
 556                         continue;
 557
 558                 r = parse_address_key(p, "port", &port);
 559                 if (r < 0)
 560                         return r;
 561                 else if (r > 0)
 562                         continue;
 563
 564                 r = parse_address_key(p, "family", &family);
 565                 if (r < 0)
 566                         return r;
 567                 else if (r > 0)
 568                         continue;
 569
 570                 skip_address_key(p);
 571         }
 572
 573         if (!host || !port)
 574                 return -EINVAL;
 575
 576         if (family) {
 577                 if (streq(family, "ipv4"))
 578                         hints.ai_family = AF_INET;
 579                 else if (streq(family, "ipv6"))
 580                         hints.ai_family = AF_INET6;
 581                 else
 582                         return -EINVAL;
 583         }
 584
 585         r = getaddrinfo(host, port, &hints, &result);
 586         if (r == EAI_SYSTEM)
 587                 return -errno;
 588         else if (r != 0)
 589                 return -EADDRNOTAVAIL;
 590
 591         memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
 592         b->sockaddr_size = result->ai_addrlen;
 593
 594         freeaddrinfo(result);
 595
 596         return 0;
 597 }
 598
 599 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
 600         char *path = NULL;
 601         unsigned n_argv = 0, j;
 602         char **argv = NULL;
 603         int r;
 604
 605         assert(b);
 606         assert(p);
 607         assert(*p);
 608         assert(guid);
 609
 610         while (**p != 0 && **p != ';') {
 611                 r = parse_address_key(p, "guid", guid);
 612                 if (r < 0)
 613                         goto fail;
 614                 else if (r > 0)
 615                         continue;
 616
 617                 r = parse_address_key(p, "path", &path);
 618                 if (r < 0)
 619                         goto fail;
 620                 else if (r > 0)
 621                         continue;
 622
 623                 if (startswith(*p, "argv")) {
 624                         unsigned ul;
 625
 626                         errno = 0;
 627                         ul = strtoul(*p + 4, (char**) p, 10);
 628                         if (errno > 0 || **p != '=' || ul > 256) {
 629                                 r = -EINVAL;
 630                                 goto fail;
 631                         }
 632
 633                         (*p) ++;
 634
 635                         if (ul >= n_argv) {
 636                                 char **x;
 637
 638                                 x = realloc(argv, sizeof(char*) * (ul + 2));
 639                                 if (!x) {
 640                                         r = -ENOMEM;
 641                                         goto fail;
 642                                 }
 643
 644                                 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
 645
 646                                 argv = x;
 647                                 n_argv = ul + 1;
 648                         }
 649
 650                         r = parse_address_key(p, NULL, argv + ul);
 651                         if (r < 0)
 652                                 goto fail;
 653
 654                         continue;
 655                 }
 656
 657                 skip_address_key(p);
 658         }
 659
 660         if (!path) {
 661                 r = -EINVAL;
 662                 goto fail;
 663         }
 664
 665         /* Make sure there are no holes in the array, with the
 666          * exception of argv[0] */
 667         for (j = 1; j < n_argv; j++)
 668                 if (!argv[j]) {
 669                         r = -EINVAL;
 670                         goto fail;
 671                 }
 672
 673         if (argv && argv[0] == NULL) {
 674                 argv[0] = strdup(path);
 675                 if (!argv[0]) {
 676                         r = -ENOMEM;
 677                         goto fail;
 678                 }
 679         }
 680
 681         b->exec_path = path;
 682         b->exec_argv = argv;
 683         return 0;
 684
 685 fail:
 686         for (j = 0; j < n_argv; j++)
 687                 free(argv[j]);
 688
 689         free(argv);
 690         free(path);
 691         return r;
 692 }
 693
 694 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
 695         _cleanup_free_ char *path = NULL;
 696         int r;
 697
 698         assert(b);
 699         assert(p);
 700         assert(*p);
 701         assert(guid);
 702
 703         while (**p != 0 && **p != ';') {
 704                 r = parse_address_key(p, "guid", guid);
 705                 if (r < 0)
 706                         return r;
 707                 else if (r > 0)
 708                         continue;
 709
 710                 r = parse_address_key(p, "path", &path);
 711                 if (r < 0)
 712                         return r;
 713                 else if (r > 0)
 714                         continue;
 715
 716                 skip_address_key(p);
 717         }
 718
 719         if (!path)
 720                 return -EINVAL;
 721
 722         free(b->kernel);
 723         b->kernel = path;
 724         path = NULL;
 725
 726         return 0;
 727 }
 728
 729 static int parse_container_address(sd_bus *b, const char **p, char **guid) {
 730         _cleanup_free_ char *machine = NULL;
 731         int r;
 732
 733         assert(b);
 734         assert(p);
 735         assert(*p);
 736         assert(guid);
 737
 738         while (**p != 0 && **p != ';') {
 739                 r = parse_address_key(p, "guid", guid);
 740                 if (r < 0)
 741                         return r;
 742                 else if (r > 0)
 743                         continue;
 744
 745                 r = parse_address_key(p, "machine", &machine);
 746                 if (r < 0)
 747                         return r;
 748                 else if (r > 0)
 749                         continue;
 750
 751                 skip_address_key(p);
 752         }
 753
 754         if (!machine)
 755                 return -EINVAL;
 756
 757         free(b->machine);
 758         b->machine = machine;
 759         machine = NULL;
 760
 761         b->sockaddr.un.sun_family = AF_UNIX;
 762         strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
 763         b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
 764
 765         return 0;
 766 }
 767
 768 static void bus_reset_parsed_address(sd_bus *b) {
 769         assert(b);
 770
 771         zero(b->sockaddr);
 772         b->sockaddr_size = 0;
 773         strv_free(b->exec_argv);
 774         free(b->exec_path);
 775         b->exec_path = NULL;
 776         b->exec_argv = NULL;
 777         b->server_id = SD_ID128_NULL;
 778         free(b->kernel);
 779         b->kernel = NULL;
 780         free(b->machine);
 781         b->machine = NULL;
 782 }
 783
 784 static int bus_parse_next_address(sd_bus *b) {
 785         _cleanup_free_ char *guid = NULL;
 786         const char *a;
 787         int r;
 788
 789         assert(b);
 790
 791         if (!b->address)
 792                 return 0;
 793         if (b->address[b->address_index] == 0)
 794                 return 0;
 795
 796         bus_reset_parsed_address(b);
 797
 798         a = b->address + b->address_index;
 799
 800         while (*a != 0) {
 801
 802                 if (*a == ';') {
 803                         a++;
 804                         continue;
 805                 }
 806
 807                 if (startswith(a, "unix:")) {
 808                         a += 5;
 809
 810                         r = parse_unix_address(b, &a, &guid);
 811                         if (r < 0)
 812                                 return r;
 813                         break;
 814
 815                 } else if (startswith(a, "tcp:")) {
 816
 817                         a += 4;
 818                         r = parse_tcp_address(b, &a, &guid);
 819                         if (r < 0)
 820                                 return r;
 821
 822                         break;
 823
 824                 } else if (startswith(a, "unixexec:")) {
 825
 826                         a += 9;
 827                         r = parse_exec_address(b, &a, &guid);
 828                         if (r < 0)
 829                                 return r;
 830
 831                         break;
 832
 833                 } else if (startswith(a, "kernel:")) {
 834
 835                         a += 7;
 836                         r = parse_kernel_address(b, &a, &guid);
 837                         if (r < 0)
 838                                 return r;
 839
 840                         break;
 841                 } else if (startswith(a, "x-container:")) {
 842
 843                         a += 12;
 844                         r = parse_container_address(b, &a, &guid);
 845                         if (r < 0)
 846                                 return r;
 847
 848                         break;
 849                 }
 850
 851                 a = strchr(a, ';');
 852                 if (!a)
 853                         return 0;
 854         }
 855
 856         if (guid) {
 857                 r = sd_id128_from_string(guid, &b->server_id);
 858                 if (r < 0)
 859                         return r;
 860         }
 861
 862         b->address_index = a - b->address;
 863         return 1;
 864 }
 865
 866 static int bus_start_address(sd_bus *b) {
 867         int r;
 868
 869         assert(b);
 870
 871         for (;;) {
 872                 sd_bus_close(b);
 873
 874                 if (b->exec_path) {
 875
 876                         r = bus_socket_exec(b);
 877                         if (r >= 0)
 878                                 return r;
 879
 880                         b->last_connect_error = -r;
 881                 } else if (b->kernel) {
 882
 883                         r = bus_kernel_connect(b);
 884                         if (r >= 0)
 885                                 return r;
 886
 887                         b->last_connect_error = -r;
 888
 889                 } else if (b->machine) {
 890
 891                         r = bus_container_connect(b);
 892                         if (r >= 0)
 893                                 return r;
 894
 895                         b->last_connect_error = -r;
 896
 897                 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
 898
 899                         r = bus_socket_connect(b);
 900                         if (r >= 0)
 901                                 return r;
 902
 903                         b->last_connect_error = -r;
 904                 }
 905
 906                 r = bus_parse_next_address(b);
 907                 if (r < 0)
 908                         return r;
 909                 if (r == 0)
 910                         return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
 911         }
 912 }
 913
 914 int bus_next_address(sd_bus *b) {
 915         assert(b);
 916
 917         bus_reset_parsed_address(b);
 918         return bus_start_address(b);
 919 }
 920
 921 static int bus_start_fd(sd_bus *b) {
 922         struct stat st;
 923         int r;
 924
 925         assert(b);
 926         assert(b->input_fd >= 0);
 927         assert(b->output_fd >= 0);
 928
 929         r = fd_nonblock(b->input_fd, true);
 930         if (r < 0)
 931                 return r;
 932
 933         r = fd_cloexec(b->input_fd, true);
 934         if (r < 0)
 935                 return r;
 936
 937         if (b->input_fd != b->output_fd) {
 938                 r = fd_nonblock(b->output_fd, true);
 939                 if (r < 0)
 940                         return r;
 941
 942                 r = fd_cloexec(b->output_fd, true);
 943                 if (r < 0)
 944                         return r;
 945         }
 946
 947         if (fstat(b->input_fd, &st) < 0)
 948                 return -errno;
 949
 950         if (S_ISCHR(b->input_fd))
 951                 return bus_kernel_take_fd(b);
 952         else
 953                 return bus_socket_take_fd(b);
 954 }
 955
 956 _public_ int sd_bus_start(sd_bus *bus) {
 957         int r;
 958
 959         assert_return(bus, -EINVAL);
 960         assert_return(bus->state == BUS_UNSET, -EPERM);
 961         assert_return(!bus_pid_changed(bus), -ECHILD);
 962
 963         bus->state = BUS_OPENING;
 964
 965         if (bus->is_server && bus->bus_client)
 966                 return -EINVAL;
 967
 968         if (bus->input_fd >= 0)
 969                 r = bus_start_fd(bus);
 970         else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
 971                 r = bus_start_address(bus);
 972         else
 973                 return -EINVAL;
 974
 975         if (r < 0)
 976                 return r;
 977
 978         return bus_send_hello(bus);
 979 }
 980
 981 _public_ int sd_bus_open_system(sd_bus **ret) {
 982         const char *e;
 983         sd_bus *b;
 984         int r;
 985
 986         assert_return(ret, -EINVAL);
 987
 988         r = sd_bus_new(&b);
 989         if (r < 0)
 990                 return r;
 991
 992         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
 993         if (e)
 994                 r = sd_bus_set_address(b, e);
 995         else
 996                 r = sd_bus_set_address(b, "kernel:path=/dev/kdbus/0-system/bus;unix:path=/run/dbus/system_bus_socket");
 997
 998         if (r < 0)
 999                 goto fail;
1000
1001         b->bus_client = true;
1002
1003         r = sd_bus_start(b);
1004         if (r < 0)
1005                 goto fail;
1006
1007         *ret = b;
1008         return 0;
1009
1010 fail:
1011         bus_free(b);
1012         return r;
1013 }
1014
1015 _public_ int sd_bus_open_user(sd_bus **ret) {
1016         const char *e;
1017         sd_bus *b;
1018         int r;
1019
1020         assert_return(ret, -EINVAL);
1021
1022         r = sd_bus_new(&b);
1023         if (r < 0)
1024                 return r;
1025
1026         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1027         if (e) {
1028                 r = sd_bus_set_address(b, e);
1029                 if (r < 0)
1030                         goto fail;
1031         } else {
1032                 e = secure_getenv("XDG_RUNTIME_DIR");
1033                 if (e) {
1034                         _cleanup_free_ char *ee = NULL;
1035
1036                         ee = bus_address_escape(e);
1037                         if (!ee) {
1038                                 r = -ENOENT;
1039                                 goto fail;
1040                         }
1041
1042                         asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus;unix:path=%s/bus", (unsigned long) getuid(), ee);
1043                 } else
1044                         asprintf(&b->address, "kernel:path=/dev/kdbus/%lu-user/bus", (unsigned long) getuid());
1045
1046                 if (!b->address) {
1047                         r = -ENOMEM;
1048                         goto fail;
1049                 }
1050         }
1051
1052         b->bus_client = true;
1053
1054         r = sd_bus_start(b);
1055         if (r < 0)
1056                 goto fail;
1057
1058         *ret = b;
1059         return 0;
1060
1061 fail:
1062         bus_free(b);
1063         return r;
1064 }
1065
1066 _public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) {
1067         _cleanup_free_ char *e = NULL;
1068         char *p = NULL;
1069         sd_bus *bus;
1070         int r;
1071
1072         assert_return(host, -EINVAL);
1073         assert_return(ret, -EINVAL);
1074
1075         e = bus_address_escape(host);
1076         if (!e)
1077                 return -ENOMEM;
1078
1079         p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
1080         if (!p)
1081                 return -ENOMEM;
1082
1083         r = sd_bus_new(&bus);
1084         if (r < 0) {
1085                 free(p);
1086                 return r;
1087         }
1088
1089         bus->address = p;
1090         bus->bus_client = true;
1091
1092         r = sd_bus_start(bus);
1093         if (r < 0) {
1094                 bus_free(bus);
1095                 return r;
1096         }
1097
1098         *ret = bus;
1099         return 0;
1100 }
1101
1102 _public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) {
1103         _cleanup_free_ char *e = NULL;
1104         sd_bus *bus;
1105         char *p;
1106         int r;
1107
1108         assert_return(machine, -EINVAL);
1109         assert_return(ret, -EINVAL);
1110
1111         e = bus_address_escape(machine);
1112         if (!e)
1113                 return -ENOMEM;
1114
1115         p = strjoin("x-container:machine=", e, NULL);
1116         if (!p)
1117                 return -ENOMEM;
1118
1119         r = sd_bus_new(&bus);
1120         if (r < 0) {
1121                 free(p);
1122                 return r;
1123         }
1124
1125         bus->address = p;
1126         bus->bus_client = true;
1127
1128         r = sd_bus_start(bus);
1129         if (r < 0) {
1130                 bus_free(bus);
1131                 return r;
1132         }
1133
1134         *ret = bus;
1135         return 0;
1136 }
1137
1138 _public_ void sd_bus_close(sd_bus *bus) {
1139
1140         if (!bus)
1141                 return;
1142         if (bus->state == BUS_CLOSED)
1143                 return;
1144         if (bus_pid_changed(bus))
1145                 return;
1146
1147         bus->state = BUS_CLOSED;
1148
1149         sd_bus_detach_event(bus);
1150
1151         /* Drop all queued messages so that they drop references to
1152          * the bus object and the bus may be freed */
1153         bus_reset_queues(bus);
1154
1155         if (!bus->is_kernel)
1156                 bus_close_fds(bus);
1157
1158         /* We'll leave the fd open in case this is a kernel bus, since
1159          * there might still be memblocks around that reference this
1160          * bus, and they might need to invoke the * KDBUS_CMD_FREE
1161          * ioctl on the fd when they are freed. */
1162 }
1163
1164 static void bus_enter_closing(sd_bus *bus) {
1165         assert(bus);
1166
1167         if (bus->state != BUS_OPENING &&
1168             bus->state != BUS_AUTHENTICATING &&
1169             bus->state != BUS_HELLO &&
1170             bus->state != BUS_RUNNING)
1171                 return;
1172
1173         bus->state = BUS_CLOSING;
1174 }
1175
1176 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1177         assert_return(bus, NULL);
1178
1179         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1180
1181         return bus;
1182 }
1183
1184 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1185         assert_return(bus, NULL);
1186
1187         if (REFCNT_DEC(bus->n_ref) <= 0)
1188                 bus_free(bus);
1189
1190         return NULL;
1191 }
1192
1193 _public_ int sd_bus_is_open(sd_bus *bus) {
1194
1195         assert_return(bus, -EINVAL);
1196         assert_return(!bus_pid_changed(bus), -ECHILD);
1197
1198         return BUS_IS_OPEN(bus->state);
1199 }
1200
1201 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1202         int r;
1203
1204         assert_return(bus, -EINVAL);
1205         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1206         assert_return(!bus_pid_changed(bus), -ECHILD);
1207
1208         if (type == SD_BUS_TYPE_UNIX_FD) {
1209                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1210                         return 0;
1211
1212                 r = bus_ensure_running(bus);
1213                 if (r < 0)
1214                         return r;
1215
1216                 return bus->can_fds;
1217         }
1218
1219         return bus_type_is_valid(type);
1220 }
1221
1222 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1223         int r;
1224
1225         assert_return(bus, -EINVAL);
1226         assert_return(server_id, -EINVAL);
1227         assert_return(!bus_pid_changed(bus), -ECHILD);
1228
1229         r = bus_ensure_running(bus);
1230         if (r < 0)
1231                 return r;
1232
1233         *server_id = bus->server_id;
1234         return 0;
1235 }
1236
1237 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1238         assert(b);
1239         assert(m);
1240
1241         if (m->header->version > b->message_version)
1242                 return -EPERM;
1243
1244         if (m->sealed) {
1245                 /* If we copy the same message to multiple
1246                  * destinations, avoid using the same serial
1247                  * numbers. */
1248                 b->serial = MAX(b->serial, BUS_MESSAGE_SERIAL(m));
1249                 return 0;
1250         }
1251
1252         return bus_message_seal(m, ++b->serial);
1253 }
1254
1255 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1256         assert(b);
1257         assert(m);
1258
1259         if (m->header->version > b->message_version)
1260                 return -EPERM;
1261
1262         /* The bus specification says the serial number cannot be 0,
1263          * hence let's fill something in for synthetic messages. Since
1264          * synthetic messages might have a fake sender and we don't
1265          * want to interfere with the real sender's serial numbers we
1266          * pick a fixed, artifical one. We use (uint32_t) -1 rather
1267          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1268          * even though kdbus can do 64bit. */
1269
1270         return bus_message_seal(m, 0xFFFFFFFFULL);
1271 }
1272
1273 static int bus_write_message(sd_bus *bus, sd_bus_message *message, size_t *idx) {
1274         int r;
1275
1276         assert(bus);
1277         assert(message);
1278
1279         if (bus->is_kernel)
1280                 return bus_kernel_write_message(bus, message);
1281         else
1282                 return bus_socket_write_message(bus, message, idx);
1283
1284         return r;
1285 }
1286
1287 static int dispatch_wqueue(sd_bus *bus) {
1288         int r, ret = 0;
1289
1290         assert(bus);
1291         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1292
1293         while (bus->wqueue_size > 0) {
1294
1295                 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1296                 if (r < 0)
1297                         return r;
1298                 else if (r == 0)
1299                         /* Didn't do anything this time */
1300                         return ret;
1301                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1302                         /* Fully written. Let's drop the entry from
1303                          * the queue.
1304                          *
1305                          * This isn't particularly optimized, but
1306                          * well, this is supposed to be our worst-case
1307                          * buffer only, and the socket buffer is
1308                          * supposed to be our primary buffer, and if
1309                          * it got full, then all bets are off
1310                          * anyway. */
1311
1312                         sd_bus_message_unref(bus->wqueue[0]);
1313                         bus->wqueue_size --;
1314                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1315                         bus->windex = 0;
1316
1317                         ret = 1;
1318                 }
1319         }
1320
1321         return ret;
1322 }
1323
1324 static int bus_read_message(sd_bus *bus) {
1325         assert(bus);
1326
1327         if (bus->is_kernel)
1328                 return bus_kernel_read_message(bus);
1329         else
1330                 return bus_socket_read_message(bus);
1331 }
1332
1333 int bus_rqueue_make_room(sd_bus *bus) {
1334         sd_bus_message **q;
1335         unsigned x;
1336
1337         x = bus->rqueue_size + 1;
1338
1339         if (bus->rqueue_allocated >= x)
1340                 return 0;
1341
1342         if (x > BUS_RQUEUE_MAX)
1343                 return -ENOBUFS;
1344
1345         q = realloc(bus->rqueue, x * sizeof(sd_bus_message*));
1346         if (!q)
1347                 return -ENOMEM;
1348
1349         bus->rqueue = q;
1350         bus->rqueue_allocated = x;
1351
1352         return 0;
1353 }
1354
1355 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1356         int r, ret = 0;
1357
1358         assert(bus);
1359         assert(m);
1360         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1361
1362         for (;;) {
1363                 if (bus->rqueue_size > 0) {
1364                         /* Dispatch a queued message */
1365
1366                         *m = bus->rqueue[0];
1367                         bus->rqueue_size --;
1368                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1369                         return 1;
1370                 }
1371
1372                 /* Try to read a new message */
1373                 r = bus_read_message(bus);
1374                 if (r < 0)
1375                         return r;
1376                 if (r == 0)
1377                         return ret;
1378
1379                 ret = 1;
1380         }
1381 }
1382
1383 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1384         int r;
1385
1386         assert_return(bus, -EINVAL);
1387         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1388         assert_return(m, -EINVAL);
1389         assert_return(!bus_pid_changed(bus), -ECHILD);
1390
1391         if (m->n_fds > 0) {
1392                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1393                 if (r < 0)
1394                         return r;
1395                 if (r == 0)
1396                         return -ENOTSUP;
1397         }
1398
1399         /* If the serial number isn't kept, then we know that no reply
1400          * is expected */
1401         if (!serial && !m->sealed)
1402                 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1403
1404         r = bus_seal_message(bus, m);
1405         if (r < 0)
1406                 return r;
1407
1408         /* If this is a reply and no reply was requested, then let's
1409          * suppress this, if we can */
1410         if (m->dont_send && !serial)
1411                 return 1;
1412
1413         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1414                 size_t idx = 0;
1415
1416                 r = bus_write_message(bus, m, &idx);
1417                 if (r < 0) {
1418                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1419                                 bus_enter_closing(bus);
1420
1421                         return r;
1422                 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1423                         /* Wasn't fully written. So let's remember how
1424                          * much was written. Note that the first entry
1425                          * of the wqueue array is always allocated so
1426                          * that we always can remember how much was
1427                          * written. */
1428                         bus->wqueue[0] = sd_bus_message_ref(m);
1429                         bus->wqueue_size = 1;
1430                         bus->windex = idx;
1431                 }
1432         } else {
1433                 sd_bus_message **q;
1434
1435                 /* Just append it to the queue. */
1436
1437                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1438                         return -ENOBUFS;
1439
1440                 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1441                 if (!q)
1442                         return -ENOMEM;
1443
1444                 bus->wqueue = q;
1445                 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1446         }
1447
1448         if (serial)
1449                 *serial = BUS_MESSAGE_SERIAL(m);
1450
1451         return 1;
1452 }
1453
1454 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *serial) {
1455         int r;
1456
1457         assert_return(bus, -EINVAL);
1458         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1459         assert_return(m, -EINVAL);
1460         assert_return(!bus_pid_changed(bus), -ECHILD);
1461
1462         if (!streq_ptr(m->destination, destination)) {
1463
1464                 if (!destination)
1465                         return -EEXIST;
1466
1467                 r = sd_bus_message_set_destination(m, destination);
1468                 if (r < 0)
1469                         return r;
1470         }
1471
1472         return sd_bus_send(bus, m, serial);
1473 }
1474
1475 static usec_t calc_elapse(uint64_t usec) {
1476         if (usec == (uint64_t) -1)
1477                 return 0;
1478
1479         if (usec == 0)
1480                 usec = BUS_DEFAULT_TIMEOUT;
1481
1482         return now(CLOCK_MONOTONIC) + usec;
1483 }
1484
1485 static int timeout_compare(const void *a, const void *b) {
1486         const struct reply_callback *x = a, *y = b;
1487
1488         if (x->timeout != 0 && y->timeout == 0)
1489                 return -1;
1490
1491         if (x->timeout == 0 && y->timeout != 0)
1492                 return 1;
1493
1494         if (x->timeout < y->timeout)
1495                 return -1;
1496
1497         if (x->timeout > y->timeout)
1498                 return 1;
1499
1500         return 0;
1501 }
1502
1503 _public_ int sd_bus_call_async(
1504                 sd_bus *bus,
1505                 sd_bus_message *m,
1506                 sd_bus_message_handler_t callback,
1507                 void *userdata,
1508                 uint64_t usec,
1509                 uint64_t *serial) {
1510
1511         struct reply_callback *c;
1512         int r;
1513
1514         assert_return(bus, -EINVAL);
1515         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1516         assert_return(m, -EINVAL);
1517         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1518         assert_return(!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1519         assert_return(callback, -EINVAL);
1520         assert_return(!bus_pid_changed(bus), -ECHILD);
1521
1522         r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1523         if (r < 0)
1524                 return r;
1525
1526         if (usec != (uint64_t) -1) {
1527                 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1528                 if (r < 0)
1529                         return r;
1530         }
1531
1532         r = bus_seal_message(bus, m);
1533         if (r < 0)
1534                 return r;
1535
1536         c = new0(struct reply_callback, 1);
1537         if (!c)
1538                 return -ENOMEM;
1539
1540         c->callback = callback;
1541         c->userdata = userdata;
1542         c->serial = BUS_MESSAGE_SERIAL(m);
1543         c->timeout = calc_elapse(usec);
1544
1545         r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1546         if (r < 0) {
1547                 free(c);
1548                 return r;
1549         }
1550
1551         if (c->timeout != 0) {
1552                 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1553                 if (r < 0) {
1554                         c->timeout = 0;
1555                         sd_bus_call_async_cancel(bus, c->serial);
1556                         return r;
1557                 }
1558         }
1559
1560         r = sd_bus_send(bus, m, serial);
1561         if (r < 0) {
1562                 sd_bus_call_async_cancel(bus, c->serial);
1563                 return r;
1564         }
1565
1566         return r;
1567 }
1568
1569 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t serial) {
1570         struct reply_callback *c;
1571
1572         assert_return(bus, -EINVAL);
1573         assert_return(serial != 0, -EINVAL);
1574         assert_return(!bus_pid_changed(bus), -ECHILD);
1575
1576         c = hashmap_remove(bus->reply_callbacks, &serial);
1577         if (!c)
1578                 return 0;
1579
1580         if (c->timeout != 0)
1581                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1582
1583         free(c);
1584         return 1;
1585 }
1586
1587 int bus_ensure_running(sd_bus *bus) {
1588         int r;
1589
1590         assert(bus);
1591
1592         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1593                 return -ENOTCONN;
1594         if (bus->state == BUS_RUNNING)
1595                 return 1;
1596
1597         for (;;) {
1598                 r = sd_bus_process(bus, NULL);
1599                 if (r < 0)
1600                         return r;
1601                 if (bus->state == BUS_RUNNING)
1602                         return 1;
1603                 if (r > 0)
1604                         continue;
1605
1606                 r = sd_bus_wait(bus, (uint64_t) -1);
1607                 if (r < 0)
1608                         return r;
1609         }
1610 }
1611
1612 _public_ int sd_bus_call(
1613                 sd_bus *bus,
1614                 sd_bus_message *m,
1615                 uint64_t usec,
1616                 sd_bus_error *error,
1617                 sd_bus_message **reply) {
1618
1619         usec_t timeout;
1620         uint64_t serial;
1621         unsigned i;
1622         int r;
1623
1624         assert_return(bus, -EINVAL);
1625         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1626         assert_return(m, -EINVAL);
1627         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1628         assert_return(!(m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1629         assert_return(!bus_error_is_dirty(error), -EINVAL);
1630         assert_return(!bus_pid_changed(bus), -ECHILD);
1631
1632         r = bus_ensure_running(bus);
1633         if (r < 0)
1634                 return r;
1635
1636         i = bus->rqueue_size;
1637
1638         r = sd_bus_send(bus, m, &serial);
1639         if (r < 0)
1640                 return r;
1641
1642         timeout = calc_elapse(usec);
1643
1644         for (;;) {
1645                 usec_t left;
1646
1647                 while (i < bus->rqueue_size) {
1648                         sd_bus_message *incoming = NULL;
1649
1650                         incoming = bus->rqueue[i];
1651
1652                         if (incoming->reply_serial == serial) {
1653                                 /* Found a match! */
1654
1655                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1656                                 bus->rqueue_size--;
1657
1658                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1659
1660                                         if (reply)
1661                                                 *reply = incoming;
1662                                         else
1663                                                 sd_bus_message_unref(incoming);
1664
1665                                         return 1;
1666                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1667                                         r = sd_bus_error_copy(error, &incoming->error);
1668                                 else
1669                                         r = -EIO;
1670
1671                                 sd_bus_message_unref(incoming);
1672                                 return r;
1673
1674                         } else if (incoming->header->serial == serial &&
1675                                    bus->unique_name &&
1676                                    incoming->sender &&
1677                                    streq(bus->unique_name, incoming->sender)) {
1678
1679                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1680                                 bus->rqueue_size--;
1681
1682                                 /* Our own message? Somebody is trying
1683                                  * to send its own client a message,
1684                                  * let's not dead-lock, let's fail
1685                                  * immediately. */
1686
1687                                 sd_bus_message_unref(incoming);
1688                                 return -ELOOP;
1689                         }
1690
1691                         /* Try to read more, right-away */
1692                         i++;
1693                 }
1694
1695                 r = bus_read_message(bus);
1696                 if (r < 0) {
1697                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1698                                 bus_enter_closing(bus);
1699
1700                         return r;
1701                 }
1702                 if (r > 0)
1703                         continue;
1704
1705                 if (timeout > 0) {
1706                         usec_t n;
1707
1708                         n = now(CLOCK_MONOTONIC);
1709                         if (n >= timeout)
1710                                 return -ETIMEDOUT;
1711
1712                         left = timeout - n;
1713                 } else
1714                         left = (uint64_t) -1;
1715
1716                 r = bus_poll(bus, true, left);
1717                 if (r < 0)
1718                         return r;
1719
1720                 r = dispatch_wqueue(bus);
1721                 if (r < 0) {
1722                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1723                                 bus_enter_closing(bus);
1724
1725                         return r;
1726                 }
1727         }
1728 }
1729
1730 _public_ int sd_bus_get_fd(sd_bus *bus) {
1731
1732         assert_return(bus, -EINVAL);
1733         assert_return(bus->input_fd == bus->output_fd, -EPERM);
1734         assert_return(!bus_pid_changed(bus), -ECHILD);
1735
1736         return bus->input_fd;
1737 }
1738
1739 _public_ int sd_bus_get_events(sd_bus *bus) {
1740         int flags = 0;
1741
1742         assert_return(bus, -EINVAL);
1743         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1744         assert_return(!bus_pid_changed(bus), -ECHILD);
1745
1746         if (bus->state == BUS_OPENING)
1747                 flags |= POLLOUT;
1748         else if (bus->state == BUS_AUTHENTICATING) {
1749
1750                 if (bus_socket_auth_needs_write(bus))
1751                         flags |= POLLOUT;
1752
1753                 flags |= POLLIN;
1754
1755         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1756                 if (bus->rqueue_size <= 0)
1757                         flags |= POLLIN;
1758                 if (bus->wqueue_size > 0)
1759                         flags |= POLLOUT;
1760         }
1761
1762         return flags;
1763 }
1764
1765 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1766         struct reply_callback *c;
1767
1768         assert_return(bus, -EINVAL);
1769         assert_return(timeout_usec, -EINVAL);
1770         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1771         assert_return(!bus_pid_changed(bus), -ECHILD);
1772
1773         if (bus->state == BUS_CLOSING) {
1774                 *timeout_usec = 0;
1775                 return 1;
1776         }
1777
1778         if (bus->state == BUS_AUTHENTICATING) {
1779                 *timeout_usec = bus->auth_timeout;
1780                 return 1;
1781         }
1782
1783         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1784                 *timeout_usec = (uint64_t) -1;
1785                 return 0;
1786         }
1787
1788         if (bus->rqueue_size > 0) {
1789                 *timeout_usec = 0;
1790                 return 1;
1791         }
1792
1793         c = prioq_peek(bus->reply_callbacks_prioq);
1794         if (!c) {
1795                 *timeout_usec = (uint64_t) -1;
1796                 return 0;
1797         }
1798
1799         *timeout_usec = c->timeout;
1800         return 1;
1801 }
1802
1803 static int process_timeout(sd_bus *bus) {
1804         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1805         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1806         struct reply_callback *c;
1807         usec_t n;
1808         int r;
1809
1810         assert(bus);
1811
1812         c = prioq_peek(bus->reply_callbacks_prioq);
1813         if (!c)
1814                 return 0;
1815
1816         n = now(CLOCK_MONOTONIC);
1817         if (c->timeout > n)
1818                 return 0;
1819
1820         r = bus_message_new_synthetic_error(
1821                         bus,
1822                         c->serial,
1823                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
1824                         &m);
1825         if (r < 0)
1826                 return r;
1827
1828         m->sender = "org.freedesktop.DBus";
1829
1830         r = bus_seal_synthetic_message(bus, m);
1831         if (r < 0)
1832                 return r;
1833
1834         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1835         hashmap_remove(bus->reply_callbacks, &c->serial);
1836
1837         bus->current = m;
1838         bus->iteration_counter ++;
1839
1840         r = c->callback(bus, m, c->userdata, &error_buffer);
1841         r = bus_maybe_reply_error(m, r, &error_buffer);
1842         free(c);
1843
1844         bus->current = NULL;
1845
1846         return r;
1847 }
1848
1849 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1850         assert(bus);
1851         assert(m);
1852
1853         if (bus->state != BUS_HELLO)
1854                 return 0;
1855
1856         /* Let's make sure the first message on the bus is the HELLO
1857          * reply. But note that we don't actually parse the message
1858          * here (we leave that to the usual handling), we just verify
1859          * we don't let any earlier msg through. */
1860
1861         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1862             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1863                 return -EIO;
1864
1865         if (m->reply_serial != bus->hello_serial)
1866                 return -EIO;
1867
1868         return 0;
1869 }
1870
1871 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1872         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1873         struct reply_callback *c;
1874         int r;
1875
1876         assert(bus);
1877         assert(m);
1878
1879         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1880             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1881                 return 0;
1882
1883         c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1884         if (!c)
1885                 return 0;
1886
1887         if (c->timeout != 0)
1888                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1889
1890         r = sd_bus_message_rewind(m, true);
1891         if (r < 0)
1892                 return r;
1893
1894         r = c->callback(bus, m, c->userdata, &error_buffer);
1895         r = bus_maybe_reply_error(m, r, &error_buffer);
1896         free(c);
1897
1898         return r;
1899 }
1900
1901 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1902         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1903         struct filter_callback *l;
1904         int r;
1905
1906         assert(bus);
1907         assert(m);
1908
1909         do {
1910                 bus->filter_callbacks_modified = false;
1911
1912                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1913
1914                         if (bus->filter_callbacks_modified)
1915                                 break;
1916
1917                         /* Don't run this more than once per iteration */
1918                         if (l->last_iteration == bus->iteration_counter)
1919                                 continue;
1920
1921                         l->last_iteration = bus->iteration_counter;
1922
1923                         r = sd_bus_message_rewind(m, true);
1924                         if (r < 0)
1925                                 return r;
1926
1927                         r = l->callback(bus, m, l->userdata, &error_buffer);
1928                         r = bus_maybe_reply_error(m, r, &error_buffer);
1929                         if (r != 0)
1930                                 return r;
1931
1932                 }
1933
1934         } while (bus->filter_callbacks_modified);
1935
1936         return 0;
1937 }
1938
1939 static int process_match(sd_bus *bus, sd_bus_message *m) {
1940         int r;
1941
1942         assert(bus);
1943         assert(m);
1944
1945         do {
1946                 bus->match_callbacks_modified = false;
1947
1948                 r = bus_match_run(bus, &bus->match_callbacks, m);
1949                 if (r != 0)
1950                         return r;
1951
1952         } while (bus->match_callbacks_modified);
1953
1954         return 0;
1955 }
1956
1957 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1958         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1959         int r;
1960
1961         assert(bus);
1962         assert(m);
1963
1964         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1965                 return 0;
1966
1967         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
1968                 return 0;
1969
1970         if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1971                 return 1;
1972
1973         if (streq_ptr(m->member, "Ping"))
1974                 r = sd_bus_message_new_method_return(m, &reply);
1975         else if (streq_ptr(m->member, "GetMachineId")) {
1976                 sd_id128_t id;
1977                 char sid[33];
1978
1979                 r = sd_id128_get_machine(&id);
1980                 if (r < 0)
1981                         return r;
1982
1983                 r = sd_bus_message_new_method_return(m, &reply);
1984                 if (r < 0)
1985                         return r;
1986
1987                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
1988         } else {
1989                 r = sd_bus_message_new_method_errorf(
1990                                 m, &reply,
1991                                 SD_BUS_ERROR_UNKNOWN_METHOD,
1992                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
1993         }
1994
1995         if (r < 0)
1996                 return r;
1997
1998         r = sd_bus_send(bus, reply, NULL);
1999         if (r < 0)
2000                 return r;
2001
2002         return 1;
2003 }
2004
2005 static int process_message(sd_bus *bus, sd_bus_message *m) {
2006         int r;
2007
2008         assert(bus);
2009         assert(m);
2010
2011         bus->current = m;
2012         bus->iteration_counter++;
2013
2014         log_debug("Got message sender=%s object=%s interface=%s member=%s",
2015                   strna(sd_bus_message_get_sender(m)),
2016                   strna(sd_bus_message_get_path(m)),
2017                   strna(sd_bus_message_get_interface(m)),
2018                   strna(sd_bus_message_get_member(m)));
2019
2020         r = process_hello(bus, m);
2021         if (r != 0)
2022                 goto finish;
2023
2024         r = process_reply(bus, m);
2025         if (r != 0)
2026                 goto finish;
2027
2028         r = process_filter(bus, m);
2029         if (r != 0)
2030                 goto finish;
2031
2032         r = process_match(bus, m);
2033         if (r != 0)
2034                 goto finish;
2035
2036         r = process_builtin(bus, m);
2037         if (r != 0)
2038                 goto finish;
2039
2040         r = bus_process_object(bus, m);
2041
2042 finish:
2043         bus->current = NULL;
2044         return r;
2045 }
2046
2047 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2048         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2049         int r;
2050
2051         assert(bus);
2052         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2053
2054         r = process_timeout(bus);
2055         if (r != 0)
2056                 goto null_message;
2057
2058         r = dispatch_wqueue(bus);
2059         if (r != 0)
2060                 goto null_message;
2061
2062         r = dispatch_rqueue(bus, &m);
2063         if (r < 0)
2064                 return r;
2065         if (!m)
2066                 goto null_message;
2067
2068         r = process_message(bus, m);
2069         if (r != 0)
2070                 goto null_message;
2071
2072         if (ret) {
2073                 r = sd_bus_message_rewind(m, true);
2074                 if (r < 0)
2075                         return r;
2076
2077                 *ret = m;
2078                 m = NULL;
2079                 return 1;
2080         }
2081
2082         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2083
2084                 r = sd_bus_reply_method_errorf(
2085                                 m,
2086                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2087                                 "Unknown object '%s'.", m->path);
2088                 if (r < 0)
2089                         return r;
2090         }
2091
2092         return 1;
2093
2094 null_message:
2095         if (r >= 0 && ret)
2096                 *ret = NULL;
2097
2098         return r;
2099 }
2100
2101 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2102         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2103         struct reply_callback *c;
2104         int r;
2105
2106         assert(bus);
2107         assert(bus->state == BUS_CLOSING);
2108
2109         c = hashmap_first(bus->reply_callbacks);
2110         if (c) {
2111                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2112
2113                 /* First, fail all outstanding method calls */
2114                 r = bus_message_new_synthetic_error(
2115                                 bus,
2116                                 c->serial,
2117                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2118                                 &m);
2119                 if (r < 0)
2120                         return r;
2121
2122                 r = bus_seal_synthetic_message(bus, m);
2123                 if (r < 0)
2124                         return r;
2125
2126                 if (c->timeout != 0)
2127                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2128
2129                 hashmap_remove(bus->reply_callbacks, &c->serial);
2130
2131                 bus->current = m;
2132                 bus->iteration_counter++;
2133
2134                 r = c->callback(bus, m, c->userdata, &error_buffer);
2135                 r = bus_maybe_reply_error(m, r, &error_buffer);
2136                 free(c);
2137
2138                 goto finish;
2139         }
2140
2141         /* Then, synthesize a Disconnected message */
2142         r = sd_bus_message_new_signal(
2143                         bus,
2144                         "/org/freedesktop/DBus/Local",
2145                         "org.freedesktop.DBus.Local",
2146                         "Disconnected",
2147                         &m);
2148         if (r < 0)
2149                 return r;
2150
2151         m->sender = "org.freedesktop.DBus.Local";
2152
2153         r = bus_seal_synthetic_message(bus, m);
2154         if (r < 0)
2155                 return r;
2156
2157         sd_bus_close(bus);
2158
2159         bus->current = m;
2160         bus->iteration_counter++;
2161
2162         r = process_filter(bus, m);
2163         if (r != 0)
2164                 goto finish;
2165
2166         r = process_match(bus, m);
2167         if (r != 0)
2168                 goto finish;
2169
2170         if (ret) {
2171                 *ret = m;
2172                 m = NULL;
2173         }
2174
2175         r = 1;
2176
2177 finish:
2178         bus->current = NULL;
2179         return r;
2180 }
2181
2182 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2183         BUS_DONT_DESTROY(bus);
2184         int r;
2185
2186         /* Returns 0 when we didn't do anything. This should cause the
2187          * caller to invoke sd_bus_wait() before returning the next
2188          * time. Returns > 0 when we did something, which possibly
2189          * means *ret is filled in with an unprocessed message. */
2190
2191         assert_return(bus, -EINVAL);
2192         assert_return(!bus_pid_changed(bus), -ECHILD);
2193
2194         /* We don't allow recursively invoking sd_bus_process(). */
2195         assert_return(!bus->current, -EBUSY);
2196
2197         switch (bus->state) {
2198
2199         case BUS_UNSET:
2200         case BUS_CLOSED:
2201                 return -ENOTCONN;
2202
2203         case BUS_OPENING:
2204                 r = bus_socket_process_opening(bus);
2205                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2206                         bus_enter_closing(bus);
2207                         r = 1;
2208                 } else if (r < 0)
2209                         return r;
2210                 if (ret)
2211                         *ret = NULL;
2212                 return r;
2213
2214         case BUS_AUTHENTICATING:
2215                 r = bus_socket_process_authenticating(bus);
2216                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2217                         bus_enter_closing(bus);
2218                         r = 1;
2219                 } else if (r < 0)
2220                         return r;
2221
2222                 if (ret)
2223                         *ret = NULL;
2224
2225                 return r;
2226
2227         case BUS_RUNNING:
2228         case BUS_HELLO:
2229                 r = process_running(bus, ret);
2230                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2231                         bus_enter_closing(bus);
2232                         r = 1;
2233
2234                         if (ret)
2235                                 *ret = NULL;
2236                 }
2237
2238                 return r;
2239
2240         case BUS_CLOSING:
2241                 return process_closing(bus, ret);
2242         }
2243
2244         assert_not_reached("Unknown state");
2245 }
2246
2247 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2248         struct pollfd p[2] = {};
2249         int r, e, n;
2250         struct timespec ts;
2251         usec_t m = (usec_t) -1;
2252
2253         assert(bus);
2254
2255         if (bus->state == BUS_CLOSING)
2256                 return 1;
2257
2258         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2259
2260         e = sd_bus_get_events(bus);
2261         if (e < 0)
2262                 return e;
2263
2264         if (need_more)
2265                 /* The caller really needs some more data, he doesn't
2266                  * care about what's already read, or any timeouts
2267                  * except its own.*/
2268                 e |= POLLIN;
2269         else {
2270                 usec_t until;
2271                 /* The caller wants to process if there's something to
2272                  * process, but doesn't care otherwise */
2273
2274                 r = sd_bus_get_timeout(bus, &until);
2275                 if (r < 0)
2276                         return r;
2277                 if (r > 0) {
2278                         usec_t nw;
2279                         nw = now(CLOCK_MONOTONIC);
2280                         m = until > nw ? until - nw : 0;
2281                 }
2282         }
2283
2284         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2285                 m = timeout_usec;
2286
2287         p[0].fd = bus->input_fd;
2288         if (bus->output_fd == bus->input_fd) {
2289                 p[0].events = e;
2290                 n = 1;
2291         } else {
2292                 p[0].events = e & POLLIN;
2293                 p[1].fd = bus->output_fd;
2294                 p[1].events = e & POLLOUT;
2295                 n = 2;
2296         }
2297
2298         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2299         if (r < 0)
2300                 return -errno;
2301
2302         return r > 0 ? 1 : 0;
2303 }
2304
2305 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2306
2307         assert_return(bus, -EINVAL);
2308         assert_return(!bus_pid_changed(bus), -ECHILD);
2309
2310         if (bus->state == BUS_CLOSING)
2311                 return 0;
2312
2313         assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2314
2315         if (bus->rqueue_size > 0)
2316                 return 0;
2317
2318         return bus_poll(bus, false, timeout_usec);
2319 }
2320
2321 _public_ int sd_bus_flush(sd_bus *bus) {
2322         int r;
2323
2324         assert_return(bus, -EINVAL);
2325         assert_return(!bus_pid_changed(bus), -ECHILD);
2326
2327         if (bus->state == BUS_CLOSING)
2328                 return 0;
2329
2330         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2331
2332         r = bus_ensure_running(bus);
2333         if (r < 0)
2334                 return r;
2335
2336         if (bus->wqueue_size <= 0)
2337                 return 0;
2338
2339         for (;;) {
2340                 r = dispatch_wqueue(bus);
2341                 if (r < 0) {
2342                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
2343                                 bus_enter_closing(bus);
2344
2345                         return r;
2346                 }
2347
2348                 if (bus->wqueue_size <= 0)
2349                         return 0;
2350
2351                 r = bus_poll(bus, false, (uint64_t) -1);
2352                 if (r < 0)
2353                         return r;
2354         }
2355 }
2356
2357 _public_ int sd_bus_add_filter(sd_bus *bus,
2358                                sd_bus_message_handler_t callback,
2359                                void *userdata) {
2360
2361         struct filter_callback *f;
2362
2363         assert_return(bus, -EINVAL);
2364         assert_return(callback, -EINVAL);
2365         assert_return(!bus_pid_changed(bus), -ECHILD);
2366
2367         f = new0(struct filter_callback, 1);
2368         if (!f)
2369                 return -ENOMEM;
2370         f->callback = callback;
2371         f->userdata = userdata;
2372
2373         bus->filter_callbacks_modified = true;
2374         LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2375         return 0;
2376 }
2377
2378 _public_ int sd_bus_remove_filter(sd_bus *bus,
2379                                   sd_bus_message_handler_t callback,
2380                                   void *userdata) {
2381
2382         struct filter_callback *f;
2383
2384         assert_return(bus, -EINVAL);
2385         assert_return(callback, -EINVAL);
2386         assert_return(!bus_pid_changed(bus), -ECHILD);
2387
2388         LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2389                 if (f->callback == callback && f->userdata == userdata) {
2390                         bus->filter_callbacks_modified = true;
2391                         LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2392                         free(f);
2393                         return 1;
2394                 }
2395         }
2396
2397         return 0;
2398 }
2399
2400 _public_ int sd_bus_add_match(sd_bus *bus,
2401                               const char *match,
2402                               sd_bus_message_handler_t callback,
2403                               void *userdata) {
2404
2405         struct bus_match_component *components = NULL;
2406         unsigned n_components = 0;
2407         uint64_t cookie = 0;
2408         int r = 0;
2409
2410         assert_return(bus, -EINVAL);
2411         assert_return(match, -EINVAL);
2412         assert_return(!bus_pid_changed(bus), -ECHILD);
2413
2414         r = bus_match_parse(match, &components, &n_components);
2415         if (r < 0)
2416                 goto finish;
2417
2418         if (bus->bus_client) {
2419                 cookie = ++bus->match_cookie;
2420
2421                 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2422                 if (r < 0)
2423                         goto finish;
2424         }
2425
2426         bus->match_callbacks_modified = true;
2427         r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2428         if (r < 0) {
2429                 if (bus->bus_client)
2430                         bus_remove_match_internal(bus, match, cookie);
2431         }
2432
2433 finish:
2434         bus_match_parse_free(components, n_components);
2435         return r;
2436 }
2437
2438 _public_ int sd_bus_remove_match(sd_bus *bus,
2439                                  const char *match,
2440                                  sd_bus_message_handler_t callback,
2441                                  void *userdata) {
2442
2443         struct bus_match_component *components = NULL;
2444         unsigned n_components = 0;
2445         int r = 0, q = 0;
2446         uint64_t cookie = 0;
2447
2448         assert_return(bus, -EINVAL);
2449         assert_return(match, -EINVAL);
2450         assert_return(!bus_pid_changed(bus), -ECHILD);
2451
2452         r = bus_match_parse(match, &components, &n_components);
2453         if (r < 0)
2454                 return r;
2455
2456         bus->match_callbacks_modified = true;
2457         r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2458
2459         if (bus->bus_client)
2460                 q = bus_remove_match_internal(bus, match, cookie);
2461
2462         bus_match_parse_free(components, n_components);
2463
2464         return r < 0 ? r : q;
2465 }
2466
2467 bool bus_pid_changed(sd_bus *bus) {
2468         assert(bus);
2469
2470         /* We don't support people creating a bus connection and
2471          * keeping it around over a fork(). Let's complain. */
2472
2473         return bus->original_pid != getpid();
2474 }
2475
2476 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2477         sd_bus *bus = userdata;
2478         int r;
2479
2480         assert(bus);
2481
2482         r = sd_bus_process(bus, NULL);
2483         if (r < 0)
2484                 return r;
2485
2486         return 1;
2487 }
2488
2489 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2490         sd_bus *bus = userdata;
2491         int r;
2492
2493         assert(bus);
2494
2495         r = sd_bus_process(bus, NULL);
2496         if (r < 0)
2497                 return r;
2498
2499         return 1;
2500 }
2501
2502 static int prepare_callback(sd_event_source *s, void *userdata) {
2503         sd_bus *bus = userdata;
2504         int r, e;
2505         usec_t until;
2506
2507         assert(s);
2508         assert(bus);
2509
2510         e = sd_bus_get_events(bus);
2511         if (e < 0)
2512                 return e;
2513
2514         if (bus->output_fd != bus->input_fd) {
2515
2516                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2517                 if (r < 0)
2518                         return r;
2519
2520                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2521                 if (r < 0)
2522                         return r;
2523         } else {
2524                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2525                 if (r < 0)
2526                         return r;
2527         }
2528
2529         r = sd_bus_get_timeout(bus, &until);
2530         if (r < 0)
2531                 return r;
2532         if (r > 0) {
2533                 int j;
2534
2535                 j = sd_event_source_set_time(bus->time_event_source, until);
2536                 if (j < 0)
2537                         return j;
2538         }
2539
2540         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2541         if (r < 0)
2542                 return r;
2543
2544         return 1;
2545 }
2546
2547 static int quit_callback(sd_event_source *event, void *userdata) {
2548         sd_bus *bus = userdata;
2549
2550         assert(event);
2551
2552         sd_bus_flush(bus);
2553
2554         return 1;
2555 }
2556
2557 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2558         int r;
2559
2560         assert_return(bus, -EINVAL);
2561         assert_return(!bus->event, -EBUSY);
2562
2563         assert(!bus->input_io_event_source);
2564         assert(!bus->output_io_event_source);
2565         assert(!bus->time_event_source);
2566
2567         if (event)
2568                 bus->event = sd_event_ref(event);
2569         else  {
2570                 r = sd_event_default(&bus->event);
2571                 if (r < 0)
2572                         return r;
2573         }
2574
2575         r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2576         if (r < 0)
2577                 goto fail;
2578
2579         r = sd_event_source_set_priority(bus->input_io_event_source, priority);
2580         if (r < 0)
2581                 goto fail;
2582
2583         if (bus->output_fd != bus->input_fd) {
2584                 r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2585                 if (r < 0)
2586                         goto fail;
2587
2588                 r = sd_event_source_set_priority(bus->output_io_event_source, priority);
2589                 if (r < 0)
2590                         goto fail;
2591         }
2592
2593         r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2594         if (r < 0)
2595                 goto fail;
2596
2597         r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2598         if (r < 0)
2599                 goto fail;
2600
2601         r = sd_event_source_set_priority(bus->time_event_source, priority);
2602         if (r < 0)
2603                 goto fail;
2604
2605         r = sd_event_add_quit(bus->event, quit_callback, bus, &bus->quit_event_source);
2606         if (r < 0)
2607                 goto fail;
2608
2609         return 0;
2610
2611 fail:
2612         sd_bus_detach_event(bus);
2613         return r;
2614 }
2615
2616 _public_ int sd_bus_detach_event(sd_bus *bus) {
2617         assert_return(bus, -EINVAL);
2618         assert_return(bus->event, -ENXIO);
2619
2620         if (bus->input_io_event_source) {
2621                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2622                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2623         }
2624
2625         if (bus->output_io_event_source) {
2626                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2627                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2628         }
2629
2630         if (bus->time_event_source) {
2631                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2632                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2633         }
2634
2635         if (bus->quit_event_source) {
2636                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2637                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2638         }
2639
2640         if (bus->event)
2641                 bus->event = sd_event_unref(bus->event);
2642
2643         return 0;
2644 }
2645
2646 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2647         assert_return(bus, NULL);
2648
2649         return bus->event;
2650 }
2651
2652 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2653         assert_return(bus, NULL);
2654
2655         return bus->current;
2656 }
2657
2658 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2659         sd_bus *b = NULL;
2660         int r;
2661
2662         assert(bus_open);
2663         assert(default_bus);
2664
2665         if (!ret)
2666                 return !!*default_bus;
2667
2668         if (*default_bus) {
2669                 *ret = sd_bus_ref(*default_bus);
2670                 return 0;
2671         }
2672
2673         r = bus_open(&b);
2674         if (r < 0)
2675                 return r;
2676
2677         b->default_bus_ptr = default_bus;
2678         b->tid = gettid();
2679         *default_bus = b;
2680
2681         *ret = b;
2682         return 1;
2683 }
2684
2685 _public_ int sd_bus_default_system(sd_bus **ret) {
2686         static __thread sd_bus *default_system_bus = NULL;
2687
2688         return bus_default(sd_bus_open_system, &default_system_bus, ret);
2689 }
2690
2691 _public_ int sd_bus_default_user(sd_bus **ret) {
2692         static __thread sd_bus *default_user_bus = NULL;
2693
2694         return bus_default(sd_bus_open_user, &default_user_bus, ret);
2695 }
2696
2697 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2698         assert_return(b, -EINVAL);
2699         assert_return(tid, -EINVAL);
2700         assert_return(!bus_pid_changed(b), -ECHILD);
2701
2702         if (b->tid != 0) {
2703                 *tid = b->tid;
2704                 return 0;
2705         }
2706
2707         if (b->event)
2708                 return sd_event_get_tid(b->event, tid);
2709
2710         return -ENXIO;
2711 }
2712
2713 _public_ char *sd_bus_label_escape(const char *s) {
2714         char *r, *t;
2715         const char *f;
2716
2717         assert_return(s, NULL);
2718
2719         /* Escapes all chars that D-Bus' object path cannot deal
2720          * with. Can be reversed with bus_path_unescape(). We special
2721          * case the empty string. */
2722
2723         if (*s == 0)
2724                 return strdup("_");
2725
2726         r = new(char, strlen(s)*3 + 1);
2727         if (!r)
2728                 return NULL;
2729
2730         for (f = s, t = r; *f; f++) {
2731
2732                 /* Escape everything that is not a-zA-Z0-9. We also
2733                  * escape 0-9 if it's the first character */
2734
2735                 if (!(*f >= 'A' && *f <= 'Z') &&
2736                     !(*f >= 'a' && *f <= 'z') &&
2737                     !(f > s && *f >= '0' && *f <= '9')) {
2738                         *(t++) = '_';
2739                         *(t++) = hexchar(*f >> 4);
2740                         *(t++) = hexchar(*f);
2741                 } else
2742                         *(t++) = *f;
2743         }
2744
2745         *t = 0;
2746
2747         return r;
2748 }
2749
2750 _public_ char *sd_bus_label_unescape(const char *f) {
2751         char *r, *t;
2752
2753         assert_return(f, NULL);
2754
2755         /* Special case for the empty string */
2756         if (streq(f, "_"))
2757                 return strdup("");
2758
2759         r = new(char, strlen(f) + 1);
2760         if (!r)
2761                 return NULL;
2762
2763         for (t = r; *f; f++) {
2764
2765                 if (*f == '_') {
2766                         int a, b;
2767
2768                         if ((a = unhexchar(f[1])) < 0 ||
2769                             (b = unhexchar(f[2])) < 0) {
2770                                 /* Invalid escape code, let's take it literal then */
2771                                 *(t++) = '_';
2772                         } else {
2773                                 *(t++) = (char) ((a << 4) | b);
2774                                 f += 2;
2775                         }
2776                 } else
2777                         *(t++) = *f;
2778         }
2779
2780         *t = 0;
2781
2782         return r;
2783 }
2784
2785 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
2786         sd_bus_creds *c;
2787         pid_t pid = 0;
2788         int r;
2789
2790         assert_return(bus, -EINVAL);
2791         assert_return(mask <= _SD_BUS_CREDS_MAX, -ENOTSUP);
2792         assert_return(ret, -EINVAL);
2793         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2794         assert_return(!bus_pid_changed(bus), -ECHILD);
2795         assert_return(!bus->is_kernel, -ENOTSUP);
2796
2797         if (!bus->ucred_valid && !isempty(bus->label))
2798                 return -ENODATA;
2799
2800         c = bus_creds_new();
2801         if (!c)
2802                 return -ENOMEM;
2803
2804         if (bus->ucred_valid) {
2805                 pid = c->pid = bus->ucred.pid;
2806                 c->uid = bus->ucred.uid;
2807                 c->gid = bus->ucred.gid;
2808
2809                 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
2810         }
2811
2812         if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
2813                 c->label = strdup(bus->label);
2814                 if (!c->label) {
2815                         sd_bus_creds_unref(c);
2816                         return -ENOMEM;
2817                 }
2818
2819                 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
2820         }
2821
2822         r = bus_creds_add_more(c, mask, pid, 0);
2823         if (r < 0)
2824                 return r;
2825
2826         *ret = c;
2827         return 0;
2828 }