src/libsystemd-bus/sd-bus.c

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