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