src/libsystemd-bus/sd-bus.c

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