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
  48 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
  49
  50 static void bus_close_fds(sd_bus *b) {
  51         assert(b);
  52
  53         if (b->input_fd >= 0)
  54                 close_nointr_nofail(b->input_fd);
  55
  56         if (b->output_fd >= 0 && b->output_fd != b->input_fd)
  57                 close_nointr_nofail(b->output_fd);
  58
  59         b->input_fd = b->output_fd = -1;
  60 }
  61
  62 static void bus_node_destroy(sd_bus *b, struct node *n) {
  63         struct node_callback *c;
  64         struct node_vtable *v;
  65         struct node_enumerator *e;
  66
  67         assert(b);
  68
  69         if (!n)
  70                 return;
  71
  72         while (n->child)
  73                 bus_node_destroy(b, n->child);
  74
  75         while ((c = n->callbacks)) {
  76                 LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
  77                 free(c);
  78         }
  79
  80         while ((v = n->vtables)) {
  81                 LIST_REMOVE(struct node_vtable, vtables, n->vtables, v);
  82                 free(v->interface);
  83                 free(v);
  84         }
  85
  86         while ((e = n->enumerators)) {
  87                 LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, e);
  88                 free(e);
  89         }
  90
  91         if (n->parent)
  92                 LIST_REMOVE(struct node, siblings, n->parent->child, n);
  93
  94         assert_se(hashmap_remove(b->nodes, n->path) == n);
  95         free(n->path);
  96         free(n);
  97 }
  98
  99 static void bus_free(sd_bus *b) {
 100         struct filter_callback *f;
 101         struct node *n;
 102         unsigned i;
 103
 104         assert(b);
 105
 106         bus_close_fds(b);
 107
 108         if (b->kdbus_buffer)
 109                 munmap(b->kdbus_buffer, KDBUS_POOL_SIZE);
 110
 111         free(b->rbuffer);
 112         free(b->unique_name);
 113         free(b->auth_buffer);
 114         free(b->address);
 115         free(b->kernel);
 116
 117         free(b->exec_path);
 118         strv_free(b->exec_argv);
 119
 120         close_many(b->fds, b->n_fds);
 121         free(b->fds);
 122
 123         for (i = 0; i < b->rqueue_size; i++)
 124                 sd_bus_message_unref(b->rqueue[i]);
 125         free(b->rqueue);
 126
 127         for (i = 0; i < b->wqueue_size; i++)
 128                 sd_bus_message_unref(b->wqueue[i]);
 129         free(b->wqueue);
 130
 131         hashmap_free_free(b->reply_callbacks);
 132         prioq_free(b->reply_callbacks_prioq);
 133
 134         while ((f = b->filter_callbacks)) {
 135                 LIST_REMOVE(struct filter_callback, callbacks, b->filter_callbacks, f);
 136                 free(f);
 137         }
 138
 139         bus_match_free(&b->match_callbacks);
 140
 141         hashmap_free_free(b->vtable_methods);
 142         hashmap_free_free(b->vtable_properties);
 143
 144         while ((n = hashmap_first(b->nodes)))
 145                 bus_node_destroy(b, n);
 146
 147         hashmap_free(b->nodes);
 148
 149         bus_kernel_flush_memfd(b);
 150
 151         assert_se(pthread_mutex_destroy(&b->memfd_cache_mutex) == 0);
 152
 153         free(b);
 154 }
 155
 156 int sd_bus_new(sd_bus **ret) {
 157         sd_bus *r;
 158
 159         if (!ret)
 160                 return -EINVAL;
 161
 162         r = new0(sd_bus, 1);
 163         if (!r)
 164                 return -ENOMEM;
 165
 166         r->n_ref = REFCNT_INIT;
 167         r->input_fd = r->output_fd = -1;
 168         r->message_version = 1;
 169         r->hello_flags |= KDBUS_HELLO_ACCEPT_FD;
 170         r->original_pid = getpid();
 171
 172         assert_se(pthread_mutex_init(&r->memfd_cache_mutex, NULL) == 0);
 173
 174         /* We guarantee that wqueue always has space for at least one
 175          * entry */
 176         r->wqueue = new(sd_bus_message*, 1);
 177         if (!r->wqueue) {
 178                 free(r);
 179                 return -ENOMEM;
 180         }
 181
 182         *ret = r;
 183         return 0;
 184 }
 185
 186 int sd_bus_set_address(sd_bus *bus, const char *address) {
 187         char *a;
 188
 189         if (!bus)
 190                 return -EINVAL;
 191         if (bus->state != BUS_UNSET)
 192                 return -EPERM;
 193         if (!address)
 194                 return -EINVAL;
 195         if (bus_pid_changed(bus))
 196                 return -ECHILD;
 197
 198         a = strdup(address);
 199         if (!a)
 200                 return -ENOMEM;
 201
 202         free(bus->address);
 203         bus->address = a;
 204
 205         return 0;
 206 }
 207
 208 int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
 209         if (!bus)
 210                 return -EINVAL;
 211         if (bus->state != BUS_UNSET)
 212                 return -EPERM;
 213         if (input_fd < 0)
 214                 return -EINVAL;
 215         if (output_fd < 0)
 216                 return -EINVAL;
 217         if (bus_pid_changed(bus))
 218                 return -ECHILD;
 219
 220         bus->input_fd = input_fd;
 221         bus->output_fd = output_fd;
 222         return 0;
 223 }
 224
 225 int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
 226         char *p, **a;
 227
 228         if (!bus)
 229                 return -EINVAL;
 230         if (bus->state != BUS_UNSET)
 231                 return -EPERM;
 232         if (!path)
 233                 return -EINVAL;
 234         if (strv_isempty(argv))
 235                 return -EINVAL;
 236         if (bus_pid_changed(bus))
 237                 return -ECHILD;
 238
 239         p = strdup(path);
 240         if (!p)
 241                 return -ENOMEM;
 242
 243         a = strv_copy(argv);
 244         if (!a) {
 245                 free(p);
 246                 return -ENOMEM;
 247         }
 248
 249         free(bus->exec_path);
 250         strv_free(bus->exec_argv);
 251
 252         bus->exec_path = p;
 253         bus->exec_argv = a;
 254
 255         return 0;
 256 }
 257
 258 int sd_bus_set_bus_client(sd_bus *bus, int b) {
 259         if (!bus)
 260                 return -EINVAL;
 261         if (bus->state != BUS_UNSET)
 262                 return -EPERM;
 263         if (bus_pid_changed(bus))
 264                 return -ECHILD;
 265
 266         bus->bus_client = !!b;
 267         return 0;
 268 }
 269
 270 int sd_bus_negotiate_fds(sd_bus *bus, int b) {
 271         if (!bus)
 272                 return -EINVAL;
 273         if (bus->state != BUS_UNSET)
 274                 return -EPERM;
 275         if (bus_pid_changed(bus))
 276                 return -ECHILD;
 277
 278         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ACCEPT_FD, b);
 279         return 0;
 280 }
 281
 282 int sd_bus_negotiate_attach_comm(sd_bus *bus, int b) {
 283         if (!bus)
 284                 return -EINVAL;
 285         if (bus->state != BUS_UNSET)
 286                 return -EPERM;
 287         if (bus_pid_changed(bus))
 288                 return -ECHILD;
 289
 290         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_COMM, b);
 291         return 0;
 292 }
 293
 294 int sd_bus_negotiate_attach_exe(sd_bus *bus, int b) {
 295         if (!bus)
 296                 return -EINVAL;
 297         if (bus->state != BUS_UNSET)
 298                 return -EPERM;
 299         if (bus_pid_changed(bus))
 300                 return -ECHILD;
 301
 302         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_EXE, b);
 303         return 0;
 304 }
 305
 306 int sd_bus_negotiate_attach_cmdline(sd_bus *bus, int b) {
 307         if (!bus)
 308                 return -EINVAL;
 309         if (bus->state != BUS_UNSET)
 310                 return -EPERM;
 311         if (bus_pid_changed(bus))
 312                 return -ECHILD;
 313
 314         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CMDLINE, b);
 315         return 0;
 316 }
 317
 318 int sd_bus_negotiate_attach_cgroup(sd_bus *bus, int b) {
 319         if (!bus)
 320                 return -EINVAL;
 321         if (bus->state != BUS_UNSET)
 322                 return -EPERM;
 323         if (bus_pid_changed(bus))
 324                 return -ECHILD;
 325
 326         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CGROUP, b);
 327         return 0;
 328 }
 329
 330 int sd_bus_negotiate_attach_caps(sd_bus *bus, int b) {
 331         if (!bus)
 332                 return -EINVAL;
 333         if (bus->state != BUS_UNSET)
 334                 return -EPERM;
 335         if (bus_pid_changed(bus))
 336                 return -ECHILD;
 337
 338         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_CAPS, b);
 339         return 0;
 340 }
 341
 342 int sd_bus_negotiate_attach_selinux_context(sd_bus *bus, int b) {
 343         if (!bus)
 344                 return -EINVAL;
 345         if (bus->state != BUS_UNSET)
 346                 return -EPERM;
 347         if (bus_pid_changed(bus))
 348                 return -ECHILD;
 349
 350         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_SECLABEL, b);
 351         return 0;
 352 }
 353
 354 int sd_bus_negotiate_attach_audit(sd_bus *bus, int b) {
 355         if (!bus)
 356                 return -EINVAL;
 357         if (bus->state != BUS_UNSET)
 358                 return -EPERM;
 359         if (bus_pid_changed(bus))
 360                 return -ECHILD;
 361
 362         SET_FLAG(bus->hello_flags, KDBUS_HELLO_ATTACH_AUDIT, b);
 363         return 0;
 364 }
 365
 366 int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
 367         if (!bus)
 368                 return -EINVAL;
 369         if (!b && !sd_id128_equal(server_id, SD_ID128_NULL))
 370                 return -EINVAL;
 371         if (bus->state != BUS_UNSET)
 372                 return -EPERM;
 373         if (bus_pid_changed(bus))
 374                 return -ECHILD;
 375
 376         bus->is_server = !!b;
 377         bus->server_id = server_id;
 378         return 0;
 379 }
 380
 381 int sd_bus_set_anonymous(sd_bus *bus, int b) {
 382         if (!bus)
 383                 return -EINVAL;
 384         if (bus->state != BUS_UNSET)
 385                 return -EPERM;
 386         if (bus_pid_changed(bus))
 387                 return -ECHILD;
 388
 389         bus->anonymous_auth = !!b;
 390         return 0;
 391 }
 392
 393 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata) {
 394         const char *s;
 395         int r;
 396
 397         assert(bus);
 398         assert(bus->state == BUS_HELLO);
 399         assert(reply);
 400
 401         r = bus_message_to_errno(reply);
 402         if (r < 0)
 403                 return r;
 404
 405         r = sd_bus_message_read(reply, "s", &s);
 406         if (r < 0)
 407                 return r;
 408
 409         if (!service_name_is_valid(s) || s[0] != ':')
 410                 return -EBADMSG;
 411
 412         bus->unique_name = strdup(s);
 413         if (!bus->unique_name)
 414                 return -ENOMEM;
 415
 416         bus->state = BUS_RUNNING;
 417
 418         return 1;
 419 }
 420
 421 static int bus_send_hello(sd_bus *bus) {
 422         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 423         int r;
 424
 425         assert(bus);
 426
 427         if (!bus->bus_client || bus->is_kernel)
 428                 return 0;
 429
 430         r = sd_bus_message_new_method_call(
 431                         bus,
 432                         "org.freedesktop.DBus",
 433                         "/",
 434                         "org.freedesktop.DBus",
 435                         "Hello",
 436                         &m);
 437         if (r < 0)
 438                 return r;
 439
 440         return sd_bus_send_with_reply(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
 441 }
 442
 443 int bus_start_running(sd_bus *bus) {
 444         assert(bus);
 445
 446         if (bus->bus_client && !bus->is_kernel) {
 447                 bus->state = BUS_HELLO;
 448                 return 1;
 449         }
 450
 451         bus->state = BUS_RUNNING;
 452         return 1;
 453 }
 454
 455 static int parse_address_key(const char **p, const char *key, char **value) {
 456         size_t l, n = 0;
 457         const char *a;
 458         char *r = NULL;
 459
 460         assert(p);
 461         assert(*p);
 462         assert(value);
 463
 464         if (key) {
 465                 l = strlen(key);
 466                 if (strncmp(*p, key, l) != 0)
 467                         return 0;
 468
 469                 if ((*p)[l] != '=')
 470                         return 0;
 471
 472                 if (*value)
 473                         return -EINVAL;
 474
 475                 a = *p + l + 1;
 476         } else
 477                 a = *p;
 478
 479         while (*a != ';' && *a != ',' && *a != 0) {
 480                 char c, *t;
 481
 482                 if (*a == '%') {
 483                         int x, y;
 484
 485                         x = unhexchar(a[1]);
 486                         if (x < 0) {
 487                                 free(r);
 488                                 return x;
 489                         }
 490
 491                         y = unhexchar(a[2]);
 492                         if (y < 0) {
 493                                 free(r);
 494                                 return y;
 495                         }
 496
 497                         c = (char) ((x << 4) | y);
 498                         a += 3;
 499                 } else {
 500                         c = *a;
 501                         a++;
 502                 }
 503
 504                 t = realloc(r, n + 2);
 505                 if (!t) {
 506                         free(r);
 507                         return -ENOMEM;
 508                 }
 509
 510                 r = t;
 511                 r[n++] = c;
 512         }
 513
 514         if (!r) {
 515                 r = strdup("");
 516                 if (!r)
 517                         return -ENOMEM;
 518         } else
 519                 r[n] = 0;
 520
 521         if (*a == ',')
 522                 a++;
 523
 524         *p = a;
 525
 526         free(*value);
 527         *value = r;
 528
 529         return 1;
 530 }
 531
 532 static void skip_address_key(const char **p) {
 533         assert(p);
 534         assert(*p);
 535
 536         *p += strcspn(*p, ",");
 537
 538         if (**p == ',')
 539                 (*p) ++;
 540 }
 541
 542 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
 543         _cleanup_free_ char *path = NULL, *abstract = NULL;
 544         size_t l;
 545         int r;
 546
 547         assert(b);
 548         assert(p);
 549         assert(*p);
 550         assert(guid);
 551
 552         while (**p != 0 && **p != ';') {
 553                 r = parse_address_key(p, "guid", guid);
 554                 if (r < 0)
 555                         return r;
 556                 else if (r > 0)
 557                         continue;
 558
 559                 r = parse_address_key(p, "path", &path);
 560                 if (r < 0)
 561                         return r;
 562                 else if (r > 0)
 563                         continue;
 564
 565                 r = parse_address_key(p, "abstract", &abstract);
 566                 if (r < 0)
 567                         return r;
 568                 else if (r > 0)
 569                         continue;
 570
 571                 skip_address_key(p);
 572         }
 573
 574         if (!path && !abstract)
 575                 return -EINVAL;
 576
 577         if (path && abstract)
 578                 return -EINVAL;
 579
 580         if (path) {
 581                 l = strlen(path);
 582                 if (l > sizeof(b->sockaddr.un.sun_path))
 583                         return -E2BIG;
 584
 585                 b->sockaddr.un.sun_family = AF_UNIX;
 586                 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
 587                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
 588         } else if (abstract) {
 589                 l = strlen(abstract);
 590                 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
 591                         return -E2BIG;
 592
 593                 b->sockaddr.un.sun_family = AF_UNIX;
 594                 b->sockaddr.un.sun_path[0] = 0;
 595                 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
 596                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
 597         }
 598
 599         return 0;
 600 }
 601
 602 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
 603         _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
 604         int r;
 605         struct addrinfo *result, hints = {
 606                 .ai_socktype = SOCK_STREAM,
 607                 .ai_flags = AI_ADDRCONFIG,
 608         };
 609
 610         assert(b);
 611         assert(p);
 612         assert(*p);
 613         assert(guid);
 614
 615         while (**p != 0 && **p != ';') {
 616                 r = parse_address_key(p, "guid", guid);
 617                 if (r < 0)
 618                         return r;
 619                 else if (r > 0)
 620                         continue;
 621
 622                 r = parse_address_key(p, "host", &host);
 623                 if (r < 0)
 624                         return r;
 625                 else if (r > 0)
 626                         continue;
 627
 628                 r = parse_address_key(p, "port", &port);
 629                 if (r < 0)
 630                         return r;
 631                 else if (r > 0)
 632                         continue;
 633
 634                 r = parse_address_key(p, "family", &family);
 635                 if (r < 0)
 636                         return r;
 637                 else if (r > 0)
 638                         continue;
 639
 640                 skip_address_key(p);
 641         }
 642
 643         if (!host || !port)
 644                 return -EINVAL;
 645
 646         if (family) {
 647                 if (streq(family, "ipv4"))
 648                         hints.ai_family = AF_INET;
 649                 else if (streq(family, "ipv6"))
 650                         hints.ai_family = AF_INET6;
 651                 else
 652                         return -EINVAL;
 653         }
 654
 655         r = getaddrinfo(host, port, &hints, &result);
 656         if (r == EAI_SYSTEM)
 657                 return -errno;
 658         else if (r != 0)
 659                 return -EADDRNOTAVAIL;
 660
 661         memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
 662         b->sockaddr_size = result->ai_addrlen;
 663
 664         freeaddrinfo(result);
 665
 666         return 0;
 667 }
 668
 669 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
 670         char *path = NULL;
 671         unsigned n_argv = 0, j;
 672         char **argv = NULL;
 673         int r;
 674
 675         assert(b);
 676         assert(p);
 677         assert(*p);
 678         assert(guid);
 679
 680         while (**p != 0 && **p != ';') {
 681                 r = parse_address_key(p, "guid", guid);
 682                 if (r < 0)
 683                         goto fail;
 684                 else if (r > 0)
 685                         continue;
 686
 687                 r = parse_address_key(p, "path", &path);
 688                 if (r < 0)
 689                         goto fail;
 690                 else if (r > 0)
 691                         continue;
 692
 693                 if (startswith(*p, "argv")) {
 694                         unsigned ul;
 695
 696                         errno = 0;
 697                         ul = strtoul(*p + 4, (char**) p, 10);
 698                         if (errno > 0 || **p != '=' || ul > 256) {
 699                                 r = -EINVAL;
 700                                 goto fail;
 701                         }
 702
 703                         (*p) ++;
 704
 705                         if (ul >= n_argv) {
 706                                 char **x;
 707
 708                                 x = realloc(argv, sizeof(char*) * (ul + 2));
 709                                 if (!x) {
 710                                         r = -ENOMEM;
 711                                         goto fail;
 712                                 }
 713
 714                                 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
 715
 716                                 argv = x;
 717                                 n_argv = ul + 1;
 718                         }
 719
 720                         r = parse_address_key(p, NULL, argv + ul);
 721                         if (r < 0)
 722                                 goto fail;
 723
 724                         continue;
 725                 }
 726
 727                 skip_address_key(p);
 728         }
 729
 730         if (!path) {
 731                 r = -EINVAL;
 732                 goto fail;
 733         }
 734
 735         /* Make sure there are no holes in the array, with the
 736          * exception of argv[0] */
 737         for (j = 1; j < n_argv; j++)
 738                 if (!argv[j]) {
 739                         r = -EINVAL;
 740                         goto fail;
 741                 }
 742
 743         if (argv && argv[0] == NULL) {
 744                 argv[0] = strdup(path);
 745                 if (!argv[0]) {
 746                         r = -ENOMEM;
 747                         goto fail;
 748                 }
 749         }
 750
 751         b->exec_path = path;
 752         b->exec_argv = argv;
 753         return 0;
 754
 755 fail:
 756         for (j = 0; j < n_argv; j++)
 757                 free(argv[j]);
 758
 759         free(argv);
 760         free(path);
 761         return r;
 762 }
 763
 764 static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
 765         _cleanup_free_ char *path = NULL;
 766         int r;
 767
 768         assert(b);
 769         assert(p);
 770         assert(*p);
 771         assert(guid);
 772
 773         while (**p != 0 && **p != ';') {
 774                 r = parse_address_key(p, "guid", guid);
 775                 if (r < 0)
 776                         return r;
 777                 else if (r > 0)
 778                         continue;
 779
 780                 r = parse_address_key(p, "path", &path);
 781                 if (r < 0)
 782                         return r;
 783                 else if (r > 0)
 784                         continue;
 785
 786                 skip_address_key(p);
 787         }
 788
 789         if (!path)
 790                 return -EINVAL;
 791
 792         free(b->kernel);
 793         b->kernel = path;
 794         path = NULL;
 795
 796         return 0;
 797 }
 798
 799 static void bus_reset_parsed_address(sd_bus *b) {
 800         assert(b);
 801
 802         zero(b->sockaddr);
 803         b->sockaddr_size = 0;
 804         strv_free(b->exec_argv);
 805         free(b->exec_path);
 806         b->exec_path = NULL;
 807         b->exec_argv = NULL;
 808         b->server_id = SD_ID128_NULL;
 809         free(b->kernel);
 810         b->kernel = NULL;
 811 }
 812
 813 static int bus_parse_next_address(sd_bus *b) {
 814         _cleanup_free_ char *guid = NULL;
 815         const char *a;
 816         int r;
 817
 818         assert(b);
 819
 820         if (!b->address)
 821                 return 0;
 822         if (b->address[b->address_index] == 0)
 823                 return 0;
 824
 825         bus_reset_parsed_address(b);
 826
 827         a = b->address + b->address_index;
 828
 829         while (*a != 0) {
 830
 831                 if (*a == ';') {
 832                         a++;
 833                         continue;
 834                 }
 835
 836                 if (startswith(a, "unix:")) {
 837                         a += 5;
 838
 839                         r = parse_unix_address(b, &a, &guid);
 840                         if (r < 0)
 841                                 return r;
 842                         break;
 843
 844                 } else if (startswith(a, "tcp:")) {
 845
 846                         a += 4;
 847                         r = parse_tcp_address(b, &a, &guid);
 848                         if (r < 0)
 849                                 return r;
 850
 851                         break;
 852
 853                 } else if (startswith(a, "unixexec:")) {
 854
 855                         a += 9;
 856                         r = parse_exec_address(b, &a, &guid);
 857                         if (r < 0)
 858                                 return r;
 859
 860                         break;
 861
 862                 } else if (startswith(a, "kernel:")) {
 863
 864                         a += 7;
 865                         r = parse_kernel_address(b, &a, &guid);
 866                         if (r < 0)
 867                                 return r;
 868
 869                         break;
 870                 }
 871
 872                 a = strchr(a, ';');
 873                 if (!a)
 874                         return 0;
 875         }
 876
 877         if (guid) {
 878                 r = sd_id128_from_string(guid, &b->server_id);
 879                 if (r < 0)
 880                         return r;
 881         }
 882
 883         b->address_index = a - b->address;
 884         return 1;
 885 }
 886
 887 static int bus_start_address(sd_bus *b) {
 888         int r;
 889
 890         assert(b);
 891
 892         for (;;) {
 893                 sd_bus_close(b);
 894
 895                 if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
 896
 897                         r = bus_socket_connect(b);
 898                         if (r >= 0)
 899                                 return r;
 900
 901                         b->last_connect_error = -r;
 902
 903                 } else if (b->exec_path) {
 904
 905                         r = bus_socket_exec(b);
 906                         if (r >= 0)
 907                                 return r;
 908
 909                         b->last_connect_error = -r;
 910                 } else if (b->kernel) {
 911
 912                         r = bus_kernel_connect(b);
 913                         if (r >= 0)
 914                                 return r;
 915
 916                         b->last_connect_error = -r;
 917                 }
 918
 919                 r = bus_parse_next_address(b);
 920                 if (r < 0)
 921                         return r;
 922                 if (r == 0)
 923                         return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
 924         }
 925 }
 926
 927 int bus_next_address(sd_bus *b) {
 928         assert(b);
 929
 930         bus_reset_parsed_address(b);
 931         return bus_start_address(b);
 932 }
 933
 934 static int bus_start_fd(sd_bus *b) {
 935         struct stat st;
 936         int r;
 937
 938         assert(b);
 939         assert(b->input_fd >= 0);
 940         assert(b->output_fd >= 0);
 941
 942         r = fd_nonblock(b->input_fd, true);
 943         if (r < 0)
 944                 return r;
 945
 946         r = fd_cloexec(b->input_fd, true);
 947         if (r < 0)
 948                 return r;
 949
 950         if (b->input_fd != b->output_fd) {
 951                 r = fd_nonblock(b->output_fd, true);
 952                 if (r < 0)
 953                         return r;
 954
 955                 r = fd_cloexec(b->output_fd, true);
 956                 if (r < 0)
 957                         return r;
 958         }
 959
 960         if (fstat(b->input_fd, &st) < 0)
 961                 return -errno;
 962
 963         if (S_ISCHR(b->input_fd))
 964                 return bus_kernel_take_fd(b);
 965         else
 966                 return bus_socket_take_fd(b);
 967 }
 968
 969 int sd_bus_start(sd_bus *bus) {
 970         int r;
 971
 972         if (!bus)
 973                 return -EINVAL;
 974         if (bus->state != BUS_UNSET)
 975                 return -EPERM;
 976         if (bus_pid_changed(bus))
 977                 return -ECHILD;
 978
 979         bus->state = BUS_OPENING;
 980
 981         if (bus->is_server && bus->bus_client)
 982                 return -EINVAL;
 983
 984         if (bus->input_fd >= 0)
 985                 r = bus_start_fd(bus);
 986         else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel)
 987                 r = bus_start_address(bus);
 988         else
 989                 return -EINVAL;
 990
 991         if (r < 0)
 992                 return r;
 993
 994         return bus_send_hello(bus);
 995 }
 996
 997 int sd_bus_open_system(sd_bus **ret) {
 998         const char *e;
 999         sd_bus *b;
1000         int r;
1001
1002         if (!ret)
1003                 return -EINVAL;
1004
1005         r = sd_bus_new(&b);
1006         if (r < 0)
1007                 return r;
1008
1009         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1010         if (e) {
1011                 r = sd_bus_set_address(b, e);
1012                 if (r < 0)
1013                         goto fail;
1014         } else {
1015                 b->sockaddr.un.sun_family = AF_UNIX;
1016                 strncpy(b->sockaddr.un.sun_path, "/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
1017                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/dbus/system_bus_socket") - 1;
1018         }
1019
1020         b->bus_client = true;
1021
1022         r = sd_bus_start(b);
1023         if (r < 0)
1024                 goto fail;
1025
1026         *ret = b;
1027         return 0;
1028
1029 fail:
1030         bus_free(b);
1031         return r;
1032 }
1033
1034 int sd_bus_open_user(sd_bus **ret) {
1035         const char *e;
1036         sd_bus *b;
1037         size_t l;
1038         int r;
1039
1040         if (!ret)
1041                 return -EINVAL;
1042
1043         r = sd_bus_new(&b);
1044         if (r < 0)
1045                 return r;
1046
1047         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1048         if (e) {
1049                 r = sd_bus_set_address(b, e);
1050                 if (r < 0)
1051                         goto fail;
1052         } else {
1053                 e = secure_getenv("XDG_RUNTIME_DIR");
1054                 if (!e) {
1055                         r = -ENOENT;
1056                         goto fail;
1057                 }
1058
1059                 l = strlen(e);
1060                 if (l + 4 > sizeof(b->sockaddr.un.sun_path)) {
1061                         r = -E2BIG;
1062                         goto fail;
1063                 }
1064
1065                 b->sockaddr.un.sun_family = AF_UNIX;
1066                 memcpy(mempcpy(b->sockaddr.un.sun_path, e, l), "/bus", 4);
1067                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l + 4;
1068         }
1069
1070         b->bus_client = true;
1071
1072         r = sd_bus_start(b);
1073         if (r < 0)
1074                 goto fail;
1075
1076         *ret = b;
1077         return 0;
1078
1079 fail:
1080         bus_free(b);
1081         return r;
1082 }
1083
1084 void sd_bus_close(sd_bus *bus) {
1085         if (!bus)
1086                 return;
1087         if (bus->state == BUS_CLOSED)
1088                 return;
1089         if (bus_pid_changed(bus))
1090                 return;
1091
1092         bus->state = BUS_CLOSED;
1093
1094         if (!bus->is_kernel)
1095                 bus_close_fds(bus);
1096
1097         /* We'll leave the fd open in case this is a kernel bus, since
1098          * there might still be memblocks around that reference this
1099          * bus, and they might need to invoke the
1100          * KDBUS_CMD_MSG_RELEASE ioctl on the fd when they are
1101          * freed. */
1102 }
1103
1104 sd_bus *sd_bus_ref(sd_bus *bus) {
1105         if (!bus)
1106                 return NULL;
1107
1108         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1109
1110         return bus;
1111 }
1112
1113 sd_bus *sd_bus_unref(sd_bus *bus) {
1114         if (!bus)
1115                 return NULL;
1116
1117         if (REFCNT_DEC(bus->n_ref) <= 0)
1118                 bus_free(bus);
1119
1120         return NULL;
1121 }
1122
1123 int sd_bus_is_open(sd_bus *bus) {
1124         if (!bus)
1125                 return -EINVAL;
1126         if (bus_pid_changed(bus))
1127                 return -ECHILD;
1128
1129         return BUS_IS_OPEN(bus->state);
1130 }
1131
1132 int sd_bus_can_send(sd_bus *bus, char type) {
1133         int r;
1134
1135         if (!bus)
1136                 return -EINVAL;
1137         if (bus->state == BUS_UNSET)
1138                 return -ENOTCONN;
1139         if (bus_pid_changed(bus))
1140                 return -ECHILD;
1141
1142         if (type == SD_BUS_TYPE_UNIX_FD) {
1143                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1144                         return 0;
1145
1146                 r = bus_ensure_running(bus);
1147                 if (r < 0)
1148                         return r;
1149
1150                 return bus->can_fds;
1151         }
1152
1153         return bus_type_is_valid(type);
1154 }
1155
1156 int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1157         int r;
1158
1159         if (!bus)
1160                 return -EINVAL;
1161         if (!server_id)
1162                 return -EINVAL;
1163         if (bus_pid_changed(bus))
1164                 return -ECHILD;
1165
1166         r = bus_ensure_running(bus);
1167         if (r < 0)
1168                 return r;
1169
1170         *server_id = bus->server_id;
1171         return 0;
1172 }
1173
1174 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
1175         assert(m);
1176
1177         if (m->header->version > b->message_version)
1178                 return -EPERM;
1179
1180         if (m->sealed)
1181                 return 0;
1182
1183         return bus_message_seal(m, ++b->serial);
1184 }
1185
1186 static int dispatch_wqueue(sd_bus *bus) {
1187         int r, ret = 0;
1188
1189         assert(bus);
1190         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1191
1192         while (bus->wqueue_size > 0) {
1193
1194                 if (bus->is_kernel)
1195                         r = bus_kernel_write_message(bus, bus->wqueue[0]);
1196                 else
1197                         r = bus_socket_write_message(bus, bus->wqueue[0], &bus->windex);
1198
1199                 if (r < 0) {
1200                         sd_bus_close(bus);
1201                         return r;
1202                 } else if (r == 0)
1203                         /* Didn't do anything this time */
1204                         return ret;
1205                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1206                         /* Fully written. Let's drop the entry from
1207                          * the queue.
1208                          *
1209                          * This isn't particularly optimized, but
1210                          * well, this is supposed to be our worst-case
1211                          * buffer only, and the socket buffer is
1212                          * supposed to be our primary buffer, and if
1213                          * it got full, then all bets are off
1214                          * anyway. */
1215
1216                         sd_bus_message_unref(bus->wqueue[0]);
1217                         bus->wqueue_size --;
1218                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1219                         bus->windex = 0;
1220
1221                         ret = 1;
1222                 }
1223         }
1224
1225         return ret;
1226 }
1227
1228 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
1229         sd_bus_message *z = NULL;
1230         int r, ret = 0;
1231
1232         assert(bus);
1233         assert(m);
1234         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1235
1236         if (bus->rqueue_size > 0) {
1237                 /* Dispatch a queued message */
1238
1239                 *m = bus->rqueue[0];
1240                 bus->rqueue_size --;
1241                 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1242                 return 1;
1243         }
1244
1245         /* Try to read a new message */
1246         do {
1247                 if (bus->is_kernel)
1248                         r = bus_kernel_read_message(bus, &z);
1249                 else
1250                         r = bus_socket_read_message(bus, &z);
1251
1252                 if (r < 0) {
1253                         sd_bus_close(bus);
1254                         return r;
1255                 }
1256                 if (r == 0)
1257                         return ret;
1258
1259                 ret = 1;
1260         } while (!z);
1261
1262         *m = z;
1263         return ret;
1264 }
1265
1266 int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1267         int r;
1268
1269         if (!bus)
1270                 return -EINVAL;
1271         if (!BUS_IS_OPEN(bus->state))
1272                 return -ENOTCONN;
1273         if (!m)
1274                 return -EINVAL;
1275         if (bus_pid_changed(bus))
1276                 return -ECHILD;
1277
1278         if (m->n_fds > 0) {
1279                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1280                 if (r < 0)
1281                         return r;
1282                 if (r == 0)
1283                         return -ENOTSUP;
1284         }
1285
1286         /* If the serial number isn't kept, then we know that no reply
1287          * is expected */
1288         if (!serial && !m->sealed)
1289                 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1290
1291         r = bus_seal_message(bus, m);
1292         if (r < 0)
1293                 return r;
1294
1295         /* If this is a reply and no reply was requested, then let's
1296          * suppress this, if we can */
1297         if (m->dont_send && !serial)
1298                 return 0;
1299
1300         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1301                 size_t idx = 0;
1302
1303                 if (bus->is_kernel)
1304                         r = bus_kernel_write_message(bus, m);
1305                 else
1306                         r = bus_socket_write_message(bus, m, &idx);
1307
1308                 if (r < 0) {
1309                         sd_bus_close(bus);
1310                         return r;
1311                 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1312                         /* Wasn't fully written. So let's remember how
1313                          * much was written. Note that the first entry
1314                          * of the wqueue array is always allocated so
1315                          * that we always can remember how much was
1316                          * written. */
1317                         bus->wqueue[0] = sd_bus_message_ref(m);
1318                         bus->wqueue_size = 1;
1319                         bus->windex = idx;
1320                 }
1321         } else {
1322                 sd_bus_message **q;
1323
1324                 /* Just append it to the queue. */
1325
1326                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1327                         return -ENOBUFS;
1328
1329                 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1330                 if (!q)
1331                         return -ENOMEM;
1332
1333                 bus->wqueue = q;
1334                 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1335         }
1336
1337         if (serial)
1338                 *serial = BUS_MESSAGE_SERIAL(m);
1339
1340         return 0;
1341 }
1342
1343 static usec_t calc_elapse(uint64_t usec) {
1344         if (usec == (uint64_t) -1)
1345                 return 0;
1346
1347         if (usec == 0)
1348                 usec = BUS_DEFAULT_TIMEOUT;
1349
1350         return now(CLOCK_MONOTONIC) + usec;
1351 }
1352
1353 static int timeout_compare(const void *a, const void *b) {
1354         const struct reply_callback *x = a, *y = b;
1355
1356         if (x->timeout != 0 && y->timeout == 0)
1357                 return -1;
1358
1359         if (x->timeout == 0 && y->timeout != 0)
1360                 return 1;
1361
1362         if (x->timeout < y->timeout)
1363                 return -1;
1364
1365         if (x->timeout > y->timeout)
1366                 return 1;
1367
1368         return 0;
1369 }
1370
1371 int sd_bus_send_with_reply(
1372                 sd_bus *bus,
1373                 sd_bus_message *m,
1374                 sd_bus_message_handler_t callback,
1375                 void *userdata,
1376                 uint64_t usec,
1377                 uint64_t *serial) {
1378
1379         struct reply_callback *c;
1380         int r;
1381
1382         if (!bus)
1383                 return -EINVAL;
1384         if (!BUS_IS_OPEN(bus->state))
1385                 return -ENOTCONN;
1386         if (!m)
1387                 return -EINVAL;
1388         if (!callback)
1389                 return -EINVAL;
1390         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1391                 return -EINVAL;
1392         if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1393                 return -EINVAL;
1394         if (bus_pid_changed(bus))
1395                 return -ECHILD;
1396
1397         r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1398         if (r < 0)
1399                 return r;
1400
1401         if (usec != (uint64_t) -1) {
1402                 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1403                 if (r < 0)
1404                         return r;
1405         }
1406
1407         r = bus_seal_message(bus, m);
1408         if (r < 0)
1409                 return r;
1410
1411         c = new0(struct reply_callback, 1);
1412         if (!c)
1413                 return -ENOMEM;
1414
1415         c->callback = callback;
1416         c->userdata = userdata;
1417         c->serial = BUS_MESSAGE_SERIAL(m);
1418         c->timeout = calc_elapse(usec);
1419
1420         r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1421         if (r < 0) {
1422                 free(c);
1423                 return r;
1424         }
1425
1426         if (c->timeout != 0) {
1427                 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1428                 if (r < 0) {
1429                         c->timeout = 0;
1430                         sd_bus_send_with_reply_cancel(bus, c->serial);
1431                         return r;
1432                 }
1433         }
1434
1435         r = sd_bus_send(bus, m, serial);
1436         if (r < 0) {
1437                 sd_bus_send_with_reply_cancel(bus, c->serial);
1438                 return r;
1439         }
1440
1441         return r;
1442 }
1443
1444 int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
1445         struct reply_callback *c;
1446
1447         if (!bus)
1448                 return -EINVAL;
1449         if (serial == 0)
1450                 return -EINVAL;
1451         if (bus_pid_changed(bus))
1452                 return -ECHILD;
1453
1454         c = hashmap_remove(bus->reply_callbacks, &serial);
1455         if (!c)
1456                 return 0;
1457
1458         if (c->timeout != 0)
1459                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1460
1461         free(c);
1462         return 1;
1463 }
1464
1465 int bus_ensure_running(sd_bus *bus) {
1466         int r;
1467
1468         assert(bus);
1469
1470         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED)
1471                 return -ENOTCONN;
1472         if (bus->state == BUS_RUNNING)
1473                 return 1;
1474
1475         for (;;) {
1476                 r = sd_bus_process(bus, NULL);
1477                 if (r < 0)
1478                         return r;
1479                 if (bus->state == BUS_RUNNING)
1480                         return 1;
1481                 if (r > 0)
1482                         continue;
1483
1484                 r = sd_bus_wait(bus, (uint64_t) -1);
1485                 if (r < 0)
1486                         return r;
1487         }
1488 }
1489
1490 int sd_bus_send_with_reply_and_block(
1491                 sd_bus *bus,
1492                 sd_bus_message *m,
1493                 uint64_t usec,
1494                 sd_bus_error *error,
1495                 sd_bus_message **reply) {
1496
1497         int r;
1498         usec_t timeout;
1499         uint64_t serial;
1500         bool room = false;
1501
1502         if (!bus)
1503                 return -EINVAL;
1504         if (!BUS_IS_OPEN(bus->state))
1505                 return -ENOTCONN;
1506         if (!m)
1507                 return -EINVAL;
1508         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1509                 return -EINVAL;
1510         if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1511                 return -EINVAL;
1512         if (bus_error_is_dirty(error))
1513                 return -EINVAL;
1514         if (bus_pid_changed(bus))
1515                 return -ECHILD;
1516
1517         r = bus_ensure_running(bus);
1518         if (r < 0)
1519                 return r;
1520
1521         r = sd_bus_send(bus, m, &serial);
1522         if (r < 0)
1523                 return r;
1524
1525         timeout = calc_elapse(usec);
1526
1527         for (;;) {
1528                 usec_t left;
1529                 sd_bus_message *incoming = NULL;
1530
1531                 if (!room) {
1532                         sd_bus_message **q;
1533
1534                         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1535                                 return -ENOBUFS;
1536
1537                         /* Make sure there's room for queuing this
1538                          * locally, before we read the message */
1539
1540                         q = realloc(bus->rqueue, (bus->rqueue_size + 1) * sizeof(sd_bus_message*));
1541                         if (!q)
1542                                 return -ENOMEM;
1543
1544                         bus->rqueue = q;
1545                         room = true;
1546                 }
1547
1548                 if (bus->is_kernel)
1549                         r = bus_kernel_read_message(bus, &incoming);
1550                 else
1551                         r = bus_socket_read_message(bus, &incoming);
1552                 if (r < 0)
1553                         return r;
1554                 if (incoming) {
1555
1556                         if (incoming->reply_serial == serial) {
1557                                 /* Found a match! */
1558
1559                                 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_RETURN) {
1560
1561                                         if (reply)
1562                                                 *reply = incoming;
1563                                         else
1564                                                 sd_bus_message_unref(incoming);
1565
1566                                         return 0;
1567                                 }
1568
1569                                 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR) {
1570                                         int k;
1571
1572                                         r = sd_bus_error_copy(error, &incoming->error);
1573                                         if (r < 0) {
1574                                                 sd_bus_message_unref(incoming);
1575                                                 return r;
1576                                         }
1577
1578                                         k = bus_error_to_errno(&incoming->error);
1579                                         sd_bus_message_unref(incoming);
1580                                         return k;
1581                                 }
1582
1583                                 sd_bus_message_unref(incoming);
1584                                 return -EIO;
1585                         }
1586
1587                         /* There's already guaranteed to be room for
1588                          * this, so need to resize things here */
1589                         bus->rqueue[bus->rqueue_size ++] = incoming;
1590                         room = false;
1591
1592                         /* Try to read more, right-away */
1593                         continue;
1594                 }
1595                 if (r != 0)
1596                         continue;
1597
1598                 if (timeout > 0) {
1599                         usec_t n;
1600
1601                         n = now(CLOCK_MONOTONIC);
1602                         if (n >= timeout)
1603                                 return -ETIMEDOUT;
1604
1605                         left = timeout - n;
1606                 } else
1607                         left = (uint64_t) -1;
1608
1609                 r = bus_poll(bus, true, left);
1610                 if (r < 0)
1611                         return r;
1612
1613                 r = dispatch_wqueue(bus);
1614                 if (r < 0)
1615                         return r;
1616         }
1617 }
1618
1619 int sd_bus_get_fd(sd_bus *bus) {
1620         if (!bus)
1621                 return -EINVAL;
1622         if (!BUS_IS_OPEN(bus->state))
1623                 return -ENOTCONN;
1624         if (bus->input_fd != bus->output_fd)
1625                 return -EPERM;
1626         if (bus_pid_changed(bus))
1627                 return -ECHILD;
1628
1629         return bus->input_fd;
1630 }
1631
1632 int sd_bus_get_events(sd_bus *bus) {
1633         int flags = 0;
1634
1635         if (!bus)
1636                 return -EINVAL;
1637         if (!BUS_IS_OPEN(bus->state))
1638                 return -ENOTCONN;
1639         if (bus_pid_changed(bus))
1640                 return -ECHILD;
1641
1642         if (bus->state == BUS_OPENING)
1643                 flags |= POLLOUT;
1644         else if (bus->state == BUS_AUTHENTICATING) {
1645
1646                 if (bus_socket_auth_needs_write(bus))
1647                         flags |= POLLOUT;
1648
1649                 flags |= POLLIN;
1650
1651         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1652                 if (bus->rqueue_size <= 0)
1653                         flags |= POLLIN;
1654                 if (bus->wqueue_size > 0)
1655                         flags |= POLLOUT;
1656         }
1657
1658         return flags;
1659 }
1660
1661 int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1662         struct reply_callback *c;
1663
1664         if (!bus)
1665                 return -EINVAL;
1666         if (!timeout_usec)
1667                 return -EINVAL;
1668         if (!BUS_IS_OPEN(bus->state))
1669                 return -ENOTCONN;
1670         if (bus_pid_changed(bus))
1671                 return -ECHILD;
1672
1673         if (bus->state == BUS_AUTHENTICATING) {
1674                 *timeout_usec = bus->auth_timeout;
1675                 return 1;
1676         }
1677
1678         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1679                 *timeout_usec = (uint64_t) -1;
1680                 return 0;
1681         }
1682
1683         c = prioq_peek(bus->reply_callbacks_prioq);
1684         if (!c) {
1685                 *timeout_usec = (uint64_t) -1;
1686                 return 0;
1687         }
1688
1689         *timeout_usec = c->timeout;
1690         return 1;
1691 }
1692
1693 static int process_timeout(sd_bus *bus) {
1694         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1695         struct reply_callback *c;
1696         usec_t n;
1697         int r;
1698
1699         assert(bus);
1700
1701         c = prioq_peek(bus->reply_callbacks_prioq);
1702         if (!c)
1703                 return 0;
1704
1705         n = now(CLOCK_MONOTONIC);
1706         if (c->timeout > n)
1707                 return 0;
1708
1709         r = bus_message_new_synthetic_error(
1710                         bus,
1711                         c->serial,
1712                         &SD_BUS_ERROR_MAKE("org.freedesktop.DBus.Error.Timeout", "Timed out"),
1713                         &m);
1714         if (r < 0)
1715                 return r;
1716
1717         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1718         hashmap_remove(bus->reply_callbacks, &c->serial);
1719
1720         r = c->callback(bus, m, c->userdata);
1721         free(c);
1722
1723         return r < 0 ? r : 1;
1724 }
1725
1726 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1727         assert(bus);
1728         assert(m);
1729
1730         if (bus->state != BUS_HELLO)
1731                 return 0;
1732
1733         /* Let's make sure the first message on the bus is the HELLO
1734          * reply. But note that we don't actually parse the message
1735          * here (we leave that to the usual handling), we just verify
1736          * we don't let any earlier msg through. */
1737
1738         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1739             m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1740                 return -EIO;
1741
1742         if (m->reply_serial != bus->hello_serial)
1743                 return -EIO;
1744
1745         return 0;
1746 }
1747
1748 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1749         struct reply_callback *c;
1750         int r;
1751
1752         assert(bus);
1753         assert(m);
1754
1755         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1756             m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1757                 return 0;
1758
1759         c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1760         if (!c)
1761                 return 0;
1762
1763         if (c->timeout != 0)
1764                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1765
1766         r = sd_bus_message_rewind(m, true);
1767         if (r < 0)
1768                 return r;
1769
1770         r = c->callback(bus, m, c->userdata);
1771         free(c);
1772
1773         return r;
1774 }
1775
1776 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1777         struct filter_callback *l;
1778         int r;
1779
1780         assert(bus);
1781         assert(m);
1782
1783         do {
1784                 bus->filter_callbacks_modified = false;
1785
1786                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1787
1788                         if (bus->filter_callbacks_modified)
1789                                 break;
1790
1791                         /* Don't run this more than once per iteration */
1792                         if (l->last_iteration == bus->iteration_counter)
1793                                 continue;
1794
1795                         l->last_iteration = bus->iteration_counter;
1796
1797                         r = sd_bus_message_rewind(m, true);
1798                         if (r < 0)
1799                                 return r;
1800
1801                         r = l->callback(bus, m, l->userdata);
1802                         if (r != 0)
1803                                 return r;
1804
1805                 }
1806
1807         } while (bus->filter_callbacks_modified);
1808
1809         return 0;
1810 }
1811
1812 static int process_match(sd_bus *bus, sd_bus_message *m) {
1813         int r;
1814
1815         assert(bus);
1816         assert(m);
1817
1818         do {
1819                 bus->match_callbacks_modified = false;
1820
1821                 r = bus_match_run(bus, &bus->match_callbacks, m);
1822                 if (r != 0)
1823                         return r;
1824
1825         } while (bus->match_callbacks_modified);
1826
1827         return 0;
1828 }
1829
1830 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1831         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1832         int r;
1833
1834         assert(bus);
1835         assert(m);
1836
1837         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1838                 return 0;
1839
1840         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
1841                 return 0;
1842
1843         if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1844                 return 1;
1845
1846         if (streq_ptr(m->member, "Ping"))
1847                 r = sd_bus_message_new_method_return(bus, m, &reply);
1848         else if (streq_ptr(m->member, "GetMachineId")) {
1849                 sd_id128_t id;
1850                 char sid[33];
1851
1852                 r = sd_id128_get_machine(&id);
1853                 if (r < 0)
1854                         return r;
1855
1856                 r = sd_bus_message_new_method_return(bus, m, &reply);
1857                 if (r < 0)
1858                         return r;
1859
1860                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
1861         } else {
1862                 r = sd_bus_message_new_method_errorf(
1863                                 bus, m, &reply,
1864                                 "org.freedesktop.DBus.Error.UnknownMethod",
1865                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
1866         }
1867
1868         if (r < 0)
1869                 return r;
1870
1871         r = sd_bus_send(bus, reply, NULL);
1872         if (r < 0)
1873                 return r;
1874
1875         return 1;
1876 }
1877
1878 static int node_vtable_get_userdata(
1879                 sd_bus *bus,
1880                 const char *path,
1881                 struct node_vtable *c,
1882                 void **userdata) {
1883
1884         void *u;
1885         int r;
1886
1887         assert(bus);
1888         assert(path);
1889         assert(c);
1890
1891         u = c->userdata;
1892         if (c->find) {
1893                 r = c->find(bus, path, c->interface, &u, u);
1894                 if (r <= 0)
1895                         return r;
1896         }
1897
1898         if (userdata)
1899                 *userdata = u;
1900
1901         return 1;
1902 }
1903
1904 static void *vtable_property_convert_userdata(const sd_bus_vtable *p, void *u) {
1905         assert(p);
1906
1907         return (uint8_t*) u + p->property.offset;
1908 }
1909
1910 static int vtable_property_get_userdata(
1911                 sd_bus *bus,
1912                 const char *path,
1913                 struct vtable_member *p,
1914                 void **userdata) {
1915
1916         void *u;
1917         int r;
1918
1919         assert(bus);
1920         assert(path);
1921         assert(p);
1922         assert(userdata);
1923
1924         r = node_vtable_get_userdata(bus, path, p->parent, &u);
1925         if (r <= 0)
1926                 return r;
1927
1928         *userdata = vtable_property_convert_userdata(p->vtable, u);
1929         return 1;
1930 }
1931
1932 static int add_enumerated_to_set(sd_bus *bus, const char *prefix, struct node_enumerator *first, Set *s) {
1933         struct node_enumerator *c;
1934         int r;
1935
1936         assert(bus);
1937         assert(prefix);
1938         assert(s);
1939
1940         LIST_FOREACH(enumerators, c, first) {
1941                 char **children = NULL, **k;
1942
1943                 r = c->callback(bus, prefix, &children, c->userdata);
1944                 if (r < 0)
1945                         return r;
1946
1947                 STRV_FOREACH(k, children) {
1948                         if (r < 0) {
1949                                 free(*k);
1950                                 continue;
1951                         }
1952
1953                         if (!object_path_is_valid(*k) && object_path_startswith(*k, prefix)) {
1954                                 free(*k);
1955                                 r = -EINVAL;
1956                                 continue;
1957                         }
1958
1959                         r = set_consume(s, *k);
1960                 }
1961
1962                 free(children);
1963                 if (r < 0)
1964                         return r;
1965         }
1966
1967         return 0;
1968 }
1969
1970 static int add_subtree_to_set(sd_bus *bus, const char *prefix, struct node *n, Set *s) {
1971         struct node *i;
1972         int r;
1973
1974         assert(bus);
1975         assert(prefix);
1976         assert(n);
1977         assert(s);
1978
1979         r = add_enumerated_to_set(bus, prefix, n->enumerators, s);
1980         if (r < 0)
1981                 return r;
1982
1983         LIST_FOREACH(siblings, i, n->child) {
1984                 char *t;
1985
1986                 t = strdup(i->path);
1987                 if (!t)
1988                         return -ENOMEM;
1989
1990                 r = set_consume(s, t);
1991                 if (r < 0 && r != -EEXIST)
1992                         return r;
1993
1994                 r = add_subtree_to_set(bus, prefix, i, s);
1995                 if (r < 0)
1996                         return r;
1997         }
1998
1999         return 0;
2000 }
2001
2002 static int get_child_nodes(sd_bus *bus, const char *prefix, struct node *n, Set **_s) {
2003         Set *s = NULL;
2004         int r;
2005
2006         assert(bus);
2007         assert(n);
2008         assert(_s);
2009
2010         s = set_new(string_hash_func, string_compare_func);
2011         if (!s)
2012                 return -ENOMEM;
2013
2014         r = add_subtree_to_set(bus, prefix, n, s);
2015         if (r < 0) {
2016                 set_free_free(s);
2017                 return r;
2018         }
2019
2020         *_s = s;
2021         return 0;
2022 }
2023
2024 static int node_callbacks_run(
2025                 sd_bus *bus,
2026                 sd_bus_message *m,
2027                 struct node_callback *first,
2028                 bool require_fallback,
2029                 bool *found_object) {
2030
2031         struct node_callback *c;
2032         int r;
2033
2034         assert(bus);
2035         assert(m);
2036         assert(found_object);
2037
2038         LIST_FOREACH(callbacks, c, first) {
2039                 if (require_fallback && !c->is_fallback)
2040                         continue;
2041
2042                 *found_object = true;
2043
2044                 if (c->last_iteration == bus->iteration_counter)
2045                         continue;
2046
2047                 r = sd_bus_message_rewind(m, true);
2048                 if (r < 0)
2049                         return r;
2050
2051                 r = c->callback(bus, m, c->userdata);
2052                 if (r != 0)
2053                         return r;
2054         }
2055
2056         return 0;
2057 }
2058
2059 static int method_callbacks_run(
2060                 sd_bus *bus,
2061                 sd_bus_message *m,
2062                 struct vtable_member *c,
2063                 bool require_fallback,
2064                 bool *found_object) {
2065
2066         const char *signature;
2067         void *u;
2068         int r;
2069
2070         assert(bus);
2071         assert(m);
2072         assert(c);
2073         assert(found_object);
2074
2075         if (require_fallback && !c->parent->is_fallback)
2076                 return 0;
2077
2078         r = node_vtable_get_userdata(bus, m->path, c->parent, &u);
2079         if (r <= 0)
2080                 return r;
2081
2082         *found_object = true;
2083
2084         r = sd_bus_message_rewind(m, true);
2085         if (r < 0)
2086                 return r;
2087
2088         r = sd_bus_message_get_signature(m, true, &signature);
2089         if (r < 0)
2090                 return r;
2091
2092         if (!streq(strempty(c->vtable->method.signature), signature)) {
2093                 r = sd_bus_reply_method_errorf(bus, m,
2094                                                "org.freedesktop.DBus.Error.InvalidArgs",
2095                                                "Invalid arguments '%s' to call %s:%s, expecting '%s'.",
2096                                                signature, c->interface, c->member, strempty(c->vtable->method.signature));
2097                 if (r < 0)
2098                         return r;
2099
2100                 return 1;
2101         }
2102
2103         if (c->vtable->method.handler)
2104                 return c->vtable->method.handler(bus, m, u);
2105
2106         /* If the method callback is NULL, make this a successful NOP */
2107         r = sd_bus_reply_method_return(bus, m, NULL);
2108         if (r < 0)
2109                 return r;
2110
2111         return 1;
2112 }
2113
2114 static int invoke_property_get(
2115                 sd_bus *bus,
2116                 const sd_bus_vtable *v,
2117                 const char *path,
2118                 const char *interface,
2119                 const char *property,
2120                 sd_bus_message *m,
2121                 sd_bus_error *error,
2122                 void *userdata) {
2123
2124         int r;
2125         void *p;
2126
2127         assert(bus);
2128         assert(v);
2129
2130         if (v->property.get)
2131                 return v->property.get(bus, path, interface, property, m, error, userdata);
2132
2133         /* Automatic handling if no callback is defined. */
2134
2135         assert(bus_type_is_basic(v->property.signature[0]));
2136
2137         switch (v->property.signature[0]) {
2138
2139         case SD_BUS_TYPE_STRING:
2140         case SD_BUS_TYPE_OBJECT_PATH:
2141         case SD_BUS_TYPE_SIGNATURE:
2142                 p = *(char**) userdata;
2143                 break;
2144
2145         default:
2146                 p = userdata;
2147                 break;
2148         }
2149
2150         r = sd_bus_message_append_basic(m, v->property.signature[0], p);
2151         if (r < 0)
2152                 return r;
2153
2154         return 1;
2155 }
2156
2157 static int invoke_property_set(
2158                 sd_bus *bus,
2159                 const sd_bus_vtable *v,
2160                 const char *path,
2161                 const char *interface,
2162                 const char *property,
2163                 sd_bus_message *value,
2164                 sd_bus_error *error,
2165                 void *userdata) {
2166
2167         int r;
2168
2169         assert(bus);
2170         assert(v);
2171
2172         if (v->property.set)
2173                 return v->property.set(bus, path, interface, property, value, error, userdata);
2174
2175         /*  Automatic handling if no callback is defined. */
2176
2177         assert(signature_is_single(v->property.signature, false));
2178         assert(bus_type_is_basic(v->property.signature[0]));
2179
2180         switch (v->property.signature[0]) {
2181
2182         case SD_BUS_TYPE_STRING:
2183         case SD_BUS_TYPE_OBJECT_PATH:
2184         case SD_BUS_TYPE_SIGNATURE: {
2185                 const char *p;
2186                 char *n;
2187
2188                 r = sd_bus_message_read_basic(value, v->property.signature[0], &p);
2189                 if (r < 0)
2190                         return r;
2191
2192                 n = strdup(p);
2193                 if (!n)
2194                         return -ENOMEM;
2195
2196                 free(*(char**) userdata);
2197                 *(char**) userdata = n;
2198
2199                 break;
2200         }
2201
2202         default:
2203                 r = sd_bus_message_read_basic(value, v->property.signature[0], userdata);
2204                 if (r < 0)
2205                         return r;
2206
2207                 break;
2208         }
2209
2210         return 1;
2211 }
2212
2213 static int property_get_set_callbacks_run(
2214                 sd_bus *bus,
2215                 sd_bus_message *m,
2216                 struct vtable_member *c,
2217                 bool require_fallback,
2218                 bool is_get,
2219                 bool *found_object) {
2220
2221         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2222         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2223         void *u;
2224         int r;
2225
2226         assert(bus);
2227         assert(m);
2228         assert(found_object);
2229
2230         if (require_fallback && !c->parent->is_fallback)
2231                 return 0;
2232
2233         r = vtable_property_get_userdata(bus, m->path, c, &u);
2234         if (r <= 0)
2235                 return r;
2236
2237         *found_object = true;
2238
2239         r = sd_bus_message_new_method_return(bus, m, &reply);
2240         if (r < 0)
2241                 return r;
2242
2243         c->last_iteration = bus->iteration_counter;
2244
2245         if (is_get) {
2246                 r = sd_bus_message_open_container(reply, 'v', c->vtable->property.signature);
2247                 if (r < 0)
2248                         return r;
2249
2250                 r = invoke_property_get(bus, c->vtable, m->path, c->interface, c->member, reply, &error, u);
2251                 if (r < 0)
2252                         return r;
2253
2254                 if (sd_bus_error_is_set(&error)) {
2255                         r = sd_bus_reply_method_error(bus, m, &error);
2256                         if (r < 0)
2257                                 return r;
2258
2259                         return 1;
2260                 }
2261
2262                 r = sd_bus_message_close_container(reply);
2263                 if (r < 0)
2264                         return r;
2265
2266         } else {
2267                 if (c->vtable->type != _SD_BUS_VTABLE_WRITABLE_PROPERTY)
2268                         sd_bus_error_setf(&error, "org.freedesktop.DBus.Error.PropertyReadOnly", "Property '%s' is not writable.", c->member);
2269                 else  {
2270                         r = sd_bus_message_enter_container(m, 'v', c->vtable->property.signature);
2271                         if (r < 0)
2272                                 return r;
2273
2274                         r = invoke_property_set(bus, c->vtable, m->path, c->interface, c->member, m, &error, u);
2275                         if (r < 0)
2276                                 return r;
2277                 }
2278
2279                 if (sd_bus_error_is_set(&error)) {
2280                         r = sd_bus_reply_method_error(bus, m, &error);
2281                         if (r < 0)
2282                                 return r;
2283
2284                         return 1;
2285                 }
2286
2287                 r = sd_bus_message_exit_container(m);
2288                 if (r < 0)
2289                         return r;
2290         }
2291
2292         r = sd_bus_send(bus, reply, NULL);
2293         if (r < 0)
2294                 return r;
2295
2296         return 1;
2297 }
2298
2299 static int vtable_append_all_properties(
2300                 sd_bus *bus,
2301                 sd_bus_message *reply,
2302                 const char *path,
2303                 struct node_vtable *c,
2304                 void *userdata,
2305                 sd_bus_error *error) {
2306
2307         const sd_bus_vtable *v;
2308         int r;
2309
2310         assert(bus);
2311         assert(reply);
2312         assert(c);
2313
2314         for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
2315                 if (v->type != _SD_BUS_VTABLE_PROPERTY && v->type != _SD_BUS_VTABLE_WRITABLE_PROPERTY)
2316                         continue;
2317
2318                 r = sd_bus_message_open_container(reply, 'e', "sv");
2319                 if (r < 0)
2320                         return r;
2321
2322                 r = sd_bus_message_append(reply, "s", c->interface);
2323                 if (r < 0)
2324                         return r;
2325
2326                 r = sd_bus_message_open_container(reply, 'v', v->property.signature);
2327                 if (r < 0)
2328                         return r;
2329
2330                 r = invoke_property_get(bus, v, path, c->interface, v->property.member, reply, error, vtable_property_convert_userdata(v, userdata));
2331                 if (r < 0)
2332                         return r;
2333
2334                 if (sd_bus_error_is_set(error))
2335                         return 0;
2336
2337                 r = sd_bus_message_close_container(reply);
2338                 if (r < 0)
2339                         return r;
2340
2341                 r = sd_bus_message_close_container(reply);
2342                 if (r < 0)
2343                         return r;
2344         }
2345
2346         return 1;
2347 }
2348
2349 static int property_get_all_callbacks_run(
2350                 sd_bus *bus,
2351                 sd_bus_message *m,
2352                 struct node_vtable *first,
2353                 bool require_fallback,
2354                 const char *iface,
2355                 bool *found_object) {
2356
2357         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2358         struct node_vtable *c;
2359         bool found_interface = false;
2360         int r;
2361
2362         assert(bus);
2363         assert(m);
2364         assert(found_object);
2365
2366         r = sd_bus_message_new_method_return(bus, m, &reply);
2367         if (r < 0)
2368                 return r;
2369
2370         r = sd_bus_message_open_container(reply, 'a', "{sv}");
2371         if (r < 0)
2372                 return r;
2373
2374         LIST_FOREACH(vtables, c, first) {
2375                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2376                 void *u;
2377
2378                 if (require_fallback && !c->is_fallback)
2379                         continue;
2380
2381                 r = node_vtable_get_userdata(bus, m->path, c, &u);
2382                 if (r < 0)
2383                         return r;
2384                 if (r == 0)
2385                         continue;
2386
2387                 *found_object = true;
2388
2389                 if (iface && !streq(c->interface, iface))
2390                         continue;
2391                 found_interface = true;
2392
2393                 c->last_iteration = bus->iteration_counter;
2394
2395                 r = vtable_append_all_properties(bus, reply, m->path, c, u, &error);
2396                 if (r < 0)
2397                         return r;
2398
2399                 if (sd_bus_error_is_set(&error)) {
2400                         r = sd_bus_reply_method_error(bus, m, &error);
2401                         if (r < 0)
2402                                 return r;
2403
2404                         return 1;
2405                 }
2406         }
2407
2408         if (!found_interface) {
2409                 r = sd_bus_reply_method_errorf(
2410                                 bus, m,
2411                                 "org.freedesktop.DBus.Error.UnknownInterface",
2412                                 "Unknown interface '%s'.", iface);
2413                 if (r < 0)
2414                         return r;
2415
2416                 return 1;
2417         }
2418
2419         r = sd_bus_message_close_container(reply);
2420         if (r < 0)
2421                 return r;
2422
2423         r = sd_bus_send(bus, reply, NULL);
2424         if (r < 0)
2425                 return r;
2426
2427         return 1;
2428 }
2429
2430 static bool bus_node_with_object_manager(sd_bus *bus, struct node *n) {
2431         assert(bus);
2432
2433         if (n->object_manager)
2434                 return true;
2435
2436         if (n->parent)
2437                 return bus_node_with_object_manager(bus, n->parent);
2438
2439         return false;
2440 }
2441
2442 static bool bus_node_exists(sd_bus *bus, struct node *n, const char *path, bool require_fallback) {
2443         struct node_vtable *c;
2444         struct node_callback *k;
2445
2446         assert(bus);
2447         assert(n);
2448
2449         /* Tests if there's anything attached directly to this node
2450          * for the specified path */
2451
2452         LIST_FOREACH(callbacks, k, n->callbacks) {
2453                 if (require_fallback && !k->is_fallback)
2454                         continue;
2455
2456                 return true;
2457         }
2458
2459         LIST_FOREACH(vtables, c, n->vtables) {
2460
2461                 if (require_fallback && !c->is_fallback)
2462                         continue;
2463
2464                 if (node_vtable_get_userdata(bus, path, c, NULL) > 0)
2465                         return true;
2466         }
2467
2468         return !require_fallback && (n->enumerators || n->object_manager);
2469 }
2470
2471 static int process_introspect(
2472                 sd_bus *bus,
2473                 sd_bus_message *m,
2474                 struct node *n,
2475                 bool require_fallback,
2476                 bool *found_object) {
2477
2478         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2479         _cleanup_set_free_free_ Set *s = NULL;
2480         struct introspect intro;
2481         struct node_vtable *c;
2482         bool empty;
2483         int r;
2484
2485         assert(bus);
2486         assert(m);
2487         assert(n);
2488         assert(found_object);
2489
2490         r = get_child_nodes(bus, m->path, n, &s);
2491         if (r < 0)
2492                 return r;
2493
2494         r = introspect_begin(&intro);
2495         if (r < 0)
2496                 return r;
2497
2498         r = introspect_write_default_interfaces(&intro, bus_node_with_object_manager(bus, n));
2499         if (r < 0)
2500                 return r;
2501
2502         empty = set_isempty(s);
2503
2504         LIST_FOREACH(vtables, c, n->vtables) {
2505                 if (require_fallback && !c->is_fallback)
2506                         continue;
2507
2508                 r = node_vtable_get_userdata(bus, m->path, c, NULL);
2509                 if (r < 0)
2510                         return r;
2511                 if (r == 0)
2512                         continue;
2513
2514                 empty = false;
2515
2516                 r = introspect_write_interface(&intro, c->interface, c->vtable);
2517                 if (r < 0)
2518                         goto finish;
2519         }
2520
2521         if (empty) {
2522                 /* Nothing?, let's see if we exist at all, and if not
2523                  * refuse to do anything */
2524                 r = bus_node_exists(bus, n, m->path, require_fallback);
2525                 if (r < 0)
2526                         return r;
2527
2528                 if (r == 0)
2529                         goto finish;
2530         }
2531
2532         *found_object = true;
2533
2534         r = introspect_write_child_nodes(&intro, s, m->path);
2535         if (r < 0)
2536                 goto finish;
2537
2538         r = introspect_finish(&intro, bus, m, &reply);
2539         if (r < 0)
2540                 goto finish;
2541
2542         r = sd_bus_send(bus, reply, NULL);
2543         if (r < 0)
2544                 goto finish;
2545
2546         r = 1;
2547
2548 finish:
2549         introspect_free(&intro);
2550         return r;
2551 }
2552
2553 static int object_manager_serialize_vtable(
2554                 sd_bus *bus,
2555                 sd_bus_message *reply,
2556                 const char *path,
2557                 struct node_vtable *c,
2558                 sd_bus_error *error) {
2559
2560         void *u;
2561         int r;
2562
2563         assert(bus);
2564         assert(reply);
2565         assert(path);
2566         assert(c);
2567         assert(error);
2568
2569         r = node_vtable_get_userdata(bus, path, c, &u);
2570         if (r <= 0)
2571                 return r;
2572
2573         r = sd_bus_message_open_container(reply, 'e', "sa{sv}");
2574         if (r < 0)
2575                 return r;
2576
2577         r = sd_bus_message_append(reply, "s", c->interface);
2578         if (r < 0)
2579                 return r;
2580
2581         r = sd_bus_message_open_container(reply, 'a', "{sv}");
2582         if (r < 0)
2583                 return r;
2584
2585         r = vtable_append_all_properties(bus, reply, path, c, u, error);
2586         if (r < 0)
2587                 return r;
2588
2589         r = sd_bus_message_close_container(reply);
2590         if (r < 0)
2591                 return r;
2592
2593         r = sd_bus_message_close_container(reply);
2594         if (r < 0)
2595                 return r;
2596
2597         return 0;
2598 }
2599
2600 static int object_manager_serialize_path(
2601                 sd_bus *bus,
2602                 sd_bus_message *reply,
2603                 const char *prefix,
2604                 const char *path,
2605                 bool require_fallback,
2606                 sd_bus_error *error) {
2607
2608         struct node_vtable *i;
2609         struct node *n;
2610         int r;
2611
2612         assert(bus);
2613         assert(reply);
2614         assert(prefix);
2615         assert(path);
2616         assert(error);
2617
2618         n = hashmap_get(bus->nodes, prefix);
2619         if (!n)
2620                 return 0;
2621
2622         r = sd_bus_message_open_container(reply, 'e', "oa{sa{sv}}");
2623         if (r < 0)
2624                 return r;
2625
2626         r = sd_bus_message_append(reply, "o", path);
2627         if (r < 0)
2628                 return r;
2629
2630         r = sd_bus_message_open_container(reply, 'a', "{sa{sv}}");
2631         if (r < 0)
2632                 return r;
2633
2634         LIST_FOREACH(vtables, i, n->vtables) {
2635
2636                 if (require_fallback && !i->is_fallback)
2637                         continue;
2638
2639                 r = object_manager_serialize_vtable(bus, reply, path, i, error);
2640                 if (r < 0)
2641                         return r;
2642                 if (sd_bus_error_is_set(error))
2643                         return 0;
2644         }
2645
2646         r = sd_bus_message_close_container(reply);
2647         if (r < 0)
2648                 return r;
2649
2650         r = sd_bus_message_close_container(reply);
2651         if (r < 0)
2652                 return r;
2653
2654         return 1;
2655 }
2656
2657 static int object_manager_serialize_path_and_fallbacks(
2658                 sd_bus *bus,
2659                 sd_bus_message *reply,
2660                 const char *path,
2661                 sd_bus_error *error) {
2662
2663         size_t pl;
2664         int r;
2665
2666         assert(bus);
2667         assert(reply);
2668         assert(path);
2669         assert(error);
2670
2671         /* First, add all vtables registered for this path */
2672         r = object_manager_serialize_path(bus, reply, path, path, false, error);
2673         if (r < 0)
2674                 return r;
2675         if (sd_bus_error_is_set(error))
2676                 return 0;
2677
2678         /* Second, add fallback vtables registered for any of the prefixes */
2679         pl = strlen(path);
2680         if (pl > 1) {
2681                 char p[pl + 1];
2682                 strcpy(p, path);
2683
2684                 for (;;) {
2685                         char *e;
2686
2687                         e = strrchr(p, '/');
2688                         if (e == p || !e)
2689                                 break;
2690
2691                         *e = 0;
2692
2693                         r = object_manager_serialize_path(bus, reply, p, path, true, error);
2694                         if (r < 0)
2695                                 return r;
2696
2697                         if (sd_bus_error_is_set(error))
2698                                 return 0;
2699                 }
2700         }
2701
2702         return 0;
2703 }
2704
2705 static int process_get_managed_objects(
2706                 sd_bus *bus,
2707                 sd_bus_message *m,
2708                 struct node *n,
2709                 bool require_fallback,
2710                 bool *found_object) {
2711
2712         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2713         _cleanup_set_free_free_ Set *s = NULL;
2714         bool empty;
2715         int r;
2716
2717         assert(bus);
2718         assert(m);
2719         assert(n);
2720         assert(found_object);
2721
2722         if (!bus_node_with_object_manager(bus, n))
2723                 return 0;
2724
2725         r = get_child_nodes(bus, m->path, n, &s);
2726         if (r < 0)
2727                 return r;
2728
2729         r = sd_bus_message_new_method_return(bus, m, &reply);
2730         if (r < 0)
2731                 return r;
2732
2733         r = sd_bus_message_open_container(reply, 'a', "{oa{sa{sv}}}");
2734         if (r < 0)
2735                 return r;
2736
2737         empty = set_isempty(s);
2738         if (empty) {
2739                 struct node_vtable *c;
2740
2741                 /* Hmm, so we have no children? Then let's check
2742                  * whether we exist at all, i.e. whether at least one
2743                  * vtable exists. */
2744
2745                 LIST_FOREACH(vtables, c, n->vtables) {
2746
2747                         if (require_fallback && !c->is_fallback)
2748                                 continue;
2749
2750                         if (r < 0)
2751                                 return r;
2752                         if (r == 0)
2753                                 continue;
2754
2755                         empty = false;
2756                         break;
2757                 }
2758
2759                 if (empty)
2760                         return 0;
2761         } else {
2762                 Iterator i;
2763                 char *path;
2764
2765                 SET_FOREACH(path, s, i) {
2766                         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2767
2768                         r = object_manager_serialize_path_and_fallbacks(bus, reply, path, &error);
2769                         if (r < 0)
2770                                 return -ENOMEM;
2771
2772                         if (sd_bus_error_is_set(&error)) {
2773                                 r = sd_bus_reply_method_error(bus, m, &error);
2774                                 if (r < 0)
2775                                         return r;
2776
2777                                 return 1;
2778                         }
2779                 }
2780         }
2781
2782         r = sd_bus_message_close_container(reply);
2783         if (r < 0)
2784                 return r;
2785
2786         r = sd_bus_send(bus, reply, NULL);
2787         if (r < 0)
2788                 return r;
2789
2790         return 1;
2791 }
2792
2793 static int object_find_and_run(
2794                 sd_bus *bus,
2795                 sd_bus_message *m,
2796                 const char *p,
2797                 bool require_fallback,
2798                 bool *found_object) {
2799
2800         struct node *n;
2801         struct vtable_member vtable_key, *v;
2802         int r;
2803
2804         assert(bus);
2805         assert(m);
2806         assert(p);
2807         assert(found_object);
2808
2809         n = hashmap_get(bus->nodes, p);
2810         if (!n)
2811                 return 0;
2812
2813         /* First, try object callbacks */
2814         r = node_callbacks_run(bus, m, n->callbacks, require_fallback, found_object);
2815         if (r != 0)
2816                 return r;
2817
2818         if (!m->interface || !m->member)
2819                 return 0;
2820
2821         /* Then, look for a known method */
2822         vtable_key.path = (char*) p;
2823         vtable_key.interface = m->interface;
2824         vtable_key.member = m->member;
2825
2826         v = hashmap_get(bus->vtable_methods, &vtable_key);
2827         if (v) {
2828                 r = method_callbacks_run(bus, m, v, require_fallback, found_object);
2829                 if (r != 0)
2830                         return r;
2831         }
2832
2833         /* Then, look for a known property */
2834         if (streq(m->interface, "org.freedesktop.DBus.Properties")) {
2835                 bool get = false;
2836
2837                 get = streq(m->member, "Get");
2838
2839                 if (get || streq(m->member, "Set")) {
2840
2841                         r = sd_bus_message_rewind(m, true);
2842                         if (r < 0)
2843                                 return r;
2844
2845                         vtable_key.path = (char*) p;
2846
2847                         r = sd_bus_message_read(m, "ss", &vtable_key.interface, &vtable_key.member);
2848                         if (r < 0)
2849                                 return r;
2850
2851                         v = hashmap_get(bus->vtable_properties, &vtable_key);
2852                         if (v) {
2853                                 r = property_get_set_callbacks_run(bus, m, v, require_fallback, get, found_object);
2854                                 if (r != 0)
2855                                         return r;
2856                         }
2857
2858                 } else if (streq(m->member, "GetAll")) {
2859                         const char *iface;
2860
2861                         r = sd_bus_message_rewind(m, true);
2862                         if (r < 0)
2863                                 return r;
2864
2865                         r = sd_bus_message_read(m, "s", &iface);
2866                         if (r < 0)
2867                                 return r;
2868
2869                         if (iface[0] == 0)
2870                                 iface = NULL;
2871
2872                         r = property_get_all_callbacks_run(bus, m, n->vtables, require_fallback, iface, found_object);
2873                         if (r != 0)
2874                                 return r;
2875                 }
2876
2877         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
2878
2879                 r = process_introspect(bus, m, n, require_fallback, found_object);
2880                 if (r != 0)
2881                         return r;
2882
2883         } else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.ObjectManager", "GetManagedObjects")) {
2884
2885                 r = process_get_managed_objects(bus, m, n, require_fallback, found_object);
2886                 if (r != 0)
2887                         return r;
2888         }
2889
2890         if (!*found_object) {
2891                 r = bus_node_exists(bus, n, m->path, require_fallback);
2892                 if (r < 0)
2893                         return r;
2894
2895                 if (r > 0)
2896                         *found_object = true;
2897         }
2898
2899         return 0;
2900 }
2901
2902 static int process_object(sd_bus *bus, sd_bus_message *m) {
2903         int r;
2904         size_t pl;
2905         bool found_object = false;
2906
2907         assert(bus);
2908         assert(m);
2909
2910         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
2911                 return 0;
2912
2913         if (!m->path)
2914                 return 0;
2915
2916         if (hashmap_isempty(bus->nodes))
2917                 return 0;
2918
2919         pl = strlen(m->path);
2920         do {
2921                 char p[pl+1];
2922
2923                 bus->nodes_modified = false;
2924
2925                 r = object_find_and_run(bus, m, m->path, false, &found_object);
2926                 if (r != 0)
2927                         return r;
2928
2929                 /* Look for fallback prefixes */
2930                 strcpy(p, m->path);
2931                 for (;;) {
2932                         char *e;
2933
2934                         if (streq(p, "/"))
2935                                 break;
2936
2937                         if (bus->nodes_modified)
2938                                 break;
2939
2940                         e = strrchr(p, '/');
2941                         assert(e);
2942                         if (e == p)
2943                                 *(e+1) = 0;
2944                         else
2945                                 *e = 0;
2946
2947                         r = object_find_and_run(bus, m, p, true, &found_object);
2948                         if (r != 0)
2949                                 return r;
2950                 }
2951
2952         } while (bus->nodes_modified);
2953
2954         if (!found_object)
2955                 return 0;
2956
2957         if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get") ||
2958             sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Set"))
2959                 r = sd_bus_reply_method_errorf(
2960                                 bus, m,
2961                                 "org.freedesktop.DBus.Error.UnknownProperty",
2962                                 "Unknown property or interface.");
2963         else
2964                 r = sd_bus_reply_method_errorf(
2965                                 bus, m,
2966                                 "org.freedesktop.DBus.Error.UnknownMethod",
2967                                 "Unknown method '%s' or interface '%s'.", m->member, m->interface);
2968
2969         if (r < 0)
2970                 return r;
2971
2972         return 1;
2973 }
2974
2975 static int process_message(sd_bus *bus, sd_bus_message *m) {
2976         int r;
2977
2978         assert(bus);
2979         assert(m);
2980
2981         bus->iteration_counter++;
2982
2983         r = process_hello(bus, m);
2984         if (r != 0)
2985                 return r;
2986
2987         r = process_reply(bus, m);
2988         if (r != 0)
2989                 return r;
2990
2991         r = process_filter(bus, m);
2992         if (r != 0)
2993                 return r;
2994
2995         r = process_match(bus, m);
2996         if (r != 0)
2997                 return r;
2998
2999         r = process_builtin(bus, m);
3000         if (r != 0)
3001                 return r;
3002
3003         return process_object(bus, m);
3004 }
3005
3006 static int process_running(sd_bus *bus, sd_bus_message **ret) {
3007         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3008         int r;
3009
3010         assert(bus);
3011         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
3012
3013         r = process_timeout(bus);
3014         if (r != 0)
3015                 goto null_message;
3016
3017         r = dispatch_wqueue(bus);
3018         if (r != 0)
3019                 goto null_message;
3020
3021         r = dispatch_rqueue(bus, &m);
3022         if (r < 0)
3023                 return r;
3024         if (!m)
3025                 goto null_message;
3026
3027         r = process_message(bus, m);
3028         if (r != 0)
3029                 goto null_message;
3030
3031         if (ret) {
3032                 r = sd_bus_message_rewind(m, true);
3033                 if (r < 0)
3034                         return r;
3035
3036                 *ret = m;
3037                 m = NULL;
3038                 return 1;
3039         }
3040
3041         if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL) {
3042
3043                 r = sd_bus_reply_method_errorf(
3044                                 bus, m,
3045                                 "org.freedesktop.DBus.Error.UnknownObject",
3046                                 "Unknown object '%s'.", m->path);
3047                 if (r < 0)
3048                         return r;
3049         }
3050
3051         return 1;
3052
3053 null_message:
3054         if (r >= 0 && ret)
3055                 *ret = NULL;
3056
3057         return r;
3058 }
3059
3060 int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
3061         int r;
3062
3063         /* Returns 0 when we didn't do anything. This should cause the
3064          * caller to invoke sd_bus_wait() before returning the next
3065          * time. Returns > 0 when we did something, which possibly
3066          * means *ret is filled in with an unprocessed message. */
3067
3068         if (!bus)
3069                 return -EINVAL;
3070         if (bus_pid_changed(bus))
3071                 return -ECHILD;
3072
3073         /* We don't allow recursively invoking sd_bus_process(). */
3074         if (bus->processing)
3075                 return -EBUSY;
3076
3077         switch (bus->state) {
3078
3079         case BUS_UNSET:
3080         case BUS_CLOSED:
3081                 return -ENOTCONN;
3082
3083         case BUS_OPENING:
3084                 r = bus_socket_process_opening(bus);
3085                 if (r < 0)
3086                         return r;
3087                 if (ret)
3088                         *ret = NULL;
3089                 return r;
3090
3091         case BUS_AUTHENTICATING:
3092
3093                 r = bus_socket_process_authenticating(bus);
3094                 if (r < 0)
3095                         return r;
3096                 if (ret)
3097                         *ret = NULL;
3098                 return r;
3099
3100         case BUS_RUNNING:
3101         case BUS_HELLO:
3102
3103                 bus->processing = true;
3104                 r = process_running(bus, ret);
3105                 bus->processing = false;
3106
3107                 return r;
3108         }
3109
3110         assert_not_reached("Unknown state");
3111 }
3112
3113 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
3114         struct pollfd p[2] = {};
3115         int r, e, n;
3116         struct timespec ts;
3117         usec_t until, m;
3118
3119         assert(bus);
3120
3121         if (!BUS_IS_OPEN(bus->state))
3122                 return -ENOTCONN;
3123
3124         e = sd_bus_get_events(bus);
3125         if (e < 0)
3126                 return e;
3127
3128         if (need_more)
3129                 e |= POLLIN;
3130
3131         r = sd_bus_get_timeout(bus, &until);
3132         if (r < 0)
3133                 return r;
3134         if (r == 0)
3135                 m = (uint64_t) -1;
3136         else {
3137                 usec_t nw;
3138                 nw = now(CLOCK_MONOTONIC);
3139                 m = until > nw ? until - nw : 0;
3140         }
3141
3142         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
3143                 m = timeout_usec;
3144
3145         p[0].fd = bus->input_fd;
3146         if (bus->output_fd == bus->input_fd) {
3147                 p[0].events = e;
3148                 n = 1;
3149         } else {
3150                 p[0].events = e & POLLIN;
3151                 p[1].fd = bus->output_fd;
3152                 p[1].events = e & POLLOUT;
3153                 n = 2;
3154         }
3155
3156         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
3157         if (r < 0)
3158                 return -errno;
3159
3160         return r > 0 ? 1 : 0;
3161 }
3162
3163 int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
3164
3165         if (!bus)
3166                 return -EINVAL;
3167         if (!BUS_IS_OPEN(bus->state))
3168                 return -ENOTCONN;
3169         if (bus_pid_changed(bus))
3170                 return -ECHILD;
3171
3172         if (bus->rqueue_size > 0)
3173                 return 0;
3174
3175         return bus_poll(bus, false, timeout_usec);
3176 }
3177
3178 int sd_bus_flush(sd_bus *bus) {
3179         int r;
3180
3181         if (!bus)
3182                 return -EINVAL;
3183         if (!BUS_IS_OPEN(bus->state))
3184                 return -ENOTCONN;
3185         if (bus_pid_changed(bus))
3186                 return -ECHILD;
3187
3188         r = bus_ensure_running(bus);
3189         if (r < 0)
3190                 return r;
3191
3192         if (bus->wqueue_size <= 0)
3193                 return 0;
3194
3195         for (;;) {
3196                 r = dispatch_wqueue(bus);
3197                 if (r < 0)
3198                         return r;
3199
3200                 if (bus->wqueue_size <= 0)
3201                         return 0;
3202
3203                 r = bus_poll(bus, false, (uint64_t) -1);
3204                 if (r < 0)
3205                         return r;
3206         }
3207 }
3208
3209 int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
3210         struct filter_callback *f;
3211
3212         if (!bus)
3213                 return -EINVAL;
3214         if (!callback)
3215                 return -EINVAL;
3216         if (bus_pid_changed(bus))
3217                 return -ECHILD;
3218
3219         f = new0(struct filter_callback, 1);
3220         if (!f)
3221                 return -ENOMEM;
3222         f->callback = callback;
3223         f->userdata = userdata;
3224
3225         bus->filter_callbacks_modified = true;
3226         LIST_PREPEND(struct filter_callback, callbacks, bus->filter_callbacks, f);
3227         return 0;
3228 }
3229
3230 int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
3231         struct filter_callback *f;
3232
3233         if (!bus)
3234                 return -EINVAL;
3235         if (!callback)
3236                 return -EINVAL;
3237         if (bus_pid_changed(bus))
3238                 return -ECHILD;
3239
3240         LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
3241                 if (f->callback == callback && f->userdata == userdata) {
3242                         bus->filter_callbacks_modified = true;
3243                         LIST_REMOVE(struct filter_callback, callbacks, bus->filter_callbacks, f);
3244                         free(f);
3245                         return 1;
3246                 }
3247         }
3248
3249         return 0;
3250 }
3251
3252 static struct node *bus_node_allocate(sd_bus *bus, const char *path) {
3253         struct node *n, *parent;
3254         const char *e;
3255         char *s, *p;
3256         int r;
3257
3258         assert(bus);
3259         assert(path);
3260         assert(path[0] == '/');
3261
3262         n = hashmap_get(bus->nodes, path);
3263         if (n)
3264                 return n;
3265
3266         r = hashmap_ensure_allocated(&bus->nodes, string_hash_func, string_compare_func);
3267         if (r < 0)
3268                 return NULL;
3269
3270         s = strdup(path);
3271         if (!s)
3272                 return NULL;
3273
3274         if (streq(path, "/"))
3275                 parent = NULL;
3276         else {
3277                 e = strrchr(path, '/');
3278                 assert(e);
3279
3280                 p = strndupa(path, MAX(1, path - e));
3281
3282                 parent = bus_node_allocate(bus, p);
3283                 if (!parent) {
3284                         free(s);
3285                         return NULL;
3286                 }
3287         }
3288
3289         n = new0(struct node, 1);
3290         if (!n)
3291                 return NULL;
3292
3293         n->parent = parent;
3294         n->path = s;
3295
3296         r = hashmap_put(bus->nodes, s, n);
3297         if (r < 0) {
3298                 free(s);
3299                 free(n);
3300                 return NULL;
3301         }
3302
3303         if (parent)
3304                 LIST_PREPEND(struct node, siblings, parent->child, n);
3305
3306         return n;
3307 }
3308
3309 static void bus_node_gc(sd_bus *b, struct node *n) {
3310         assert(b);
3311
3312         if (!n)
3313                 return;
3314
3315         if (n->child ||
3316             n->callbacks ||
3317             n->vtables ||
3318             n->enumerators ||
3319             n->object_manager)
3320                 return;
3321
3322         assert(hashmap_remove(b->nodes, n->path) == n);
3323
3324         if (n->parent)
3325                 LIST_REMOVE(struct node, siblings, n->parent->child, n);
3326
3327         free(n->path);
3328         bus_node_gc(b, n->parent);
3329         free(n);
3330 }
3331
3332 static int bus_add_object(
3333                 sd_bus *b,
3334                 bool fallback,
3335                 const char *path,
3336                 sd_bus_message_handler_t callback,
3337                 void *userdata) {
3338
3339         struct node_callback *c;
3340         struct node *n;
3341         int r;
3342
3343         if (!b)
3344                 return -EINVAL;
3345         if (!object_path_is_valid(path))
3346                 return -EINVAL;
3347         if (!callback)
3348                 return -EINVAL;
3349         if (bus_pid_changed(b))
3350                 return -ECHILD;
3351
3352         n = bus_node_allocate(b, path);
3353         if (!n)
3354                 return -ENOMEM;
3355
3356         c = new0(struct node_callback, 1);
3357         if (!c) {
3358                 r = -ENOMEM;
3359                 goto fail;
3360         }
3361
3362         c->node = n;
3363         c->callback = callback;
3364         c->userdata = userdata;
3365         c->is_fallback = fallback;
3366
3367         LIST_PREPEND(struct node_callback, callbacks, n->callbacks, c);
3368         return 0;
3369
3370 fail:
3371         free(c);
3372         bus_node_gc(b, n);
3373         return r;
3374 }
3375
3376 static int bus_remove_object(
3377                 sd_bus *bus,
3378                 bool fallback,
3379                 const char *path,
3380                 sd_bus_message_handler_t callback,
3381                 void *userdata) {
3382
3383         struct node_callback *c;
3384         struct node *n;
3385
3386         if (!bus)
3387                 return -EINVAL;
3388         if (!object_path_is_valid(path))
3389                 return -EINVAL;
3390         if (!callback)
3391                 return -EINVAL;
3392         if (bus_pid_changed(bus))
3393                 return -ECHILD;
3394
3395         n = hashmap_get(bus->nodes, path);
3396         if (!n)
3397                 return 0;
3398
3399         LIST_FOREACH(callbacks, c, n->callbacks)
3400                 if (c->callback == callback && c->userdata == userdata && c->is_fallback == fallback)
3401                         break;
3402         if (!c)
3403                 return 0;
3404
3405         LIST_REMOVE(struct node_callback, callbacks, n->callbacks, c);
3406         free(c);
3407
3408         bus_node_gc(bus, n);
3409
3410         return 1;
3411 }
3412
3413 int sd_bus_add_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
3414         return bus_add_object(bus, false, path, callback, userdata);
3415 }
3416
3417 int sd_bus_remove_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
3418         return bus_remove_object(bus, false, path, callback, userdata);
3419 }
3420
3421 int sd_bus_add_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
3422         return bus_add_object(bus, true, prefix, callback, userdata);
3423 }
3424
3425 int sd_bus_remove_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
3426         return bus_remove_object(bus, true, prefix, callback, userdata);
3427 }
3428
3429 int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
3430         struct bus_match_component *components = NULL;
3431         unsigned n_components = 0;
3432         uint64_t cookie = 0;
3433         int r = 0;
3434
3435         if (!bus)
3436                 return -EINVAL;
3437         if (!match)
3438                 return -EINVAL;
3439         if (bus_pid_changed(bus))
3440                 return -ECHILD;
3441
3442         r = bus_match_parse(match, &components, &n_components);
3443         if (r < 0)
3444                 goto finish;
3445
3446         if (bus->bus_client) {
3447                 cookie = ++bus->match_cookie;
3448
3449                 r = bus_add_match_internal(bus, match, components, n_components, cookie);
3450                 if (r < 0)
3451                         goto finish;
3452         }
3453
3454         bus->match_callbacks_modified = true;
3455         r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
3456         if (r < 0) {
3457                 if (bus->bus_client)
3458                         bus_remove_match_internal(bus, match, cookie);
3459         }
3460
3461 finish:
3462         bus_match_parse_free(components, n_components);
3463         return r;
3464 }
3465
3466 int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
3467         struct bus_match_component *components = NULL;
3468         unsigned n_components = 0;
3469         int r = 0, q = 0;
3470         uint64_t cookie = 0;
3471
3472         if (!bus)
3473                 return -EINVAL;
3474         if (!match)
3475                 return -EINVAL;
3476         if (bus_pid_changed(bus))
3477                 return -ECHILD;
3478
3479         r = bus_match_parse(match, &components, &n_components);
3480         if (r < 0)
3481                 return r;
3482
3483         bus->match_callbacks_modified = true;
3484         r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
3485
3486         if (bus->bus_client)
3487                 q = bus_remove_match_internal(bus, match, cookie);
3488
3489         bus_match_parse_free(components, n_components);
3490
3491         return r < 0 ? r : q;
3492 }
3493
3494 int sd_bus_emit_signal(
3495                 sd_bus *bus,
3496                 const char *path,
3497                 const char *interface,
3498                 const char *member,
3499                 const char *types, ...) {
3500
3501         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3502         int r;
3503
3504         if (!bus)
3505                 return -EINVAL;
3506         if (!BUS_IS_OPEN(bus->state))
3507                 return -ENOTCONN;
3508         if (bus_pid_changed(bus))
3509                 return -ECHILD;
3510
3511         r = sd_bus_message_new_signal(bus, path, interface, member, &m);
3512         if (r < 0)
3513                 return r;
3514
3515         if (!isempty(types)) {
3516                 va_list ap;
3517
3518                 va_start(ap, types);
3519                 r = bus_message_append_ap(m, types, ap);
3520                 va_end(ap);
3521                 if (r < 0)
3522                         return r;
3523         }
3524
3525         return sd_bus_send(bus, m, NULL);
3526 }
3527
3528 int sd_bus_call_method(
3529                 sd_bus *bus,
3530                 const char *destination,
3531                 const char *path,
3532                 const char *interface,
3533                 const char *member,
3534                 sd_bus_error *error,
3535                 sd_bus_message **reply,
3536                 const char *types, ...) {
3537
3538         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3539         int r;
3540
3541         if (!bus)
3542
3543                 return -EINVAL;
3544         if (!BUS_IS_OPEN(bus->state))
3545                 return -ENOTCONN;
3546         if (bus_pid_changed(bus))
3547                 return -ECHILD;
3548
3549         r = sd_bus_message_new_method_call(bus, destination, path, interface, member, &m);
3550         if (r < 0)
3551                 return r;
3552
3553         if (!isempty(types)) {
3554                 va_list ap;
3555
3556                 va_start(ap, types);
3557                 r = bus_message_append_ap(m, types, ap);
3558                 va_end(ap);
3559                 if (r < 0)
3560                         return r;
3561         }
3562
3563         return sd_bus_send_with_reply_and_block(bus, m, 0, error, reply);
3564 }
3565
3566 int sd_bus_reply_method_return(
3567                 sd_bus *bus,
3568                 sd_bus_message *call,
3569                 const char *types, ...) {
3570
3571         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3572         int r;
3573
3574         if (!bus)
3575                 return -EINVAL;
3576         if (!call)
3577                 return -EINVAL;
3578         if (!call->sealed)
3579                 return -EPERM;
3580         if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
3581                 return -EINVAL;
3582         if (!BUS_IS_OPEN(bus->state))
3583                 return -ENOTCONN;
3584         if (bus_pid_changed(bus))
3585                 return -ECHILD;
3586
3587         if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
3588                 return 0;
3589
3590         r = sd_bus_message_new_method_return(bus, call, &m);
3591         if (r < 0)
3592                 return r;
3593
3594         if (!isempty(types)) {
3595                 va_list ap;
3596
3597                 va_start(ap, types);
3598                 r = bus_message_append_ap(m, types, ap);
3599                 va_end(ap);
3600                 if (r < 0)
3601                         return r;
3602         }
3603
3604         return sd_bus_send(bus, m, NULL);
3605 }
3606
3607 int sd_bus_reply_method_error(
3608                 sd_bus *bus,
3609                 sd_bus_message *call,
3610                 const sd_bus_error *e) {
3611
3612         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3613         int r;
3614
3615         if (!bus)
3616                 return -EINVAL;
3617         if (!call)
3618                 return -EINVAL;
3619         if (!call->sealed)
3620                 return -EPERM;
3621         if (call->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
3622                 return -EINVAL;
3623         if (!sd_bus_error_is_set(e))
3624                 return -EINVAL;
3625         if (!BUS_IS_OPEN(bus->state))
3626                 return -ENOTCONN;
3627         if (bus_pid_changed(bus))
3628                 return -ECHILD;
3629
3630         if (call->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
3631                 return 0;
3632
3633         r = sd_bus_message_new_method_error(bus, call, e, &m);
3634         if (r < 0)
3635                 return r;
3636
3637         return sd_bus_send(bus, m, NULL);
3638 }
3639
3640 int sd_bus_reply_method_errorf(
3641                 sd_bus *bus,
3642                 sd_bus_message *call,
3643                 const char *name,
3644                 const char *format,
3645                 ...) {
3646
3647         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
3648         char *n, *m;
3649         va_list ap;
3650         int r;
3651
3652         n = strdup(name);
3653         if (!n)
3654                 return -ENOMEM;
3655
3656         if (format) {
3657                 va_start(ap, format);
3658                 r = vasprintf(&m, format, ap);
3659                 va_end(ap);
3660
3661                 if (r < 0) {
3662                         free(n);
3663                         return -ENOMEM;
3664                 }
3665         }
3666
3667         error.name = n;
3668         error.message = m;
3669         error.need_free = true;
3670
3671         return sd_bus_reply_method_error(bus, call, &error);
3672 }
3673
3674 bool bus_pid_changed(sd_bus *bus) {
3675         assert(bus);
3676
3677         /* We don't support people creating a bus connection and
3678          * keeping it around over a fork(). Let's complain. */
3679
3680         return bus->original_pid != getpid();
3681 }
3682
3683 static void free_node_vtable(sd_bus *bus, struct node_vtable *w) {
3684         assert(bus);
3685
3686         if (!w)
3687                 return;
3688
3689         if (w->interface && w->node && w->vtable) {
3690                 const sd_bus_vtable *v;
3691
3692                 for (v = w->vtable; v->type != _SD_BUS_VTABLE_END; v++) {
3693                         struct vtable_member *x = NULL;
3694
3695                         switch (v->type) {
3696
3697                         case _SD_BUS_VTABLE_METHOD: {
3698                                 struct vtable_member key;
3699
3700                                 key.path = w->node->path;
3701                                 key.interface = w->interface;
3702                                 key.member = v->method.member;
3703
3704                                 x = hashmap_remove(bus->vtable_methods, &key);
3705                                 break;
3706                         }
3707
3708                         case _SD_BUS_VTABLE_PROPERTY:
3709                         case _SD_BUS_VTABLE_WRITABLE_PROPERTY: {
3710                                 struct vtable_member key;
3711
3712                                 key.path = w->node->path;
3713                                 key.interface = w->interface;
3714                                 key.member = v->property.member;
3715                                 x = hashmap_remove(bus->vtable_properties, &key);
3716                                 break;
3717                         }}
3718
3719                         free(x);
3720                 }
3721         }
3722
3723         free(w->interface);
3724         free(w);
3725 }
3726
3727 static unsigned vtable_member_hash_func(const void *a) {
3728         const struct vtable_member *m = a;
3729
3730         return
3731                 string_hash_func(m->path) ^
3732                 string_hash_func(m->interface) ^
3733                 string_hash_func(m->member);
3734 }
3735
3736 static int vtable_member_compare_func(const void *a, const void *b) {
3737         const struct vtable_member *x = a, *y = b;
3738         int r;
3739
3740         r = strcmp(x->path, y->path);
3741         if (r != 0)
3742                 return r;
3743
3744         r = strcmp(x->interface, y->interface);
3745         if (r != 0)
3746                 return r;
3747
3748         return strcmp(x->member, y->member);
3749 }
3750
3751 static int add_object_vtable_internal(
3752                 sd_bus *bus,
3753                 const char *path,
3754                 const char *interface,
3755                 const sd_bus_vtable *vtable,
3756                 bool fallback,
3757                 sd_bus_object_find_t find,
3758                 void *userdata) {
3759
3760         struct node_vtable *c = NULL, *i;
3761         const sd_bus_vtable *v;
3762         struct node *n;
3763         int r;
3764
3765         if (!bus)
3766                 return -EINVAL;
3767         if (!object_path_is_valid(path))
3768                 return -EINVAL;
3769         if (!interface_name_is_valid(interface))
3770                 return -EINVAL;
3771         if (!vtable || vtable[0].type != _SD_BUS_VTABLE_START || vtable[0].start.element_size != sizeof(struct sd_bus_vtable))
3772                 return -EINVAL;
3773         if (bus_pid_changed(bus))
3774                 return -ECHILD;
3775
3776         r = hashmap_ensure_allocated(&bus->vtable_methods, vtable_member_hash_func, vtable_member_compare_func);
3777         if (r < 0)
3778                 return r;
3779
3780         r = hashmap_ensure_allocated(&bus->vtable_properties, vtable_member_hash_func, vtable_member_compare_func);
3781         if (r < 0)
3782                 return r;
3783
3784         n = bus_node_allocate(bus, path);
3785         if (!n)
3786                 return -ENOMEM;
3787
3788         LIST_FOREACH(vtables, i, n->vtables) {
3789                 if (streq(i->interface, interface)) {
3790                         r = -EEXIST;
3791                         goto fail;
3792                 }
3793
3794                 if (i->is_fallback != fallback) {
3795                         r = -EPROTOTYPE;
3796                         goto fail;
3797                 }
3798         }
3799
3800         c = new0(struct node_vtable, 1);
3801         if (!c) {
3802                 r = -ENOMEM;
3803                 goto fail;
3804         }
3805
3806         c->node = n;
3807         c->is_fallback = fallback;
3808         c->vtable = vtable;
3809         c->userdata = userdata;
3810         c->find = find;
3811
3812         c->interface = strdup(interface);
3813         if (!c->interface) {
3814                 r = -ENOMEM;
3815                 goto fail;
3816         }
3817
3818         for (v = c->vtable+1; v->type != _SD_BUS_VTABLE_END; v++) {
3819
3820                 switch (v->type) {
3821
3822                 case _SD_BUS_VTABLE_METHOD: {
3823                         struct vtable_member *m;
3824
3825                         if (!member_name_is_valid(v->method.member) ||
3826                             !signature_is_valid(strempty(v->method.signature), false) ||
3827                             !signature_is_valid(strempty(v->method.result), false) ||
3828                             !(v->method.handler || (isempty(v->method.signature) && isempty(v->method.result))) ||
3829                             v->flags & (SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE|SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY)) {
3830                                 r = -EINVAL;
3831                                 goto fail;
3832                         }
3833
3834                         m = new0(struct vtable_member, 1);
3835                         if (!m) {
3836                                 r = -ENOMEM;
3837                                 goto fail;
3838                         }
3839
3840                         m->parent = c;
3841                         m->path = n->path;
3842                         m->interface = c->interface;
3843                         m->member = v->method.member;
3844                         m->vtable = v;
3845
3846                         r = hashmap_put(bus->vtable_methods, m, m);
3847                         if (r < 0) {
3848                                 free(m);
3849                                 goto fail;
3850                         }
3851
3852                         break;
3853                 }
3854
3855                 case _SD_BUS_VTABLE_WRITABLE_PROPERTY:
3856
3857                         if (!(v->property.set || bus_type_is_basic(v->property.signature[0]))) {
3858                                 r = -EINVAL;
3859                                 goto fail;
3860                         }
3861
3862                         /* Fall through */
3863
3864                 case _SD_BUS_VTABLE_PROPERTY: {
3865                         struct vtable_member *m;
3866
3867                         if (!member_name_is_valid(v->property.member) ||
3868                             !signature_is_single(v->property.signature, false) ||
3869                             !(v->property.get || bus_type_is_basic(v->property.signature[0])) ||
3870                             v->flags & SD_BUS_VTABLE_METHOD_NO_REPLY ||
3871                             (v->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY && !(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))) {
3872                                 r = -EINVAL;
3873                                 goto fail;
3874                         }
3875
3876
3877                         m = new0(struct vtable_member, 1);
3878                         if (!m) {
3879                                 r = -ENOMEM;
3880                                 goto fail;
3881                         }
3882
3883                         m->parent = c;
3884                         m->path = n->path;
3885                         m->interface = c->interface;
3886                         m->member = v->property.member;
3887                         m->vtable = v;
3888
3889                         r = hashmap_put(bus->vtable_properties, m, m);
3890                         if (r < 0) {
3891                                 free(m);
3892                                 goto fail;
3893                         }
3894
3895                         break;
3896                 }
3897
3898                 case _SD_BUS_VTABLE_SIGNAL:
3899
3900                         if (!member_name_is_valid(v->signal.member) ||
3901                             !signature_is_single(strempty(v->signal.signature), false)) {
3902                                 r = -EINVAL;
3903                                 goto fail;
3904                         }
3905
3906                         break;
3907
3908                 default:
3909                         r = -EINVAL;
3910                         goto fail;
3911                 }
3912         }
3913
3914         LIST_PREPEND(struct node_vtable, vtables, n->vtables, c);
3915         return 0;
3916
3917 fail:
3918         if (c)
3919                 free_node_vtable(bus, c);
3920
3921         bus_node_gc(bus, n);
3922         return r;
3923 }
3924
3925 static int remove_object_vtable_internal(
3926                 sd_bus *bus,
3927                 const char *path,
3928                 const char *interface,
3929                 bool fallback) {
3930
3931         struct node_vtable *c;
3932         struct node *n;
3933
3934         if (!bus)
3935                 return -EINVAL;
3936         if (!object_path_is_valid(path))
3937                 return -EINVAL;
3938         if (!interface_name_is_valid(interface))
3939                 return -EINVAL;
3940         if (bus_pid_changed(bus))
3941                 return -ECHILD;
3942
3943         n = hashmap_get(bus->nodes, path);
3944         if (!n)
3945                 return 0;
3946
3947         LIST_FOREACH(vtables, c, n->vtables)
3948                 if (streq(c->interface, interface) && c->is_fallback == fallback)
3949                         break;
3950
3951         if (!c)
3952                 return 0;
3953
3954         LIST_REMOVE(struct node_vtable, vtables, n->vtables, c);
3955
3956         free_node_vtable(bus, c);
3957         return 1;
3958 }
3959
3960 int sd_bus_add_object_vtable(
3961                 sd_bus *bus,
3962                 const char *path,
3963                 const char *interface,
3964                 const sd_bus_vtable *vtable,
3965                 void *userdata) {
3966
3967         return add_object_vtable_internal(bus, path, interface, vtable, false, NULL, userdata);
3968 }
3969
3970 int sd_bus_remove_object_vtable(
3971                 sd_bus *bus,
3972                 const char *path,
3973                 const char *interface) {
3974
3975         return remove_object_vtable_internal(bus, path, interface, false);
3976 }
3977
3978 int sd_bus_add_fallback_vtable(
3979                 sd_bus *bus,
3980                 const char *path,
3981                 const char *interface,
3982                 const sd_bus_vtable *vtable,
3983                 sd_bus_object_find_t find,
3984                 void *userdata) {
3985
3986         return add_object_vtable_internal(bus, path, interface, vtable, true, find, userdata);
3987 }
3988
3989 int sd_bus_remove_fallback_vtable(
3990                 sd_bus *bus,
3991                 const char *path,
3992                 const char *interface) {
3993
3994         return remove_object_vtable_internal(bus, path, interface, true);
3995 }
3996
3997 int sd_bus_add_node_enumerator(
3998                 sd_bus *bus,
3999                 const char *path,
4000                 sd_bus_node_enumerator_t callback,
4001                 void *userdata) {
4002
4003         struct node_enumerator *c;
4004         struct node *n;
4005         int r;
4006
4007         if (!bus)
4008                 return -EINVAL;
4009         if (!object_path_is_valid(path))
4010                 return -EINVAL;
4011         if (!callback)
4012                 return -EINVAL;
4013         if (bus_pid_changed(bus))
4014                 return -ECHILD;
4015
4016         n = bus_node_allocate(bus, path);
4017         if (!n)
4018                 return -ENOMEM;
4019
4020         c = new0(struct node_enumerator, 1);
4021         if (!c) {
4022                 r = -ENOMEM;
4023                 goto fail;
4024         }
4025
4026         c->node = n;
4027         c->callback = callback;
4028         c->userdata = userdata;
4029
4030         LIST_PREPEND(struct node_enumerator, enumerators, n->enumerators, c);
4031         return 0;
4032
4033 fail:
4034         free(c);
4035         bus_node_gc(bus, n);
4036         return r;
4037 }
4038
4039 int sd_bus_remove_node_enumerator(
4040                 sd_bus *bus,
4041                 const char *path,
4042                 sd_bus_node_enumerator_t callback,
4043                 void *userdata) {
4044
4045         struct node_enumerator *c;
4046         struct node *n;
4047
4048         if (!bus)
4049                 return -EINVAL;
4050         if (!object_path_is_valid(path))
4051                 return -EINVAL;
4052         if (!callback)
4053                 return -EINVAL;
4054         if (bus_pid_changed(bus))
4055                 return -ECHILD;
4056
4057         n = hashmap_get(bus->nodes, path);
4058         if (!n)
4059                 return 0;
4060
4061         LIST_FOREACH(enumerators, c, n->enumerators)
4062                 if (c->callback == callback && c->userdata == userdata)
4063                         break;
4064
4065         if (!c)
4066                 return 0;
4067
4068         LIST_REMOVE(struct node_enumerator, enumerators, n->enumerators, c);
4069         free(c);
4070
4071         bus_node_gc(bus, n);
4072
4073         return 1;
4074 }
4075
4076 static int emit_properties_changed_on_interface(
4077                 sd_bus *bus,
4078                 const char *prefix,
4079                 const char *path,
4080                 const char *interface,
4081                 bool require_fallback,
4082                 char **names) {
4083
4084         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4085         bool has_invalidating = false;
4086         struct vtable_member key;
4087         struct node_vtable *c;
4088         struct node *n;
4089         char **property;
4090         void *u = NULL;
4091         int r;
4092
4093         assert(bus);
4094         assert(path);
4095         assert(interface);
4096
4097         n = hashmap_get(bus->nodes, prefix);
4098         if (!n)
4099                 return 0;
4100
4101         LIST_FOREACH(vtables, c, n->vtables) {
4102                 if (require_fallback && !c->is_fallback)
4103                         continue;
4104
4105                 if (streq(c->interface, interface))
4106                         break;
4107         }
4108
4109         if (!c)
4110                 return 0;
4111
4112         r = node_vtable_get_userdata(bus, path, c, &u);
4113         if (r <= 0)
4114                 return r;
4115
4116         r = sd_bus_message_new_signal(bus, path, "org.freedesktop.DBus.Properties", "PropertiesChanged", &m);
4117         if (r < 0)
4118                 return r;
4119
4120         r = sd_bus_message_append(m, "s", interface);
4121         if (r < 0)
4122                 return r;
4123
4124         r = sd_bus_message_open_container(m, 'a', "{sv}");
4125         if (r < 0)
4126                 return r;
4127
4128         key.path = prefix;
4129         key.interface = interface;
4130
4131         STRV_FOREACH(property, names) {
4132                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4133                 struct vtable_member *v;
4134
4135                 key.member = *property;
4136                 v = hashmap_get(bus->vtable_properties, &key);
4137                 if (!v)
4138                         return -ENOENT;
4139
4140                 assert(c == v->parent);
4141
4142                 if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))
4143                         return -EDOM;
4144                 if (v->vtable->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY) {
4145                         has_invalidating = true;
4146                         continue;
4147                 }
4148
4149                 r = sd_bus_message_open_container(m, 'e', "sv");
4150                 if (r < 0)
4151                         return r;
4152
4153                 r = sd_bus_message_append(m, "s", *property);
4154                 if (r < 0)
4155                         return r;
4156
4157                 r = sd_bus_message_open_container(m, 'v', v->vtable->property.signature);
4158                 if (r < 0)
4159                         return r;
4160
4161                 r = invoke_property_get(bus, v->vtable, m->path, interface, *property, m, &error, vtable_property_convert_userdata(v->vtable, u));
4162                 if (r < 0)
4163                         return r;
4164
4165                 if (sd_bus_error_is_set(&error))
4166                         return bus_error_to_errno(&error);
4167
4168                 r = sd_bus_message_close_container(m);
4169                 if (r < 0)
4170                         return r;
4171
4172                 r = sd_bus_message_close_container(m);
4173                 if (r < 0)
4174                         return r;
4175         }
4176
4177         r = sd_bus_message_close_container(m);
4178         if (r < 0)
4179                 return r;
4180
4181         r = sd_bus_message_open_container(m, 'a', "s");
4182         if (r < 0)
4183                 return r;
4184
4185         if (has_invalidating) {
4186                 STRV_FOREACH(property, names) {
4187                         struct vtable_member *v;
4188
4189                         key.member = *property;
4190                         assert_se(v = hashmap_get(bus->vtable_properties, &key));
4191                         assert(c == v->parent);
4192
4193                         if (!(v->vtable->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY))
4194                                 continue;
4195
4196                         r = sd_bus_message_append(m, "s", *property);
4197                         if (r < 0)
4198                                 return r;
4199                 }
4200         }
4201
4202         r = sd_bus_message_close_container(m);
4203         if (r < 0)
4204                 return r;
4205
4206         r = sd_bus_send(bus, m, NULL);
4207         if (r < 0)
4208                 return r;
4209
4210         return 1;
4211 }
4212
4213 int sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names) {
4214         size_t pl;
4215         int r;
4216
4217         if (!bus)
4218                 return -EINVAL;
4219         if (!object_path_is_valid(path))
4220                 return -EINVAL;
4221         if (!interface_name_is_valid(interface))
4222                 return -EINVAL;
4223
4224         r = emit_properties_changed_on_interface(bus, path, path, interface, false, names);
4225         if (r != 0)
4226                 return r;
4227
4228         pl = strlen(path);
4229         if (pl > 1 ) {
4230                 char p[pl+1];
4231
4232                 strcpy(p, path);
4233                 for (;;) {
4234                         char *e;
4235
4236                         if (streq(p, "/"))
4237                                 break;
4238
4239                         e = strrchr(p, '/');
4240                         assert(e);
4241                         if (e == p)
4242                                 *(e+1) = 0;
4243                         else
4244                                 *e = 0;
4245
4246                         r = emit_properties_changed_on_interface(bus, p, path, interface, true, names);
4247                         if (r != 0)
4248                                 return r;
4249                 }
4250         }
4251
4252         return -ENOENT;
4253 }
4254
4255 int sd_bus_emit_properties_changed(sd_bus *bus, const char *path, const char *interface, const char *name, ...)  {
4256         _cleanup_strv_free_ char **names = NULL;
4257         va_list ap;
4258
4259         va_start(ap, name);
4260         names = strv_new_ap(name, ap);
4261         va_end(ap);
4262
4263         if (!names)
4264                 return -ENOMEM;
4265
4266         return sd_bus_emit_properties_changed_strv(bus, path, interface, names);
4267 }
4268
4269 int sd_bus_emit_interfaces_added(sd_bus *bus, const char *path, const char *interfaces, ...) {
4270         return -ENOSYS;
4271 }
4272
4273 int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const char *interfaces, ...) {
4274         return -ENOSYS;
4275 }
4276
4277 int sd_bus_get_property(
4278                 sd_bus *bus,
4279                 const char *destination,
4280                 const char *path,
4281                 const char *interface,
4282                 const char *member,
4283                 sd_bus_error *error,
4284                 sd_bus_message **reply,
4285                 const char *type) {
4286
4287         sd_bus_message *rep = NULL;
4288         int r;
4289
4290         if (interface && !interface_name_is_valid(interface))
4291                 return -EINVAL;
4292         if (!member_name_is_valid(member))
4293                 return -EINVAL;
4294         if (!signature_is_single(type, false))
4295                 return -EINVAL;
4296         if (!reply)
4297                 return -EINVAL;
4298
4299         r = sd_bus_call_method(bus, destination, path, "org.freedesktop.DBus.Properties", "Get", error, &rep, "ss", strempty(interface), member);
4300         if (r < 0)
4301                 return r;
4302
4303         r = sd_bus_message_enter_container(rep, 'v', type);
4304         if (r < 0) {
4305                 sd_bus_message_unref(rep);
4306                 return r;
4307         }
4308
4309         *reply = rep;
4310         return 0;
4311 }
4312
4313 int sd_bus_set_property(
4314                 sd_bus *bus,
4315                 const char *destination,
4316                 const char *path,
4317                 const char *interface,
4318                 const char *member,
4319                 sd_bus_error *error,
4320                 const char *type, ...) {
4321
4322         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4323         va_list ap;
4324         int r;
4325
4326         if (interface && !interface_name_is_valid(interface))
4327                 return -EINVAL;
4328         if (!member_name_is_valid(member))
4329                 return -EINVAL;
4330         if (!signature_is_single(type, false))
4331                 return -EINVAL;
4332
4333         r = sd_bus_message_new_method_call(bus, destination, path, "org.freedesktop.DBus.Properties", "Set", &m);
4334         if (r < 0)
4335                 return r;
4336
4337         r = sd_bus_message_append(m, "ss", strempty(interface), member);
4338         if (r < 0)
4339                 return r;
4340
4341         r = sd_bus_message_open_container(m, 'v', type);
4342         if (r < 0)
4343                 return r;
4344
4345         va_start(ap, type);
4346         r = bus_message_append_ap(m, type, ap);
4347         va_end(ap);
4348         if (r < 0)
4349                 return r;
4350
4351         r = sd_bus_message_close_container(m);
4352         if (r < 0)
4353                 return r;
4354
4355         return sd_bus_send_with_reply_and_block(bus, m, 0, error, NULL);
4356 }
4357
4358 int sd_bus_add_object_manager(sd_bus *bus, const char *path) {
4359         struct node *n;
4360
4361         if (!bus)
4362                 return -EINVAL;
4363         if (!object_path_is_valid(path))
4364                 return -EINVAL;
4365         if (bus_pid_changed(bus))
4366                 return -ECHILD;
4367
4368         n = bus_node_allocate(bus, path);
4369         if (!n)
4370                 return -ENOMEM;
4371
4372         n->object_manager = true;
4373         return 0;
4374 }
4375
4376 int sd_bus_remove_object_manager(sd_bus *bus, const char *path) {
4377         struct node *n;
4378
4379         if (!bus)
4380                 return -EINVAL;
4381         if (!object_path_is_valid(path))
4382                 return -EINVAL;
4383         if (bus_pid_changed(bus))
4384                 return -ECHILD;
4385
4386         n = hashmap_get(bus->nodes, path);
4387         if (!n)
4388                 return 0;
4389
4390         if (!n->object_manager)
4391                 return 0;
4392
4393         n->object_manager = false;
4394         bus_node_gc(bus, n);
4395         return 1;
4396 }