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