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