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 type=%s sender=%s destination=%s object=%s interface=%s member=%s serial=%lu reply_serial=%lu error=%s",
2107                   bus_message_type_to_string(m->header->type),
2108                   strna(sd_bus_message_get_sender(m)),
2109                   strna(sd_bus_message_get_destination(m)),
2110                   strna(sd_bus_message_get_path(m)),
2111                   strna(sd_bus_message_get_interface(m)),
2112                   strna(sd_bus_message_get_member(m)),
2113                   (unsigned long) m->header->serial,
2114                   (unsigned long) m->reply_serial,
2115                   strna(m->error.message));
2116
2117         r = process_hello(bus, m);
2118         if (r != 0)
2119                 goto finish;
2120
2121         r = process_reply(bus, m);
2122         if (r != 0)
2123                 goto finish;
2124
2125         r = process_filter(bus, m);
2126         if (r != 0)
2127                 goto finish;
2128
2129         r = process_match(bus, m);
2130         if (r != 0)
2131                 goto finish;
2132
2133         r = process_builtin(bus, m);
2134         if (r != 0)
2135                 goto finish;
2136
2137         r = bus_process_object(bus, m);
2138
2139 finish:
2140         bus->current = NULL;
2141         return r;
2142 }
2143
2144 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2145         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2146         int r;
2147
2148         assert(bus);
2149         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2150
2151         r = process_timeout(bus);
2152         if (r != 0)
2153                 goto null_message;
2154
2155         r = dispatch_wqueue(bus);
2156         if (r != 0)
2157                 goto null_message;
2158
2159         r = dispatch_rqueue(bus, &m);
2160         if (r < 0)
2161                 return r;
2162         if (!m)
2163                 goto null_message;
2164
2165         r = process_message(bus, m);
2166         if (r != 0)
2167                 goto null_message;
2168
2169         if (ret) {
2170                 r = sd_bus_message_rewind(m, true);
2171                 if (r < 0)
2172                         return r;
2173
2174                 *ret = m;
2175                 m = NULL;
2176                 return 1;
2177         }
2178
2179         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2180
2181                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2182                           strna(sd_bus_message_get_sender(m)),
2183                           strna(sd_bus_message_get_path(m)),
2184                           strna(sd_bus_message_get_interface(m)),
2185                           strna(sd_bus_message_get_member(m)));
2186
2187                 r = sd_bus_reply_method_errorf(
2188                                 m,
2189                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2190                                 "Unknown object '%s'.", m->path);
2191                 if (r < 0)
2192                         return r;
2193         }
2194
2195         return 1;
2196
2197 null_message:
2198         if (r >= 0 && ret)
2199                 *ret = NULL;
2200
2201         return r;
2202 }
2203
2204 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2205         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2206         struct reply_callback *c;
2207         int r;
2208
2209         assert(bus);
2210         assert(bus->state == BUS_CLOSING);
2211
2212         c = hashmap_first(bus->reply_callbacks);
2213         if (c) {
2214                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2215
2216                 /* First, fail all outstanding method calls */
2217                 r = bus_message_new_synthetic_error(
2218                                 bus,
2219                                 c->serial,
2220                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2221                                 &m);
2222                 if (r < 0)
2223                         return r;
2224
2225                 r = bus_seal_synthetic_message(bus, m);
2226                 if (r < 0)
2227                         return r;
2228
2229                 if (c->timeout != 0)
2230                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2231
2232                 hashmap_remove(bus->reply_callbacks, &c->serial);
2233
2234                 bus->current = m;
2235                 bus->iteration_counter++;
2236
2237                 r = c->callback(bus, m, c->userdata, &error_buffer);
2238                 r = bus_maybe_reply_error(m, r, &error_buffer);
2239                 free(c);
2240
2241                 goto finish;
2242         }
2243
2244         /* Then, synthesize a Disconnected message */
2245         r = sd_bus_message_new_signal(
2246                         bus,
2247                         "/org/freedesktop/DBus/Local",
2248                         "org.freedesktop.DBus.Local",
2249                         "Disconnected",
2250                         &m);
2251         if (r < 0)
2252                 return r;
2253
2254         m->sender = "org.freedesktop.DBus.Local";
2255
2256         r = bus_seal_synthetic_message(bus, m);
2257         if (r < 0)
2258                 return r;
2259
2260         sd_bus_close(bus);
2261
2262         bus->current = m;
2263         bus->iteration_counter++;
2264
2265         r = process_filter(bus, m);
2266         if (r != 0)
2267                 goto finish;
2268
2269         r = process_match(bus, m);
2270         if (r != 0)
2271                 goto finish;
2272
2273         if (ret) {
2274                 *ret = m;
2275                 m = NULL;
2276         }
2277
2278         r = 1;
2279
2280 finish:
2281         bus->current = NULL;
2282         return r;
2283 }
2284
2285 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2286         BUS_DONT_DESTROY(bus);
2287         int r;
2288
2289         /* Returns 0 when we didn't do anything. This should cause the
2290          * caller to invoke sd_bus_wait() before returning the next
2291          * time. Returns > 0 when we did something, which possibly
2292          * means *ret is filled in with an unprocessed message. */
2293
2294         assert_return(bus, -EINVAL);
2295         assert_return(!bus_pid_changed(bus), -ECHILD);
2296
2297         /* We don't allow recursively invoking sd_bus_process(). */
2298         assert_return(!bus->current, -EBUSY);
2299
2300         switch (bus->state) {
2301
2302         case BUS_UNSET:
2303                 return -ENOTCONN;
2304
2305         case BUS_CLOSED:
2306                 return -ECONNRESET;
2307
2308         case BUS_OPENING:
2309                 r = bus_socket_process_opening(bus);
2310                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2311                         bus_enter_closing(bus);
2312                         r = 1;
2313                 } else if (r < 0)
2314                         return r;
2315                 if (ret)
2316                         *ret = NULL;
2317                 return r;
2318
2319         case BUS_AUTHENTICATING:
2320                 r = bus_socket_process_authenticating(bus);
2321                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2322                         bus_enter_closing(bus);
2323                         r = 1;
2324                 } else if (r < 0)
2325                         return r;
2326
2327                 if (ret)
2328                         *ret = NULL;
2329
2330                 return r;
2331
2332         case BUS_RUNNING:
2333         case BUS_HELLO:
2334                 r = process_running(bus, ret);
2335                 if (r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2336                         bus_enter_closing(bus);
2337                         r = 1;
2338
2339                         if (ret)
2340                                 *ret = NULL;
2341                 }
2342
2343                 return r;
2344
2345         case BUS_CLOSING:
2346                 return process_closing(bus, ret);
2347         }
2348
2349         assert_not_reached("Unknown state");
2350 }
2351
2352 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2353         struct pollfd p[2] = {};
2354         int r, e, n;
2355         struct timespec ts;
2356         usec_t m = (usec_t) -1;
2357
2358         assert(bus);
2359
2360         if (bus->state == BUS_CLOSING)
2361                 return 1;
2362
2363         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2364
2365         e = sd_bus_get_events(bus);
2366         if (e < 0)
2367                 return e;
2368
2369         if (need_more)
2370                 /* The caller really needs some more data, he doesn't
2371                  * care about what's already read, or any timeouts
2372                  * except its own.*/
2373                 e |= POLLIN;
2374         else {
2375                 usec_t until;
2376                 /* The caller wants to process if there's something to
2377                  * process, but doesn't care otherwise */
2378
2379                 r = sd_bus_get_timeout(bus, &until);
2380                 if (r < 0)
2381                         return r;
2382                 if (r > 0) {
2383                         usec_t nw;
2384                         nw = now(CLOCK_MONOTONIC);
2385                         m = until > nw ? until - nw : 0;
2386                 }
2387         }
2388
2389         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2390                 m = timeout_usec;
2391
2392         p[0].fd = bus->input_fd;
2393         if (bus->output_fd == bus->input_fd) {
2394                 p[0].events = e;
2395                 n = 1;
2396         } else {
2397                 p[0].events = e & POLLIN;
2398                 p[1].fd = bus->output_fd;
2399                 p[1].events = e & POLLOUT;
2400                 n = 2;
2401         }
2402
2403         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2404         if (r < 0)
2405                 return -errno;
2406
2407         return r > 0 ? 1 : 0;
2408 }
2409
2410 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2411
2412         assert_return(bus, -EINVAL);
2413         assert_return(!bus_pid_changed(bus), -ECHILD);
2414
2415         if (bus->state == BUS_CLOSING)
2416                 return 0;
2417
2418         assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2419
2420         if (bus->rqueue_size > 0)
2421                 return 0;
2422
2423         return bus_poll(bus, false, timeout_usec);
2424 }
2425
2426 _public_ int sd_bus_flush(sd_bus *bus) {
2427         int r;
2428
2429         assert_return(bus, -EINVAL);
2430         assert_return(!bus_pid_changed(bus), -ECHILD);
2431
2432         if (bus->state == BUS_CLOSING)
2433                 return 0;
2434
2435         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2436
2437         r = bus_ensure_running(bus);
2438         if (r < 0)
2439                 return r;
2440
2441         if (bus->wqueue_size <= 0)
2442                 return 0;
2443
2444         for (;;) {
2445                 r = dispatch_wqueue(bus);
2446                 if (r < 0) {
2447                         if (r == -EPIPE || r == -ENOTCONN || r == -ESHUTDOWN)
2448                                 bus_enter_closing(bus);
2449
2450                         return r;
2451                 }
2452
2453                 if (bus->wqueue_size <= 0)
2454                         return 0;
2455
2456                 r = bus_poll(bus, false, (uint64_t) -1);
2457                 if (r < 0)
2458                         return r;
2459         }
2460 }
2461
2462 _public_ int sd_bus_add_filter(sd_bus *bus,
2463                                sd_bus_message_handler_t callback,
2464                                void *userdata) {
2465
2466         struct filter_callback *f;
2467
2468         assert_return(bus, -EINVAL);
2469         assert_return(callback, -EINVAL);
2470         assert_return(!bus_pid_changed(bus), -ECHILD);
2471
2472         f = new0(struct filter_callback, 1);
2473         if (!f)
2474                 return -ENOMEM;
2475         f->callback = callback;
2476         f->userdata = userdata;
2477
2478         bus->filter_callbacks_modified = true;
2479         LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2480         return 0;
2481 }
2482
2483 _public_ int sd_bus_remove_filter(sd_bus *bus,
2484                                   sd_bus_message_handler_t callback,
2485                                   void *userdata) {
2486
2487         struct filter_callback *f;
2488
2489         assert_return(bus, -EINVAL);
2490         assert_return(callback, -EINVAL);
2491         assert_return(!bus_pid_changed(bus), -ECHILD);
2492
2493         LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2494                 if (f->callback == callback && f->userdata == userdata) {
2495                         bus->filter_callbacks_modified = true;
2496                         LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2497                         free(f);
2498                         return 1;
2499                 }
2500         }
2501
2502         return 0;
2503 }
2504
2505 _public_ int sd_bus_add_match(sd_bus *bus,
2506                               const char *match,
2507                               sd_bus_message_handler_t callback,
2508                               void *userdata) {
2509
2510         struct bus_match_component *components = NULL;
2511         unsigned n_components = 0;
2512         uint64_t cookie = 0;
2513         int r = 0;
2514
2515         assert_return(bus, -EINVAL);
2516         assert_return(match, -EINVAL);
2517         assert_return(!bus_pid_changed(bus), -ECHILD);
2518
2519         r = bus_match_parse(match, &components, &n_components);
2520         if (r < 0)
2521                 goto finish;
2522
2523         if (bus->bus_client) {
2524                 cookie = ++bus->match_cookie;
2525
2526                 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2527                 if (r < 0)
2528                         goto finish;
2529         }
2530
2531         bus->match_callbacks_modified = true;
2532         r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2533         if (r < 0) {
2534                 if (bus->bus_client)
2535                         bus_remove_match_internal(bus, match, cookie);
2536         }
2537
2538 finish:
2539         bus_match_parse_free(components, n_components);
2540         return r;
2541 }
2542
2543 _public_ int sd_bus_remove_match(sd_bus *bus,
2544                                  const char *match,
2545                                  sd_bus_message_handler_t callback,
2546                                  void *userdata) {
2547
2548         struct bus_match_component *components = NULL;
2549         unsigned n_components = 0;
2550         int r = 0, q = 0;
2551         uint64_t cookie = 0;
2552
2553         assert_return(bus, -EINVAL);
2554         assert_return(match, -EINVAL);
2555         assert_return(!bus_pid_changed(bus), -ECHILD);
2556
2557         r = bus_match_parse(match, &components, &n_components);
2558         if (r < 0)
2559                 return r;
2560
2561         bus->match_callbacks_modified = true;
2562         r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2563
2564         if (bus->bus_client)
2565                 q = bus_remove_match_internal(bus, match, cookie);
2566
2567         bus_match_parse_free(components, n_components);
2568
2569         return r < 0 ? r : q;
2570 }
2571
2572 bool bus_pid_changed(sd_bus *bus) {
2573         assert(bus);
2574
2575         /* We don't support people creating a bus connection and
2576          * keeping it around over a fork(). Let's complain. */
2577
2578         return bus->original_pid != getpid();
2579 }
2580
2581 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2582         sd_bus *bus = userdata;
2583         int r;
2584
2585         assert(bus);
2586
2587         r = sd_bus_process(bus, NULL);
2588         if (r < 0)
2589                 return r;
2590
2591         return 1;
2592 }
2593
2594 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2595         sd_bus *bus = userdata;
2596         int r;
2597
2598         assert(bus);
2599
2600         r = sd_bus_process(bus, NULL);
2601         if (r < 0)
2602                 return r;
2603
2604         return 1;
2605 }
2606
2607 static int prepare_callback(sd_event_source *s, void *userdata) {
2608         sd_bus *bus = userdata;
2609         int r, e;
2610         usec_t until;
2611
2612         assert(s);
2613         assert(bus);
2614
2615         e = sd_bus_get_events(bus);
2616         if (e < 0)
2617                 return e;
2618
2619         if (bus->output_fd != bus->input_fd) {
2620
2621                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2622                 if (r < 0)
2623                         return r;
2624
2625                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2626                 if (r < 0)
2627                         return r;
2628         } else {
2629                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2630                 if (r < 0)
2631                         return r;
2632         }
2633
2634         r = sd_bus_get_timeout(bus, &until);
2635         if (r < 0)
2636                 return r;
2637         if (r > 0) {
2638                 int j;
2639
2640                 j = sd_event_source_set_time(bus->time_event_source, until);
2641                 if (j < 0)
2642                         return j;
2643         }
2644
2645         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2646         if (r < 0)
2647                 return r;
2648
2649         return 1;
2650 }
2651
2652 static int quit_callback(sd_event_source *event, void *userdata) {
2653         sd_bus *bus = userdata;
2654
2655         assert(event);
2656
2657         sd_bus_flush(bus);
2658
2659         return 1;
2660 }
2661
2662 static int attach_io_events(sd_bus *bus) {
2663         int r;
2664
2665         assert(bus);
2666
2667         if (bus->input_fd < 0)
2668                 return 0;
2669
2670         if (!bus->event)
2671                 return 0;
2672
2673         if (!bus->input_io_event_source) {
2674                 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2675                 if (r < 0)
2676                         return r;
2677
2678                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2679                 if (r < 0)
2680                         return r;
2681
2682                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2683         } else
2684                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2685
2686         if (r < 0)
2687                 return r;
2688
2689         if (bus->output_fd != bus->input_fd) {
2690                 assert(bus->output_fd >= 0);
2691
2692                 if (!bus->output_io_event_source) {
2693                         r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2694                         if (r < 0)
2695                                 return r;
2696
2697                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2698                 } else
2699                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2700
2701                 if (r < 0)
2702                         return r;
2703         }
2704
2705         return 0;
2706 }
2707
2708 static void detach_io_events(sd_bus *bus) {
2709         assert(bus);
2710
2711         if (bus->input_io_event_source) {
2712                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2713                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2714         }
2715
2716         if (bus->output_io_event_source) {
2717                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2718                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2719         }
2720 }
2721
2722 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2723         int r;
2724
2725         assert_return(bus, -EINVAL);
2726         assert_return(!bus->event, -EBUSY);
2727
2728         assert(!bus->input_io_event_source);
2729         assert(!bus->output_io_event_source);
2730         assert(!bus->time_event_source);
2731
2732         if (event)
2733                 bus->event = sd_event_ref(event);
2734         else  {
2735                 r = sd_event_default(&bus->event);
2736                 if (r < 0)
2737                         return r;
2738         }
2739
2740         bus->event_priority = priority;
2741
2742         r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2743         if (r < 0)
2744                 goto fail;
2745
2746         r = sd_event_source_set_priority(bus->time_event_source, priority);
2747         if (r < 0)
2748                 goto fail;
2749
2750         r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
2751         if (r < 0)
2752                 goto fail;
2753
2754         r = attach_io_events(bus);
2755         if (r < 0)
2756                 goto fail;
2757
2758         return 0;
2759
2760 fail:
2761         sd_bus_detach_event(bus);
2762         return r;
2763 }
2764
2765 _public_ int sd_bus_detach_event(sd_bus *bus) {
2766         assert_return(bus, -EINVAL);
2767
2768         if (!bus->event)
2769                 return 0;
2770
2771         detach_io_events(bus);
2772
2773         if (bus->time_event_source) {
2774                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2775                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2776         }
2777
2778         if (bus->quit_event_source) {
2779                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2780                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2781         }
2782
2783         if (bus->event)
2784                 bus->event = sd_event_unref(bus->event);
2785
2786         return 1;
2787 }
2788
2789 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2790         assert_return(bus, NULL);
2791
2792         return bus->event;
2793 }
2794
2795 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2796         assert_return(bus, NULL);
2797
2798         return bus->current;
2799 }
2800
2801 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2802         sd_bus *b = NULL;
2803         int r;
2804
2805         assert(bus_open);
2806         assert(default_bus);
2807
2808         if (!ret)
2809                 return !!*default_bus;
2810
2811         if (*default_bus) {
2812                 *ret = sd_bus_ref(*default_bus);
2813                 return 0;
2814         }
2815
2816         r = bus_open(&b);
2817         if (r < 0)
2818                 return r;
2819
2820         b->default_bus_ptr = default_bus;
2821         b->tid = gettid();
2822         *default_bus = b;
2823
2824         *ret = b;
2825         return 1;
2826 }
2827
2828 _public_ int sd_bus_default_system(sd_bus **ret) {
2829         static thread_local sd_bus *default_system_bus = NULL;
2830
2831         return bus_default(sd_bus_open_system, &default_system_bus, ret);
2832 }
2833
2834 _public_ int sd_bus_default_user(sd_bus **ret) {
2835         static thread_local sd_bus *default_user_bus = NULL;
2836
2837         return bus_default(sd_bus_open_user, &default_user_bus, ret);
2838 }
2839
2840 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2841         assert_return(b, -EINVAL);
2842         assert_return(tid, -EINVAL);
2843         assert_return(!bus_pid_changed(b), -ECHILD);
2844
2845         if (b->tid != 0) {
2846                 *tid = b->tid;
2847                 return 0;
2848         }
2849
2850         if (b->event)
2851                 return sd_event_get_tid(b->event, tid);
2852
2853         return -ENXIO;
2854 }
2855
2856 _public_ char *sd_bus_label_escape(const char *s) {
2857         char *r, *t;
2858         const char *f;
2859
2860         assert_return(s, NULL);
2861
2862         /* Escapes all chars that D-Bus' object path cannot deal
2863          * with. Can be reversed with bus_path_unescape(). We special
2864          * case the empty string. */
2865
2866         if (*s == 0)
2867                 return strdup("_");
2868
2869         r = new(char, strlen(s)*3 + 1);
2870         if (!r)
2871                 return NULL;
2872
2873         for (f = s, t = r; *f; f++) {
2874
2875                 /* Escape everything that is not a-zA-Z0-9. We also
2876                  * escape 0-9 if it's the first character */
2877
2878                 if (!(*f >= 'A' && *f <= 'Z') &&
2879                     !(*f >= 'a' && *f <= 'z') &&
2880                     !(f > s && *f >= '0' && *f <= '9')) {
2881                         *(t++) = '_';
2882                         *(t++) = hexchar(*f >> 4);
2883                         *(t++) = hexchar(*f);
2884                 } else
2885                         *(t++) = *f;
2886         }
2887
2888         *t = 0;
2889
2890         return r;
2891 }
2892
2893 _public_ char *sd_bus_label_unescape(const char *f) {
2894         char *r, *t;
2895
2896         assert_return(f, NULL);
2897
2898         /* Special case for the empty string */
2899         if (streq(f, "_"))
2900                 return strdup("");
2901
2902         r = new(char, strlen(f) + 1);
2903         if (!r)
2904                 return NULL;
2905
2906         for (t = r; *f; f++) {
2907
2908                 if (*f == '_') {
2909                         int a, b;
2910
2911                         if ((a = unhexchar(f[1])) < 0 ||
2912                             (b = unhexchar(f[2])) < 0) {
2913                                 /* Invalid escape code, let's take it literal then */
2914                                 *(t++) = '_';
2915                         } else {
2916                                 *(t++) = (char) ((a << 4) | b);
2917                                 f += 2;
2918                         }
2919                 } else
2920                         *(t++) = *f;
2921         }
2922
2923         *t = 0;
2924
2925         return r;
2926 }
2927
2928 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
2929         sd_bus_creds *c;
2930         pid_t pid = 0;
2931         int r;
2932
2933         assert_return(bus, -EINVAL);
2934         assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
2935         assert_return(ret, -EINVAL);
2936         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2937         assert_return(!bus_pid_changed(bus), -ECHILD);
2938         assert_return(!bus->is_kernel, -ENOTSUP);
2939
2940         if (!bus->ucred_valid && !isempty(bus->label))
2941                 return -ENODATA;
2942
2943         c = bus_creds_new();
2944         if (!c)
2945                 return -ENOMEM;
2946
2947         if (bus->ucred_valid) {
2948                 pid = c->pid = bus->ucred.pid;
2949                 c->uid = bus->ucred.uid;
2950                 c->gid = bus->ucred.gid;
2951
2952                 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
2953         }
2954
2955         if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
2956                 c->label = strdup(bus->label);
2957                 if (!c->label) {
2958                         sd_bus_creds_unref(c);
2959                         return -ENOMEM;
2960                 }
2961
2962                 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
2963         }
2964
2965         r = bus_creds_add_more(c, mask, pid, 0);
2966         if (r < 0)
2967                 return r;
2968
2969         *ret = c;
2970         return 0;
2971 }
2972
2973 _public_ int sd_bus_try_close(sd_bus *bus) {
2974         int r;
2975
2976         assert_return(bus, -EINVAL);
2977         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2978         assert_return(!bus_pid_changed(bus), -ECHILD);
2979         assert_return(bus->is_kernel, -ENOTSUP);
2980
2981         if (bus->rqueue_size > 0)
2982                 return -EBUSY;
2983
2984         if (bus->wqueue_size > 0)
2985                 return -EBUSY;
2986
2987         r = bus_kernel_try_close(bus);
2988         if (r < 0)
2989                 return r;
2990
2991         sd_bus_close(bus);
2992         return 0;
2993 }