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