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