src/libsystemd-bus/sd-bus.c

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