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
1146         e = bus_address_escape(machine);
1147         if (!e)
1148                 return -ENOMEM;
1149
1150         p = strjoin("x-container:machine=", e, NULL);
1151         if (!p)
1152                 return -ENOMEM;
1153
1154         r = sd_bus_new(&bus);
1155         if (r < 0) {
1156                 free(p);
1157                 return r;
1158         }
1159
1160         bus->address = p;
1161         bus->bus_client = true;
1162
1163         r = sd_bus_start(bus);
1164         if (r < 0) {
1165                 bus_free(bus);
1166                 return r;
1167         }
1168
1169         *ret = bus;
1170         return 0;
1171 }
1172
1173 _public_ void sd_bus_close(sd_bus *bus) {
1174
1175         if (!bus)
1176                 return;
1177         if (bus->state == BUS_CLOSED)
1178                 return;
1179         if (bus_pid_changed(bus))
1180                 return;
1181
1182         bus->state = BUS_CLOSED;
1183
1184         sd_bus_detach_event(bus);
1185
1186         /* Drop all queued messages so that they drop references to
1187          * the bus object and the bus may be freed */
1188         bus_reset_queues(bus);
1189
1190         if (!bus->is_kernel)
1191                 bus_close_fds(bus);
1192
1193         /* We'll leave the fd open in case this is a kernel bus, since
1194          * there might still be memblocks around that reference this
1195          * bus, and they might need to invoke the * KDBUS_CMD_FREE
1196          * ioctl on the fd when they are freed. */
1197 }
1198
1199 static void bus_enter_closing(sd_bus *bus) {
1200         assert(bus);
1201
1202         if (bus->state != BUS_OPENING &&
1203             bus->state != BUS_AUTHENTICATING &&
1204             bus->state != BUS_HELLO &&
1205             bus->state != BUS_RUNNING)
1206                 return;
1207
1208         bus->state = BUS_CLOSING;
1209 }
1210
1211 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1212         assert_return(bus, NULL);
1213
1214         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1215
1216         return bus;
1217 }
1218
1219 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1220
1221         if (!bus)
1222                 return NULL;
1223
1224         if (REFCNT_DEC(bus->n_ref) <= 0)
1225                 bus_free(bus);
1226
1227         return NULL;
1228 }
1229
1230 _public_ int sd_bus_is_open(sd_bus *bus) {
1231
1232         assert_return(bus, -EINVAL);
1233         assert_return(!bus_pid_changed(bus), -ECHILD);
1234
1235         return BUS_IS_OPEN(bus->state);
1236 }
1237
1238 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1239         int r;
1240
1241         assert_return(bus, -EINVAL);
1242         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1243         assert_return(!bus_pid_changed(bus), -ECHILD);
1244
1245         if (type == SD_BUS_TYPE_UNIX_FD) {
1246                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1247                         return 0;
1248
1249                 r = bus_ensure_running(bus);
1250                 if (r < 0)
1251                         return r;
1252
1253                 return bus->can_fds;
1254         }
1255
1256         return bus_type_is_valid(type);
1257 }
1258
1259 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1260         int r;
1261
1262         assert_return(bus, -EINVAL);
1263         assert_return(server_id, -EINVAL);
1264         assert_return(!bus_pid_changed(bus), -ECHILD);
1265
1266         r = bus_ensure_running(bus);
1267         if (r < 0)
1268                 return r;
1269
1270         *server_id = bus->server_id;
1271         return 0;
1272 }
1273
1274 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1275         assert(b);
1276         assert(m);
1277
1278         if (m->header->version > b->message_version)
1279                 return -EPERM;
1280
1281         if (m->sealed) {
1282                 /* If we copy the same message to multiple
1283                  * destinations, avoid using the same serial
1284                  * numbers. */
1285                 b->serial = MAX(b->serial, BUS_MESSAGE_SERIAL(m));
1286                 return 0;
1287         }
1288
1289         return bus_message_seal(m, ++b->serial);
1290 }
1291
1292 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1293         assert(b);
1294         assert(m);
1295
1296         if (m->header->version > b->message_version)
1297                 return -EPERM;
1298
1299         /* The bus specification says the serial number cannot be 0,
1300          * hence let's fill something in for synthetic messages. Since
1301          * synthetic messages might have a fake sender and we don't
1302          * want to interfere with the real sender's serial numbers we
1303          * pick a fixed, artifical one. We use (uint32_t) -1 rather
1304          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1305          * even though kdbus can do 64bit. */
1306
1307         return bus_message_seal(m, 0xFFFFFFFFULL);
1308 }
1309
1310 static int bus_write_message(sd_bus *bus, sd_bus_message *message, size_t *idx) {
1311         assert(bus);
1312         assert(message);
1313
1314         if (bus->is_kernel)
1315                 return bus_kernel_write_message(bus, message);
1316         else
1317                 return bus_socket_write_message(bus, message, idx);
1318 }
1319
1320 static int dispatch_wqueue(sd_bus *bus) {
1321         int r, ret = 0;
1322
1323         assert(bus);
1324         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1325
1326         while (bus->wqueue_size > 0) {
1327
1328                 r = bus_write_message(bus, bus->wqueue[0], &bus->windex);
1329                 if (r < 0)
1330                         return r;
1331                 else if (r == 0)
1332                         /* Didn't do anything this time */
1333                         return ret;
1334                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1335                         /* Fully written. Let's drop the entry from
1336                          * the queue.
1337                          *
1338                          * This isn't particularly optimized, but
1339                          * well, this is supposed to be our worst-case
1340                          * buffer only, and the socket buffer is
1341                          * supposed to be our primary buffer, and if
1342                          * it got full, then all bets are off
1343                          * anyway. */
1344
1345                         sd_bus_message_unref(bus->wqueue[0]);
1346                         bus->wqueue_size --;
1347                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1348                         bus->windex = 0;
1349
1350                         ret = 1;
1351                 }
1352         }
1353
1354         return ret;
1355 }
1356
1357 static int bus_read_message(sd_bus *bus) {
1358         assert(bus);
1359
1360         if (bus->is_kernel)
1361                 return bus_kernel_read_message(bus);
1362         else
1363                 return bus_socket_read_message(bus);
1364 }
1365
1366 int bus_rqueue_make_room(sd_bus *bus) {
1367         sd_bus_message **q;
1368         unsigned x;
1369
1370         x = bus->rqueue_size + 1;
1371
1372         if (bus->rqueue_allocated >= x)
1373                 return 0;
1374
1375         if (x > BUS_RQUEUE_MAX)
1376                 return -ENOBUFS;
1377
1378         q = realloc(bus->rqueue, x * sizeof(sd_bus_message*));
1379         if (!q)
1380                 return -ENOMEM;
1381
1382         bus->rqueue = q;
1383         bus->rqueue_allocated = x;
1384
1385         return 0;
1386 }
1387
1388 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1389         int r, ret = 0;
1390
1391         assert(bus);
1392         assert(m);
1393         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1394
1395         for (;;) {
1396                 if (bus->rqueue_size > 0) {
1397                         /* Dispatch a queued message */
1398
1399                         *m = bus->rqueue[0];
1400                         bus->rqueue_size --;
1401                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1402                         return 1;
1403                 }
1404
1405                 /* Try to read a new message */
1406                 r = bus_read_message(bus);
1407                 if (r < 0)
1408                         return r;
1409                 if (r == 0)
1410                         return ret;
1411
1412                 ret = 1;
1413         }
1414 }
1415
1416 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1417         int r;
1418
1419         assert_return(bus, -EINVAL);
1420         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1421         assert_return(m, -EINVAL);
1422         assert_return(!bus_pid_changed(bus), -ECHILD);
1423
1424         if (m->n_fds > 0) {
1425                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1426                 if (r < 0)
1427                         return r;
1428                 if (r == 0)
1429                         return -ENOTSUP;
1430         }
1431
1432         /* If the serial number isn't kept, then we know that no reply
1433          * is expected */
1434         if (!serial && !m->sealed)
1435                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1436
1437         r = bus_seal_message(bus, m);
1438         if (r < 0)
1439                 return r;
1440
1441         /* If this is a reply and no reply was requested, then let's
1442          * suppress this, if we can */
1443         if (m->dont_send && !serial)
1444                 return 1;
1445
1446         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1447                 size_t idx = 0;
1448
1449                 r = bus_write_message(bus, m, &idx);
1450                 if (r < 0) {
1451                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1452                                 bus_enter_closing(bus);
1453
1454                         return r;
1455                 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1456                         /* Wasn't fully written. So let's remember how
1457                          * much was written. Note that the first entry
1458                          * of the wqueue array is always allocated so
1459                          * that we always can remember how much was
1460                          * written. */
1461                         bus->wqueue[0] = sd_bus_message_ref(m);
1462                         bus->wqueue_size = 1;
1463                         bus->windex = idx;
1464                 }
1465         } else {
1466                 sd_bus_message **q;
1467
1468                 /* Just append it to the queue. */
1469
1470                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1471                         return -ENOBUFS;
1472
1473                 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1474                 if (!q)
1475                         return -ENOMEM;
1476
1477                 bus->wqueue = q;
1478                 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1479         }
1480
1481         if (serial)
1482                 *serial = BUS_MESSAGE_SERIAL(m);
1483
1484         return 1;
1485 }
1486
1487 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *serial) {
1488         int r;
1489
1490         assert_return(bus, -EINVAL);
1491         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1492         assert_return(m, -EINVAL);
1493         assert_return(!bus_pid_changed(bus), -ECHILD);
1494
1495         if (!streq_ptr(m->destination, destination)) {
1496
1497                 if (!destination)
1498                         return -EEXIST;
1499
1500                 r = sd_bus_message_set_destination(m, destination);
1501                 if (r < 0)
1502                         return r;
1503         }
1504
1505         return sd_bus_send(bus, m, serial);
1506 }
1507
1508 static usec_t calc_elapse(uint64_t usec) {
1509         if (usec == (uint64_t) -1)
1510                 return 0;
1511
1512         if (usec == 0)
1513                 usec = BUS_DEFAULT_TIMEOUT;
1514
1515         return now(CLOCK_MONOTONIC) + usec;
1516 }
1517
1518 static int timeout_compare(const void *a, const void *b) {
1519         const struct reply_callback *x = a, *y = b;
1520
1521         if (x->timeout != 0 && y->timeout == 0)
1522                 return -1;
1523
1524         if (x->timeout == 0 && y->timeout != 0)
1525                 return 1;
1526
1527         if (x->timeout < y->timeout)
1528                 return -1;
1529
1530         if (x->timeout > y->timeout)
1531                 return 1;
1532
1533         return 0;
1534 }
1535
1536 _public_ int sd_bus_call_async(
1537                 sd_bus *bus,
1538                 sd_bus_message *m,
1539                 sd_bus_message_handler_t callback,
1540                 void *userdata,
1541                 uint64_t usec,
1542                 uint64_t *serial) {
1543
1544         struct reply_callback *c;
1545         int r;
1546
1547         assert_return(bus, -EINVAL);
1548         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1549         assert_return(m, -EINVAL);
1550         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1551         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1552         assert_return(callback, -EINVAL);
1553         assert_return(!bus_pid_changed(bus), -ECHILD);
1554
1555         r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1556         if (r < 0)
1557                 return r;
1558
1559         if (usec != (uint64_t) -1) {
1560                 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1561                 if (r < 0)
1562                         return r;
1563         }
1564
1565         r = bus_seal_message(bus, m);
1566         if (r < 0)
1567                 return r;
1568
1569         c = new0(struct reply_callback, 1);
1570         if (!c)
1571                 return -ENOMEM;
1572
1573         c->callback = callback;
1574         c->userdata = userdata;
1575         c->serial = BUS_MESSAGE_SERIAL(m);
1576         c->timeout = calc_elapse(usec);
1577
1578         r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1579         if (r < 0) {
1580                 free(c);
1581                 return r;
1582         }
1583
1584         if (c->timeout != 0) {
1585                 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1586                 if (r < 0) {
1587                         c->timeout = 0;
1588                         sd_bus_call_async_cancel(bus, c->serial);
1589                         return r;
1590                 }
1591         }
1592
1593         r = sd_bus_send(bus, m, serial);
1594         if (r < 0) {
1595                 sd_bus_call_async_cancel(bus, c->serial);
1596                 return r;
1597         }
1598
1599         return r;
1600 }
1601
1602 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t serial) {
1603         struct reply_callback *c;
1604
1605         assert_return(bus, -EINVAL);
1606         assert_return(serial != 0, -EINVAL);
1607         assert_return(!bus_pid_changed(bus), -ECHILD);
1608
1609         c = hashmap_remove(bus->reply_callbacks, &serial);
1610         if (!c)
1611                 return 0;
1612
1613         if (c->timeout != 0)
1614                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1615
1616         free(c);
1617         return 1;
1618 }
1619
1620 int bus_ensure_running(sd_bus *bus) {
1621         int r;
1622
1623         assert(bus);
1624
1625         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1626                 return -ENOTCONN;
1627         if (bus->state == BUS_RUNNING)
1628                 return 1;
1629
1630         for (;;) {
1631                 r = sd_bus_process(bus, NULL);
1632                 if (r < 0)
1633                         return r;
1634                 if (bus->state == BUS_RUNNING)
1635                         return 1;
1636                 if (r > 0)
1637                         continue;
1638
1639                 r = sd_bus_wait(bus, (uint64_t) -1);
1640                 if (r < 0)
1641                         return r;
1642         }
1643 }
1644
1645 _public_ int sd_bus_call(
1646                 sd_bus *bus,
1647                 sd_bus_message *m,
1648                 uint64_t usec,
1649                 sd_bus_error *error,
1650                 sd_bus_message **reply) {
1651
1652         usec_t timeout;
1653         uint64_t serial;
1654         unsigned i;
1655         int r;
1656
1657         assert_return(bus, -EINVAL);
1658         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1659         assert_return(m, -EINVAL);
1660         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1661         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1662         assert_return(!bus_error_is_dirty(error), -EINVAL);
1663         assert_return(!bus_pid_changed(bus), -ECHILD);
1664
1665         r = bus_ensure_running(bus);
1666         if (r < 0)
1667                 return r;
1668
1669         i = bus->rqueue_size;
1670
1671         r = sd_bus_send(bus, m, &serial);
1672         if (r < 0)
1673                 return r;
1674
1675         timeout = calc_elapse(usec);
1676
1677         for (;;) {
1678                 usec_t left;
1679
1680                 while (i < bus->rqueue_size) {
1681                         sd_bus_message *incoming = NULL;
1682
1683                         incoming = bus->rqueue[i];
1684
1685                         if (incoming->reply_serial == serial) {
1686                                 /* Found a match! */
1687
1688                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1689                                 bus->rqueue_size--;
1690
1691                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1692
1693                                         if (reply)
1694                                                 *reply = incoming;
1695                                         else
1696                                                 sd_bus_message_unref(incoming);
1697
1698                                         return 1;
1699                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1700                                         r = sd_bus_error_copy(error, &incoming->error);
1701                                 else
1702                                         r = -EIO;
1703
1704                                 sd_bus_message_unref(incoming);
1705                                 return r;
1706
1707                         } else if (incoming->header->serial == serial &&
1708                                    bus->unique_name &&
1709                                    incoming->sender &&
1710                                    streq(bus->unique_name, incoming->sender)) {
1711
1712                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1713                                 bus->rqueue_size--;
1714
1715                                 /* Our own message? Somebody is trying
1716                                  * to send its own client a message,
1717                                  * let's not dead-lock, let's fail
1718                                  * immediately. */
1719
1720                                 sd_bus_message_unref(incoming);
1721                                 return -ELOOP;
1722                         }
1723
1724                         /* Try to read more, right-away */
1725                         i++;
1726                 }
1727
1728                 r = bus_read_message(bus);
1729                 if (r < 0) {
1730                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1731                                 bus_enter_closing(bus);
1732
1733                         return r;
1734                 }
1735                 if (r > 0)
1736                         continue;
1737
1738                 if (timeout > 0) {
1739                         usec_t n;
1740
1741                         n = now(CLOCK_MONOTONIC);
1742                         if (n >= timeout)
1743                                 return -ETIMEDOUT;
1744
1745                         left = timeout - n;
1746                 } else
1747                         left = (uint64_t) -1;
1748
1749                 r = bus_poll(bus, true, left);
1750                 if (r < 0)
1751                         return r;
1752
1753                 r = dispatch_wqueue(bus);
1754                 if (r < 0) {
1755                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
1756                                 bus_enter_closing(bus);
1757
1758                         return r;
1759                 }
1760         }
1761 }
1762
1763 _public_ int sd_bus_get_fd(sd_bus *bus) {
1764
1765         assert_return(bus, -EINVAL);
1766         assert_return(bus->input_fd == bus->output_fd, -EPERM);
1767         assert_return(!bus_pid_changed(bus), -ECHILD);
1768
1769         return bus->input_fd;
1770 }
1771
1772 _public_ int sd_bus_get_events(sd_bus *bus) {
1773         int flags = 0;
1774
1775         assert_return(bus, -EINVAL);
1776         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1777         assert_return(!bus_pid_changed(bus), -ECHILD);
1778
1779         if (bus->state == BUS_OPENING)
1780                 flags |= POLLOUT;
1781         else if (bus->state == BUS_AUTHENTICATING) {
1782
1783                 if (bus_socket_auth_needs_write(bus))
1784                         flags |= POLLOUT;
1785
1786                 flags |= POLLIN;
1787
1788         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1789                 if (bus->rqueue_size <= 0)
1790                         flags |= POLLIN;
1791                 if (bus->wqueue_size > 0)
1792                         flags |= POLLOUT;
1793         }
1794
1795         return flags;
1796 }
1797
1798 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1799         struct reply_callback *c;
1800
1801         assert_return(bus, -EINVAL);
1802         assert_return(timeout_usec, -EINVAL);
1803         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1804         assert_return(!bus_pid_changed(bus), -ECHILD);
1805
1806         if (bus->state == BUS_CLOSING) {
1807                 *timeout_usec = 0;
1808                 return 1;
1809         }
1810
1811         if (bus->state == BUS_AUTHENTICATING) {
1812                 *timeout_usec = bus->auth_timeout;
1813                 return 1;
1814         }
1815
1816         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1817                 *timeout_usec = (uint64_t) -1;
1818                 return 0;
1819         }
1820
1821         if (bus->rqueue_size > 0) {
1822                 *timeout_usec = 0;
1823                 return 1;
1824         }
1825
1826         c = prioq_peek(bus->reply_callbacks_prioq);
1827         if (!c) {
1828                 *timeout_usec = (uint64_t) -1;
1829                 return 0;
1830         }
1831
1832         *timeout_usec = c->timeout;
1833         return 1;
1834 }
1835
1836 static int process_timeout(sd_bus *bus) {
1837         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1838         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1839         struct reply_callback *c;
1840         usec_t n;
1841         int r;
1842
1843         assert(bus);
1844
1845         c = prioq_peek(bus->reply_callbacks_prioq);
1846         if (!c)
1847                 return 0;
1848
1849         n = now(CLOCK_MONOTONIC);
1850         if (c->timeout > n)
1851                 return 0;
1852
1853         r = bus_message_new_synthetic_error(
1854                         bus,
1855                         c->serial,
1856                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
1857                         &m);
1858         if (r < 0)
1859                 return r;
1860
1861         m->sender = "org.freedesktop.DBus";
1862
1863         r = bus_seal_synthetic_message(bus, m);
1864         if (r < 0)
1865                 return r;
1866
1867         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1868         hashmap_remove(bus->reply_callbacks, &c->serial);
1869
1870         bus->current = m;
1871         bus->iteration_counter ++;
1872
1873         r = c->callback(bus, m, c->userdata, &error_buffer);
1874         r = bus_maybe_reply_error(m, r, &error_buffer);
1875         free(c);
1876
1877         bus->current = NULL;
1878
1879         return r;
1880 }
1881
1882 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1883         assert(bus);
1884         assert(m);
1885
1886         if (bus->state != BUS_HELLO)
1887                 return 0;
1888
1889         /* Let's make sure the first message on the bus is the HELLO
1890          * reply. But note that we don't actually parse the message
1891          * here (we leave that to the usual handling), we just verify
1892          * we don't let any earlier msg through. */
1893
1894         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1895             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1896                 return -EIO;
1897
1898         if (m->reply_serial != bus->hello_serial)
1899                 return -EIO;
1900
1901         return 0;
1902 }
1903
1904 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1905         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1906         struct reply_callback *c;
1907         int r;
1908
1909         assert(bus);
1910         assert(m);
1911
1912         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1913             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1914                 return 0;
1915
1916         c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1917         if (!c)
1918                 return 0;
1919
1920         if (c->timeout != 0)
1921                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1922
1923         r = sd_bus_message_rewind(m, true);
1924         if (r < 0)
1925                 return r;
1926
1927         r = c->callback(bus, m, c->userdata, &error_buffer);
1928         r = bus_maybe_reply_error(m, r, &error_buffer);
1929         free(c);
1930
1931         return r;
1932 }
1933
1934 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1935         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1936         struct filter_callback *l;
1937         int r;
1938
1939         assert(bus);
1940         assert(m);
1941
1942         do {
1943                 bus->filter_callbacks_modified = false;
1944
1945                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1946
1947                         if (bus->filter_callbacks_modified)
1948                                 break;
1949
1950                         /* Don't run this more than once per iteration */
1951                         if (l->last_iteration == bus->iteration_counter)
1952                                 continue;
1953
1954                         l->last_iteration = bus->iteration_counter;
1955
1956                         r = sd_bus_message_rewind(m, true);
1957                         if (r < 0)
1958                                 return r;
1959
1960                         r = l->callback(bus, m, l->userdata, &error_buffer);
1961                         r = bus_maybe_reply_error(m, r, &error_buffer);
1962                         if (r != 0)
1963                                 return r;
1964
1965                 }
1966
1967         } while (bus->filter_callbacks_modified);
1968
1969         return 0;
1970 }
1971
1972 static int process_match(sd_bus *bus, sd_bus_message *m) {
1973         int r;
1974
1975         assert(bus);
1976         assert(m);
1977
1978         do {
1979                 bus->match_callbacks_modified = false;
1980
1981                 r = bus_match_run(bus, &bus->match_callbacks, m);
1982                 if (r != 0)
1983                         return r;
1984
1985         } while (bus->match_callbacks_modified);
1986
1987         return 0;
1988 }
1989
1990 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1991         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1992         int r;
1993
1994         assert(bus);
1995         assert(m);
1996
1997         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
1998                 return 0;
1999
2000         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2001                 return 0;
2002
2003         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2004                 return 1;
2005
2006         if (streq_ptr(m->member, "Ping"))
2007                 r = sd_bus_message_new_method_return(m, &reply);
2008         else if (streq_ptr(m->member, "GetMachineId")) {
2009                 sd_id128_t id;
2010                 char sid[33];
2011
2012                 r = sd_id128_get_machine(&id);
2013                 if (r < 0)
2014                         return r;
2015
2016                 r = sd_bus_message_new_method_return(m, &reply);
2017                 if (r < 0)
2018                         return r;
2019
2020                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2021         } else {
2022                 r = sd_bus_message_new_method_errorf(
2023                                 m, &reply,
2024                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2025                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2026         }
2027
2028         if (r < 0)
2029                 return r;
2030
2031         r = sd_bus_send(bus, reply, NULL);
2032         if (r < 0)
2033                 return r;
2034
2035         return 1;
2036 }
2037
2038 static int process_message(sd_bus *bus, sd_bus_message *m) {
2039         int r;
2040
2041         assert(bus);
2042         assert(m);
2043
2044         bus->current = m;
2045         bus->iteration_counter++;
2046
2047         log_debug("Got message sender=%s object=%s interface=%s member=%s",
2048                   strna(sd_bus_message_get_sender(m)),
2049                   strna(sd_bus_message_get_path(m)),
2050                   strna(sd_bus_message_get_interface(m)),
2051                   strna(sd_bus_message_get_member(m)));
2052
2053         r = process_hello(bus, m);
2054         if (r != 0)
2055                 goto finish;
2056
2057         r = process_reply(bus, m);
2058         if (r != 0)
2059                 goto finish;
2060
2061         r = process_filter(bus, m);
2062         if (r != 0)
2063                 goto finish;
2064
2065         r = process_match(bus, m);
2066         if (r != 0)
2067                 goto finish;
2068
2069         r = process_builtin(bus, m);
2070         if (r != 0)
2071                 goto finish;
2072
2073         r = bus_process_object(bus, m);
2074
2075 finish:
2076         bus->current = NULL;
2077         return r;
2078 }
2079
2080 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2081         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2082         int r;
2083
2084         assert(bus);
2085         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2086
2087         r = process_timeout(bus);
2088         if (r != 0)
2089                 goto null_message;
2090
2091         r = dispatch_wqueue(bus);
2092         if (r != 0)
2093                 goto null_message;
2094
2095         r = dispatch_rqueue(bus, &m);
2096         if (r < 0)
2097                 return r;
2098         if (!m)
2099                 goto null_message;
2100
2101         r = process_message(bus, m);
2102         if (r != 0)
2103                 goto null_message;
2104
2105         if (ret) {
2106                 r = sd_bus_message_rewind(m, true);
2107                 if (r < 0)
2108                         return r;
2109
2110                 *ret = m;
2111                 m = NULL;
2112                 return 1;
2113         }
2114
2115         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2116
2117                 r = sd_bus_reply_method_errorf(
2118                                 m,
2119                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2120                                 "Unknown object '%s'.", m->path);
2121                 if (r < 0)
2122                         return r;
2123         }
2124
2125         return 1;
2126
2127 null_message:
2128         if (r >= 0 && ret)
2129                 *ret = NULL;
2130
2131         return r;
2132 }
2133
2134 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2135         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2136         struct reply_callback *c;
2137         int r;
2138
2139         assert(bus);
2140         assert(bus->state == BUS_CLOSING);
2141
2142         c = hashmap_first(bus->reply_callbacks);
2143         if (c) {
2144                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2145
2146                 /* First, fail all outstanding method calls */
2147                 r = bus_message_new_synthetic_error(
2148                                 bus,
2149                                 c->serial,
2150                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2151                                 &m);
2152                 if (r < 0)
2153                         return r;
2154
2155                 r = bus_seal_synthetic_message(bus, m);
2156                 if (r < 0)
2157                         return r;
2158
2159                 if (c->timeout != 0)
2160                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2161
2162                 hashmap_remove(bus->reply_callbacks, &c->serial);
2163
2164                 bus->current = m;
2165                 bus->iteration_counter++;
2166
2167                 r = c->callback(bus, m, c->userdata, &error_buffer);
2168                 r = bus_maybe_reply_error(m, r, &error_buffer);
2169                 free(c);
2170
2171                 goto finish;
2172         }
2173
2174         /* Then, synthesize a Disconnected message */
2175         r = sd_bus_message_new_signal(
2176                         bus,
2177                         "/org/freedesktop/DBus/Local",
2178                         "org.freedesktop.DBus.Local",
2179                         "Disconnected",
2180                         &m);
2181         if (r < 0)
2182                 return r;
2183
2184         m->sender = "org.freedesktop.DBus.Local";
2185
2186         r = bus_seal_synthetic_message(bus, m);
2187         if (r < 0)
2188                 return r;
2189
2190         sd_bus_close(bus);
2191
2192         bus->current = m;
2193         bus->iteration_counter++;
2194
2195         r = process_filter(bus, m);
2196         if (r != 0)
2197                 goto finish;
2198
2199         r = process_match(bus, m);
2200         if (r != 0)
2201                 goto finish;
2202
2203         if (ret) {
2204                 *ret = m;
2205                 m = NULL;
2206         }
2207
2208         r = 1;
2209
2210 finish:
2211         bus->current = NULL;
2212         return r;
2213 }
2214
2215 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2216         BUS_DONT_DESTROY(bus);
2217         int r;
2218
2219         /* Returns 0 when we didn't do anything. This should cause the
2220          * caller to invoke sd_bus_wait() before returning the next
2221          * time. Returns > 0 when we did something, which possibly
2222          * means *ret is filled in with an unprocessed message. */
2223
2224         assert_return(bus, -EINVAL);
2225         assert_return(!bus_pid_changed(bus), -ECHILD);
2226
2227         /* We don't allow recursively invoking sd_bus_process(). */
2228         assert_return(!bus->current, -EBUSY);
2229
2230         switch (bus->state) {
2231
2232         case BUS_UNSET:
2233         case BUS_CLOSED:
2234                 return -ENOTCONN;
2235
2236         case BUS_OPENING:
2237                 r = bus_socket_process_opening(bus);
2238                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2239                         bus_enter_closing(bus);
2240                         r = 1;
2241                 } else if (r < 0)
2242                         return r;
2243                 if (ret)
2244                         *ret = NULL;
2245                 return r;
2246
2247         case BUS_AUTHENTICATING:
2248                 r = bus_socket_process_authenticating(bus);
2249                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2250                         bus_enter_closing(bus);
2251                         r = 1;
2252                 } else if (r < 0)
2253                         return r;
2254
2255                 if (ret)
2256                         *ret = NULL;
2257
2258                 return r;
2259
2260         case BUS_RUNNING:
2261         case BUS_HELLO:
2262                 r = process_running(bus, ret);
2263                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2264                         bus_enter_closing(bus);
2265                         r = 1;
2266
2267                         if (ret)
2268                                 *ret = NULL;
2269                 }
2270
2271                 return r;
2272
2273         case BUS_CLOSING:
2274                 return process_closing(bus, ret);
2275         }
2276
2277         assert_not_reached("Unknown state");
2278 }
2279
2280 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2281         struct pollfd p[2] = {};
2282         int r, e, n;
2283         struct timespec ts;
2284         usec_t m = (usec_t) -1;
2285
2286         assert(bus);
2287
2288         if (bus->state == BUS_CLOSING)
2289                 return 1;
2290
2291         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2292
2293         e = sd_bus_get_events(bus);
2294         if (e < 0)
2295                 return e;
2296
2297         if (need_more)
2298                 /* The caller really needs some more data, he doesn't
2299                  * care about what's already read, or any timeouts
2300                  * except its own.*/
2301                 e |= POLLIN;
2302         else {
2303                 usec_t until;
2304                 /* The caller wants to process if there's something to
2305                  * process, but doesn't care otherwise */
2306
2307                 r = sd_bus_get_timeout(bus, &until);
2308                 if (r < 0)
2309                         return r;
2310                 if (r > 0) {
2311                         usec_t nw;
2312                         nw = now(CLOCK_MONOTONIC);
2313                         m = until > nw ? until - nw : 0;
2314                 }
2315         }
2316
2317         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2318                 m = timeout_usec;
2319
2320         p[0].fd = bus->input_fd;
2321         if (bus->output_fd == bus->input_fd) {
2322                 p[0].events = e;
2323                 n = 1;
2324         } else {
2325                 p[0].events = e & POLLIN;
2326                 p[1].fd = bus->output_fd;
2327                 p[1].events = e & POLLOUT;
2328                 n = 2;
2329         }
2330
2331         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2332         if (r < 0)
2333                 return -errno;
2334
2335         return r > 0 ? 1 : 0;
2336 }
2337
2338 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2339
2340         assert_return(bus, -EINVAL);
2341         assert_return(!bus_pid_changed(bus), -ECHILD);
2342
2343         if (bus->state == BUS_CLOSING)
2344                 return 0;
2345
2346         assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2347
2348         if (bus->rqueue_size > 0)
2349                 return 0;
2350
2351         return bus_poll(bus, false, timeout_usec);
2352 }
2353
2354 _public_ int sd_bus_flush(sd_bus *bus) {
2355         int r;
2356
2357         assert_return(bus, -EINVAL);
2358         assert_return(!bus_pid_changed(bus), -ECHILD);
2359
2360         if (bus->state == BUS_CLOSING)
2361                 return 0;
2362
2363         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2364
2365         r = bus_ensure_running(bus);
2366         if (r < 0)
2367                 return r;
2368
2369         if (bus->wqueue_size <= 0)
2370                 return 0;
2371
2372         for (;;) {
2373                 r = dispatch_wqueue(bus);
2374                 if (r < 0) {
2375                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
2376                                 bus_enter_closing(bus);
2377
2378                         return r;
2379                 }
2380
2381                 if (bus->wqueue_size <= 0)
2382                         return 0;
2383
2384                 r = bus_poll(bus, false, (uint64_t) -1);
2385                 if (r < 0)
2386                         return r;
2387         }
2388 }
2389
2390 _public_ int sd_bus_add_filter(sd_bus *bus,
2391                                sd_bus_message_handler_t callback,
2392                                void *userdata) {
2393
2394         struct filter_callback *f;
2395
2396         assert_return(bus, -EINVAL);
2397         assert_return(callback, -EINVAL);
2398         assert_return(!bus_pid_changed(bus), -ECHILD);
2399
2400         f = new0(struct filter_callback, 1);
2401         if (!f)
2402                 return -ENOMEM;
2403         f->callback = callback;
2404         f->userdata = userdata;
2405
2406         bus->filter_callbacks_modified = true;
2407         LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2408         return 0;
2409 }
2410
2411 _public_ int sd_bus_remove_filter(sd_bus *bus,
2412                                   sd_bus_message_handler_t callback,
2413                                   void *userdata) {
2414
2415         struct filter_callback *f;
2416
2417         assert_return(bus, -EINVAL);
2418         assert_return(callback, -EINVAL);
2419         assert_return(!bus_pid_changed(bus), -ECHILD);
2420
2421         LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2422                 if (f->callback == callback && f->userdata == userdata) {
2423                         bus->filter_callbacks_modified = true;
2424                         LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2425                         free(f);
2426                         return 1;
2427                 }
2428         }
2429
2430         return 0;
2431 }
2432
2433 _public_ int sd_bus_add_match(sd_bus *bus,
2434                               const char *match,
2435                               sd_bus_message_handler_t callback,
2436                               void *userdata) {
2437
2438         struct bus_match_component *components = NULL;
2439         unsigned n_components = 0;
2440         uint64_t cookie = 0;
2441         int r = 0;
2442
2443         assert_return(bus, -EINVAL);
2444         assert_return(match, -EINVAL);
2445         assert_return(!bus_pid_changed(bus), -ECHILD);
2446
2447         r = bus_match_parse(match, &components, &n_components);
2448         if (r < 0)
2449                 goto finish;
2450
2451         if (bus->bus_client) {
2452                 cookie = ++bus->match_cookie;
2453
2454                 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2455                 if (r < 0)
2456                         goto finish;
2457         }
2458
2459         bus->match_callbacks_modified = true;
2460         r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2461         if (r < 0) {
2462                 if (bus->bus_client)
2463                         bus_remove_match_internal(bus, match, cookie);
2464         }
2465
2466 finish:
2467         bus_match_parse_free(components, n_components);
2468         return r;
2469 }
2470
2471 _public_ int sd_bus_remove_match(sd_bus *bus,
2472                                  const char *match,
2473                                  sd_bus_message_handler_t callback,
2474                                  void *userdata) {
2475
2476         struct bus_match_component *components = NULL;
2477         unsigned n_components = 0;
2478         int r = 0, q = 0;
2479         uint64_t cookie = 0;
2480
2481         assert_return(bus, -EINVAL);
2482         assert_return(match, -EINVAL);
2483         assert_return(!bus_pid_changed(bus), -ECHILD);
2484
2485         r = bus_match_parse(match, &components, &n_components);
2486         if (r < 0)
2487                 return r;
2488
2489         bus->match_callbacks_modified = true;
2490         r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2491
2492         if (bus->bus_client)
2493                 q = bus_remove_match_internal(bus, match, cookie);
2494
2495         bus_match_parse_free(components, n_components);
2496
2497         return r < 0 ? r : q;
2498 }
2499
2500 bool bus_pid_changed(sd_bus *bus) {
2501         assert(bus);
2502
2503         /* We don't support people creating a bus connection and
2504          * keeping it around over a fork(). Let's complain. */
2505
2506         return bus->original_pid != getpid();
2507 }
2508
2509 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2510         sd_bus *bus = userdata;
2511         int r;
2512
2513         assert(bus);
2514
2515         r = sd_bus_process(bus, NULL);
2516         if (r < 0)
2517                 return r;
2518
2519         return 1;
2520 }
2521
2522 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2523         sd_bus *bus = userdata;
2524         int r;
2525
2526         assert(bus);
2527
2528         r = sd_bus_process(bus, NULL);
2529         if (r < 0)
2530                 return r;
2531
2532         return 1;
2533 }
2534
2535 static int prepare_callback(sd_event_source *s, void *userdata) {
2536         sd_bus *bus = userdata;
2537         int r, e;
2538         usec_t until;
2539
2540         assert(s);
2541         assert(bus);
2542
2543         e = sd_bus_get_events(bus);
2544         if (e < 0)
2545                 return e;
2546
2547         if (bus->output_fd != bus->input_fd) {
2548
2549                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2550                 if (r < 0)
2551                         return r;
2552
2553                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2554                 if (r < 0)
2555                         return r;
2556         } else {
2557                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2558                 if (r < 0)
2559                         return r;
2560         }
2561
2562         r = sd_bus_get_timeout(bus, &until);
2563         if (r < 0)
2564                 return r;
2565         if (r > 0) {
2566                 int j;
2567
2568                 j = sd_event_source_set_time(bus->time_event_source, until);
2569                 if (j < 0)
2570                         return j;
2571         }
2572
2573         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2574         if (r < 0)
2575                 return r;
2576
2577         return 1;
2578 }
2579
2580 static int quit_callback(sd_event_source *event, void *userdata) {
2581         sd_bus *bus = userdata;
2582
2583         assert(event);
2584
2585         sd_bus_flush(bus);
2586
2587         return 1;
2588 }
2589
2590 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2591         int r;
2592
2593         assert_return(bus, -EINVAL);
2594         assert_return(!bus->event, -EBUSY);
2595
2596         assert(!bus->input_io_event_source);
2597         assert(!bus->output_io_event_source);
2598         assert(!bus->time_event_source);
2599
2600         if (event)
2601                 bus->event = sd_event_ref(event);
2602         else  {
2603                 r = sd_event_default(&bus->event);
2604                 if (r < 0)
2605                         return r;
2606         }
2607
2608         r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2609         if (r < 0)
2610                 goto fail;
2611
2612         r = sd_event_source_set_priority(bus->input_io_event_source, priority);
2613         if (r < 0)
2614                 goto fail;
2615
2616         if (bus->output_fd != bus->input_fd) {
2617                 r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2618                 if (r < 0)
2619                         goto fail;
2620
2621                 r = sd_event_source_set_priority(bus->output_io_event_source, priority);
2622                 if (r < 0)
2623                         goto fail;
2624         }
2625
2626         r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2627         if (r < 0)
2628                 goto fail;
2629
2630         r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2631         if (r < 0)
2632                 goto fail;
2633
2634         r = sd_event_source_set_priority(bus->time_event_source, priority);
2635         if (r < 0)
2636                 goto fail;
2637
2638         r = sd_event_add_quit(bus->event, quit_callback, bus, &bus->quit_event_source);
2639         if (r < 0)
2640                 goto fail;
2641
2642         return 0;
2643
2644 fail:
2645         sd_bus_detach_event(bus);
2646         return r;
2647 }
2648
2649 _public_ int sd_bus_detach_event(sd_bus *bus) {
2650         assert_return(bus, -EINVAL);
2651
2652         if (!bus->event)
2653                 return 0;
2654
2655         if (bus->input_io_event_source) {
2656                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2657                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2658         }
2659
2660         if (bus->output_io_event_source) {
2661                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2662                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2663         }
2664
2665         if (bus->time_event_source) {
2666                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2667                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2668         }
2669
2670         if (bus->quit_event_source) {
2671                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2672                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2673         }
2674
2675         if (bus->event)
2676                 bus->event = sd_event_unref(bus->event);
2677
2678         return 1;
2679 }
2680
2681 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2682         assert_return(bus, NULL);
2683
2684         return bus->event;
2685 }
2686
2687 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2688         assert_return(bus, NULL);
2689
2690         return bus->current;
2691 }
2692
2693 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2694         sd_bus *b = NULL;
2695         int r;
2696
2697         assert(bus_open);
2698         assert(default_bus);
2699
2700         if (!ret)
2701                 return !!*default_bus;
2702
2703         if (*default_bus) {
2704                 *ret = sd_bus_ref(*default_bus);
2705                 return 0;
2706         }
2707
2708         r = bus_open(&b);
2709         if (r < 0)
2710                 return r;
2711
2712         b->default_bus_ptr = default_bus;
2713         b->tid = gettid();
2714         *default_bus = b;
2715
2716         *ret = b;
2717         return 1;
2718 }
2719
2720 _public_ int sd_bus_default_system(sd_bus **ret) {
2721         static __thread sd_bus *default_system_bus = NULL;
2722
2723         return bus_default(sd_bus_open_system, &default_system_bus, ret);
2724 }
2725
2726 _public_ int sd_bus_default_user(sd_bus **ret) {
2727         static __thread sd_bus *default_user_bus = NULL;
2728
2729         return bus_default(sd_bus_open_user, &default_user_bus, ret);
2730 }
2731
2732 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2733         assert_return(b, -EINVAL);
2734         assert_return(tid, -EINVAL);
2735         assert_return(!bus_pid_changed(b), -ECHILD);
2736
2737         if (b->tid != 0) {
2738                 *tid = b->tid;
2739                 return 0;
2740         }
2741
2742         if (b->event)
2743                 return sd_event_get_tid(b->event, tid);
2744
2745         return -ENXIO;
2746 }
2747
2748 _public_ char *sd_bus_label_escape(const char *s) {
2749         char *r, *t;
2750         const char *f;
2751
2752         assert_return(s, NULL);
2753
2754         /* Escapes all chars that D-Bus' object path cannot deal
2755          * with. Can be reversed with bus_path_unescape(). We special
2756          * case the empty string. */
2757
2758         if (*s == 0)
2759                 return strdup("_");
2760
2761         r = new(char, strlen(s)*3 + 1);
2762         if (!r)
2763                 return NULL;
2764
2765         for (f = s, t = r; *f; f++) {
2766
2767                 /* Escape everything that is not a-zA-Z0-9. We also
2768                  * escape 0-9 if it's the first character */
2769
2770                 if (!(*f >= 'A' && *f <= 'Z') &&
2771                     !(*f >= 'a' && *f <= 'z') &&
2772                     !(f > s && *f >= '0' && *f <= '9')) {
2773                         *(t++) = '_';
2774                         *(t++) = hexchar(*f >> 4);
2775                         *(t++) = hexchar(*f);
2776                 } else
2777                         *(t++) = *f;
2778         }
2779
2780         *t = 0;
2781
2782         return r;
2783 }
2784
2785 _public_ char *sd_bus_label_unescape(const char *f) {
2786         char *r, *t;
2787
2788         assert_return(f, NULL);
2789
2790         /* Special case for the empty string */
2791         if (streq(f, "_"))
2792                 return strdup("");
2793
2794         r = new(char, strlen(f) + 1);
2795         if (!r)
2796                 return NULL;
2797
2798         for (t = r; *f; f++) {
2799
2800                 if (*f == '_') {
2801                         int a, b;
2802
2803                         if ((a = unhexchar(f[1])) < 0 ||
2804                             (b = unhexchar(f[2])) < 0) {
2805                                 /* Invalid escape code, let's take it literal then */
2806                                 *(t++) = '_';
2807                         } else {
2808                                 *(t++) = (char) ((a << 4) | b);
2809                                 f += 2;
2810                         }
2811                 } else
2812                         *(t++) = *f;
2813         }
2814
2815         *t = 0;
2816
2817         return r;
2818 }
2819
2820 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
2821         sd_bus_creds *c;
2822         pid_t pid = 0;
2823         int r;
2824
2825         assert_return(bus, -EINVAL);
2826         assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
2827         assert_return(ret, -EINVAL);
2828         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2829         assert_return(!bus_pid_changed(bus), -ECHILD);
2830         assert_return(!bus->is_kernel, -ENOTSUP);
2831
2832         if (!bus->ucred_valid && !isempty(bus->label))
2833                 return -ENODATA;
2834
2835         c = bus_creds_new();
2836         if (!c)
2837                 return -ENOMEM;
2838
2839         if (bus->ucred_valid) {
2840                 pid = c->pid = bus->ucred.pid;
2841                 c->uid = bus->ucred.uid;
2842                 c->gid = bus->ucred.gid;
2843
2844                 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
2845         }
2846
2847         if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
2848                 c->label = strdup(bus->label);
2849                 if (!c->label) {
2850                         sd_bus_creds_unref(c);
2851                         return -ENOMEM;
2852                 }
2853
2854                 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
2855         }
2856
2857         r = bus_creds_add_more(c, mask, pid, 0);
2858         if (r < 0)
2859                 return r;
2860
2861         *ret = c;
2862         return 0;
2863 }