src/libsystemd-bus/sd-bus.c

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