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