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
  30 #include "util.h"
  31 #include "macro.h"
  32 #include "strv.h"
  33 #include "set.h"
  34
  35 #include "sd-bus.h"
  36 #include "bus-internal.h"
  37 #include "bus-message.h"
  38 #include "bus-type.h"
  39 #include "bus-socket.h"
  40 #include "bus-control.h"
  41
  42 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
  43
  44 static void bus_free(sd_bus *b) {
  45         struct filter_callback *f;
  46         struct object_callback *c;
  47         unsigned i;
  48
  49         assert(b);
  50
  51         if (b->fd >= 0)
  52                 close_nointr_nofail(b->fd);
  53
  54         free(b->rbuffer);
  55         free(b->unique_name);
  56         free(b->auth_buffer);
  57         free(b->address);
  58
  59         free(b->exec_path);
  60         strv_free(b->exec_argv);
  61
  62         close_many(b->fds, b->n_fds);
  63         free(b->fds);
  64
  65         for (i = 0; i < b->rqueue_size; i++)
  66                 sd_bus_message_unref(b->rqueue[i]);
  67         free(b->rqueue);
  68
  69         for (i = 0; i < b->wqueue_size; i++)
  70                 sd_bus_message_unref(b->wqueue[i]);
  71         free(b->wqueue);
  72
  73         hashmap_free_free(b->reply_callbacks);
  74         prioq_free(b->reply_callbacks_prioq);
  75
  76         while ((f = b->filter_callbacks)) {
  77                 LIST_REMOVE(struct filter_callback, callbacks, b->filter_callbacks, f);
  78                 free(f);
  79         }
  80
  81         while ((c = hashmap_steal_first(b->object_callbacks))) {
  82                 free(c->path);
  83                 free(c);
  84         }
  85
  86         hashmap_free(b->object_callbacks);
  87
  88         bus_match_free(&b->match_callbacks);
  89
  90         free(b);
  91 }
  92
  93 int sd_bus_new(sd_bus **ret) {
  94         sd_bus *r;
  95
  96         if (!ret)
  97                 return -EINVAL;
  98
  99         r = new0(sd_bus, 1);
 100         if (!r)
 101                 return -ENOMEM;
 102
 103         r->n_ref = 1;
 104         r->fd = -1;
 105         r->message_version = 1;
 106         r->negotiate_fds = true;
 107
 108         /* We guarantee that wqueue always has space for at least one
 109          * entry */
 110         r->wqueue = new(sd_bus_message*, 1);
 111         if (!r->wqueue) {
 112                 free(r);
 113                 return -ENOMEM;
 114         }
 115
 116         *ret = r;
 117         return 0;
 118 }
 119
 120 int sd_bus_set_address(sd_bus *bus, const char *address) {
 121         char *a;
 122
 123         if (!bus)
 124                 return -EINVAL;
 125         if (bus->state != BUS_UNSET)
 126                 return -EPERM;
 127         if (!address)
 128                 return -EINVAL;
 129
 130         a = strdup(address);
 131         if (!a)
 132                 return -ENOMEM;
 133
 134         free(bus->address);
 135         bus->address = a;
 136
 137         return 0;
 138 }
 139
 140 int sd_bus_set_fd(sd_bus *bus, int fd) {
 141         if (!bus)
 142                 return -EINVAL;
 143         if (bus->state != BUS_UNSET)
 144                 return -EPERM;
 145         if (fd < 0)
 146                 return -EINVAL;
 147
 148         bus->fd = fd;
 149         return 0;
 150 }
 151
 152 int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
 153         char *p, **a;
 154
 155         if (!bus)
 156                 return -EINVAL;
 157         if (bus->state != BUS_UNSET)
 158                 return -EPERM;
 159         if (!path)
 160                 return -EINVAL;
 161         if (strv_isempty(argv))
 162                 return -EINVAL;
 163
 164         p = strdup(path);
 165         if (!p)
 166                 return -ENOMEM;
 167
 168         a = strv_copy(argv);
 169         if (!a) {
 170                 free(p);
 171                 return -ENOMEM;
 172         }
 173
 174         free(bus->exec_path);
 175         strv_free(bus->exec_argv);
 176
 177         bus->exec_path = p;
 178         bus->exec_argv = a;
 179
 180         return 0;
 181 }
 182
 183 int sd_bus_set_bus_client(sd_bus *bus, int b) {
 184         if (!bus)
 185                 return -EINVAL;
 186         if (bus->state != BUS_UNSET)
 187                 return -EPERM;
 188
 189         bus->bus_client = !!b;
 190         return 0;
 191 }
 192
 193 int sd_bus_set_negotiate_fds(sd_bus *bus, int b) {
 194         if (!bus)
 195                 return -EINVAL;
 196         if (bus->state != BUS_UNSET)
 197                 return -EPERM;
 198
 199         bus->negotiate_fds = !!b;
 200         return 0;
 201 }
 202
 203 int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
 204         if (!bus)
 205                 return -EINVAL;
 206         if (!b && !sd_id128_equal(server_id, SD_ID128_NULL))
 207                 return -EINVAL;
 208         if (bus->state != BUS_UNSET)
 209                 return -EPERM;
 210
 211         bus->is_server = !!b;
 212         bus->server_id = server_id;
 213         return 0;
 214 }
 215
 216 int sd_bus_set_anonymous(sd_bus *bus, int b) {
 217         if (!bus)
 218                 return -EINVAL;
 219         if (bus->state != BUS_UNSET)
 220                 return -EPERM;
 221
 222         bus->anonymous_auth = !!b;
 223         return 0;
 224 }
 225
 226 static int hello_callback(sd_bus *bus, int error, sd_bus_message *reply, void *userdata) {
 227         const char *s;
 228         int r;
 229
 230         assert(bus);
 231         assert(bus->state == BUS_HELLO);
 232
 233         if (error != 0)
 234                 return -error;
 235
 236         assert(reply);
 237
 238         r = sd_bus_message_read(reply, "s", &s);
 239         if (r < 0)
 240                 return r;
 241
 242         if (!service_name_is_valid(s) || s[0] != ':')
 243                 return -EBADMSG;
 244
 245         bus->unique_name = strdup(s);
 246         if (!bus->unique_name)
 247                 return -ENOMEM;
 248
 249         bus->state = BUS_RUNNING;
 250
 251         return 1;
 252 }
 253
 254 static int bus_send_hello(sd_bus *bus) {
 255         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 256         int r;
 257
 258         assert(bus);
 259
 260         if (!bus->bus_client)
 261                 return 0;
 262
 263         r = sd_bus_message_new_method_call(
 264                         bus,
 265                         "org.freedesktop.DBus",
 266                         "/",
 267                         "org.freedesktop.DBus",
 268                         "Hello",
 269                         &m);
 270         if (r < 0)
 271                 return r;
 272
 273         return sd_bus_send_with_reply(bus, m, hello_callback, NULL, 0, &bus->hello_serial);
 274 }
 275
 276 int bus_start_running(sd_bus *bus) {
 277         assert(bus);
 278
 279         if (bus->bus_client) {
 280                 bus->state = BUS_HELLO;
 281                 return 1;
 282         }
 283
 284         bus->state = BUS_RUNNING;
 285         return 1;
 286 }
 287
 288 static int parse_address_key(const char **p, const char *key, char **value) {
 289         size_t l, n = 0;
 290         const char *a;
 291         char *r = NULL;
 292
 293         assert(p);
 294         assert(*p);
 295         assert(value);
 296
 297         if (key) {
 298                 l = strlen(key);
 299                 if (strncmp(*p, key, l) != 0)
 300                         return 0;
 301
 302                 if ((*p)[l] != '=')
 303                         return 0;
 304
 305                 if (*value)
 306                         return -EINVAL;
 307
 308                 a = *p + l + 1;
 309         } else
 310                 a = *p;
 311
 312         while (*a != ';' && *a != ',' && *a != 0) {
 313                 char c, *t;
 314
 315                 if (*a == '%') {
 316                         int x, y;
 317
 318                         x = unhexchar(a[1]);
 319                         if (x < 0) {
 320                                 free(r);
 321                                 return x;
 322                         }
 323
 324                         y = unhexchar(a[2]);
 325                         if (y < 0) {
 326                                 free(r);
 327                                 return y;
 328                         }
 329
 330                         c = (char) ((x << 4) | y);
 331                         a += 3;
 332                 } else {
 333                         c = *a;
 334                         a++;
 335                 }
 336
 337                 t = realloc(r, n + 2);
 338                 if (!t) {
 339                         free(r);
 340                         return -ENOMEM;
 341                 }
 342
 343                 r = t;
 344                 r[n++] = c;
 345         }
 346
 347         if (!r) {
 348                 r = strdup("");
 349                 if (!r)
 350                         return -ENOMEM;
 351         } else
 352                 r[n] = 0;
 353
 354         if (*a == ',')
 355                 a++;
 356
 357         *p = a;
 358
 359         free(*value);
 360         *value = r;
 361
 362         return 1;
 363 }
 364
 365 static void skip_address_key(const char **p) {
 366         assert(p);
 367         assert(*p);
 368
 369         *p += strcspn(*p, ",");
 370
 371         if (**p == ',')
 372                 (*p) ++;
 373 }
 374
 375 static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
 376         _cleanup_free_ char *path = NULL, *abstract = NULL;
 377         size_t l;
 378         int r;
 379
 380         assert(b);
 381         assert(p);
 382         assert(*p);
 383         assert(guid);
 384
 385         while (**p != 0 && **p != ';') {
 386                 r = parse_address_key(p, "guid", guid);
 387                 if (r < 0)
 388                         return r;
 389                 else if (r > 0)
 390                         continue;
 391
 392                 r = parse_address_key(p, "path", &path);
 393                 if (r < 0)
 394                         return r;
 395                 else if (r > 0)
 396                         continue;
 397
 398                 r = parse_address_key(p, "abstract", &abstract);
 399                 if (r < 0)
 400                         return r;
 401                 else if (r > 0)
 402                         continue;
 403
 404                 skip_address_key(p);
 405         }
 406
 407         if (!path && !abstract)
 408                 return -EINVAL;
 409
 410         if (path && abstract)
 411                 return -EINVAL;
 412
 413         if (path) {
 414                 l = strlen(path);
 415                 if (l > sizeof(b->sockaddr.un.sun_path))
 416                         return -E2BIG;
 417
 418                 b->sockaddr.un.sun_family = AF_UNIX;
 419                 strncpy(b->sockaddr.un.sun_path, path, sizeof(b->sockaddr.un.sun_path));
 420                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l;
 421         } else if (abstract) {
 422                 l = strlen(abstract);
 423                 if (l > sizeof(b->sockaddr.un.sun_path) - 1)
 424                         return -E2BIG;
 425
 426                 b->sockaddr.un.sun_family = AF_UNIX;
 427                 b->sockaddr.un.sun_path[0] = 0;
 428                 strncpy(b->sockaddr.un.sun_path+1, abstract, sizeof(b->sockaddr.un.sun_path)-1);
 429                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + 1 + l;
 430         }
 431
 432         return 0;
 433 }
 434
 435 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
 436         _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
 437         struct addrinfo hints, *result;
 438         int r;
 439
 440         assert(b);
 441         assert(p);
 442         assert(*p);
 443         assert(guid);
 444
 445         while (**p != 0 && **p != ';') {
 446                 r = parse_address_key(p, "guid", guid);
 447                 if (r < 0)
 448                         return r;
 449                 else if (r > 0)
 450                         continue;
 451
 452                 r = parse_address_key(p, "host", &host);
 453                 if (r < 0)
 454                         return r;
 455                 else if (r > 0)
 456                         continue;
 457
 458                 r = parse_address_key(p, "port", &port);
 459                 if (r < 0)
 460                         return r;
 461                 else if (r > 0)
 462                         continue;
 463
 464                 r = parse_address_key(p, "family", &family);
 465                 if (r < 0)
 466                         return r;
 467                 else if (r > 0)
 468                         continue;
 469
 470                 skip_address_key(p);
 471         }
 472
 473         if (!host || !port)
 474                 return -EINVAL;
 475
 476         zero(hints);
 477         hints.ai_socktype = SOCK_STREAM;
 478         hints.ai_flags = AI_ADDRCONFIG;
 479
 480         if (family) {
 481                 if (streq(family, "ipv4"))
 482                         hints.ai_family = AF_INET;
 483                 else if (streq(family, "ipv6"))
 484                         hints.ai_family = AF_INET6;
 485                 else
 486                         return -EINVAL;
 487         }
 488
 489         r = getaddrinfo(host, port, &hints, &result);
 490         if (r == EAI_SYSTEM)
 491                 return -errno;
 492         else if (r != 0)
 493                 return -EADDRNOTAVAIL;
 494
 495         memcpy(&b->sockaddr, result->ai_addr, result->ai_addrlen);
 496         b->sockaddr_size = result->ai_addrlen;
 497
 498         freeaddrinfo(result);
 499
 500         return 0;
 501 }
 502
 503 static int parse_exec_address(sd_bus *b, const char **p, char **guid) {
 504         char *path = NULL;
 505         unsigned n_argv = 0, j;
 506         char **argv = NULL;
 507         int r;
 508
 509         assert(b);
 510         assert(p);
 511         assert(*p);
 512         assert(guid);
 513
 514         while (**p != 0 && **p != ';') {
 515                 r = parse_address_key(p, "guid", guid);
 516                 if (r < 0)
 517                         goto fail;
 518                 else if (r > 0)
 519                         continue;
 520
 521                 r = parse_address_key(p, "path", &path);
 522                 if (r < 0)
 523                         goto fail;
 524                 else if (r > 0)
 525                         continue;
 526
 527                 if (startswith(*p, "argv")) {
 528                         unsigned ul;
 529
 530                         errno = 0;
 531                         ul = strtoul(*p + 4, (char**) p, 10);
 532                         if (errno > 0 || **p != '=' || ul > 256) {
 533                                 r = -EINVAL;
 534                                 goto fail;
 535                         }
 536
 537                         (*p) ++;
 538
 539                         if (ul >= n_argv) {
 540                                 char **x;
 541
 542                                 x = realloc(argv, sizeof(char*) * (ul + 2));
 543                                 if (!x) {
 544                                         r = -ENOMEM;
 545                                         goto fail;
 546                                 }
 547
 548                                 memset(x + n_argv, 0, sizeof(char*) * (ul - n_argv + 2));
 549
 550                                 argv = x;
 551                                 n_argv = ul + 1;
 552                         }
 553
 554                         r = parse_address_key(p, NULL, argv + ul);
 555                         if (r < 0)
 556                                 goto fail;
 557
 558                         continue;
 559                 }
 560
 561                 skip_address_key(p);
 562         }
 563
 564         if (!path) {
 565                 r = -EINVAL;
 566                 goto fail;
 567         }
 568
 569         /* Make sure there are no holes in the array, with the
 570          * exception of argv[0] */
 571         for (j = 1; j < n_argv; j++)
 572                 if (!argv[j]) {
 573                         r = -EINVAL;
 574                         goto fail;
 575                 }
 576
 577         if (argv && argv[0] == NULL) {
 578                 argv[0] = strdup(path);
 579                 if (!argv[0]) {
 580                         r = -ENOMEM;
 581                         goto fail;
 582                 }
 583         }
 584
 585         b->exec_path = path;
 586         b->exec_argv = argv;
 587         return 0;
 588
 589 fail:
 590         for (j = 0; j < n_argv; j++)
 591                 free(argv[j]);
 592
 593         free(argv);
 594         free(path);
 595         return r;
 596 }
 597
 598 static void bus_reset_parsed_address(sd_bus *b) {
 599         assert(b);
 600
 601         zero(b->sockaddr);
 602         b->sockaddr_size = 0;
 603         strv_free(b->exec_argv);
 604         free(b->exec_path);
 605         b->exec_path = NULL;
 606         b->exec_argv = NULL;
 607         b->server_id = SD_ID128_NULL;
 608 }
 609
 610 static int bus_parse_next_address(sd_bus *b) {
 611         _cleanup_free_ char *guid = NULL;
 612         const char *a;
 613         int r;
 614
 615         assert(b);
 616
 617         if (!b->address)
 618                 return 0;
 619         if (b->address[b->address_index] == 0)
 620                 return 0;
 621
 622         bus_reset_parsed_address(b);
 623
 624         a = b->address + b->address_index;
 625
 626         while (*a != 0) {
 627
 628                 if (*a == ';') {
 629                         a++;
 630                         continue;
 631                 }
 632
 633                 if (startswith(a, "unix:")) {
 634                         a += 5;
 635
 636                         r = parse_unix_address(b, &a, &guid);
 637                         if (r < 0)
 638                                 return r;
 639                         break;
 640
 641                 } else if (startswith(a, "tcp:")) {
 642
 643                         a += 4;
 644                         r = parse_tcp_address(b, &a, &guid);
 645                         if (r < 0)
 646                                 return r;
 647
 648                         break;
 649
 650                 } else if (startswith(a, "unixexec:")) {
 651
 652                         a += 9;
 653                         r = parse_exec_address(b, &a, &guid);
 654                         if (r < 0)
 655                                 return r;
 656
 657                         break;
 658
 659                 }
 660
 661                 a = strchr(a, ';');
 662                 if (!a)
 663                         return 0;
 664         }
 665
 666         if (guid) {
 667                 r = sd_id128_from_string(guid, &b->server_id);
 668                 if (r < 0)
 669                         return r;
 670         }
 671
 672         b->address_index = a - b->address;
 673         return 1;
 674 }
 675
 676 static int bus_start_address(sd_bus *b) {
 677         int r;
 678
 679         assert(b);
 680
 681         for (;;) {
 682                 if (b->fd >= 0) {
 683                         close_nointr_nofail(b->fd);
 684                         b->fd = -1;
 685                 }
 686
 687                 if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
 688
 689                         r = bus_socket_connect(b);
 690                         if (r >= 0)
 691                                 return r;
 692
 693                         b->last_connect_error = -r;
 694
 695                 } else if (b->exec_path) {
 696
 697                         r = bus_socket_exec(b);
 698                         if (r >= 0)
 699                                 return r;
 700
 701                         b->last_connect_error = -r;
 702                 }
 703
 704                 r = bus_parse_next_address(b);
 705                 if (r < 0)
 706                         return r;
 707                 if (r == 0)
 708                         return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
 709         }
 710 }
 711
 712 int bus_next_address(sd_bus *b) {
 713         assert(b);
 714
 715         bus_reset_parsed_address(b);
 716         return bus_start_address(b);
 717 }
 718
 719 static int bus_start_fd(sd_bus *b) {
 720         int r;
 721
 722         assert(b);
 723
 724         r = fd_nonblock(b->fd, true);
 725         if (r < 0)
 726                 return r;
 727
 728         r = fd_cloexec(b->fd, true);
 729         if (r < 0)
 730                 return r;
 731
 732         return bus_socket_take_fd(b);
 733 }
 734
 735 int sd_bus_start(sd_bus *bus) {
 736         int r;
 737
 738         if (!bus)
 739                 return -EINVAL;
 740         if (bus->state != BUS_UNSET)
 741                 return -EPERM;
 742
 743         bus->state = BUS_OPENING;
 744
 745         if (bus->is_server && bus->bus_client)
 746                 return -EINVAL;
 747
 748         if (bus->fd >= 0)
 749                 r = bus_start_fd(bus);
 750         else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path)
 751                 r = bus_start_address(bus);
 752         else
 753                 return -EINVAL;
 754
 755         if (r < 0)
 756                 return r;
 757
 758         return bus_send_hello(bus);
 759 }
 760
 761 int sd_bus_open_system(sd_bus **ret) {
 762         const char *e;
 763         sd_bus *b;
 764         int r;
 765
 766         if (!ret)
 767                 return -EINVAL;
 768
 769         r = sd_bus_new(&b);
 770         if (r < 0)
 771                 return r;
 772
 773         e = getenv("DBUS_SYSTEM_BUS_ADDRESS");
 774         if (e) {
 775                 r = sd_bus_set_address(b, e);
 776                 if (r < 0)
 777                         goto fail;
 778         } else {
 779                 b->sockaddr.un.sun_family = AF_UNIX;
 780                 strncpy(b->sockaddr.un.sun_path, "/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
 781                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/dbus/system_bus_socket") - 1;
 782         }
 783
 784         b->bus_client = true;
 785
 786         r = sd_bus_start(b);
 787         if (r < 0)
 788                 goto fail;
 789
 790         *ret = b;
 791         return 0;
 792
 793 fail:
 794         bus_free(b);
 795         return r;
 796 }
 797
 798 int sd_bus_open_user(sd_bus **ret) {
 799         const char *e;
 800         sd_bus *b;
 801         size_t l;
 802         int r;
 803
 804         if (!ret)
 805                 return -EINVAL;
 806
 807         r = sd_bus_new(&b);
 808         if (r < 0)
 809                 return r;
 810
 811         e = getenv("DBUS_SESSION_BUS_ADDRESS");
 812         if (e) {
 813                 r = sd_bus_set_address(b, e);
 814                 if (r < 0)
 815                         goto fail;
 816         } else {
 817                 e = getenv("XDG_RUNTIME_DIR");
 818                 if (!e) {
 819                         r = -ENOENT;
 820                         goto fail;
 821                 }
 822
 823                 l = strlen(e);
 824                 if (l + 4 > sizeof(b->sockaddr.un.sun_path)) {
 825                         r = -E2BIG;
 826                         goto fail;
 827                 }
 828
 829                 b->sockaddr.un.sun_family = AF_UNIX;
 830                 memcpy(mempcpy(b->sockaddr.un.sun_path, e, l), "/bus", 4);
 831                 b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + l + 4;
 832         }
 833
 834         b->bus_client = true;
 835
 836         r = sd_bus_start(b);
 837         if (r < 0)
 838                 goto fail;
 839
 840         *ret = b;
 841         return 0;
 842
 843 fail:
 844         bus_free(b);
 845         return r;
 846 }
 847
 848 void sd_bus_close(sd_bus *bus) {
 849         if (!bus)
 850                 return;
 851         if (bus->fd < 0)
 852                 return;
 853
 854         close_nointr_nofail(bus->fd);
 855         bus->fd = -1;
 856 }
 857
 858 sd_bus *sd_bus_ref(sd_bus *bus) {
 859         if (!bus)
 860                 return NULL;
 861
 862         assert(bus->n_ref > 0);
 863
 864         bus->n_ref++;
 865         return bus;
 866 }
 867
 868 sd_bus *sd_bus_unref(sd_bus *bus) {
 869         if (!bus)
 870                 return NULL;
 871
 872         assert(bus->n_ref > 0);
 873         bus->n_ref--;
 874
 875         if (bus->n_ref <= 0)
 876                 bus_free(bus);
 877
 878         return NULL;
 879 }
 880
 881 int sd_bus_is_open(sd_bus *bus) {
 882         if (!bus)
 883                 return -EINVAL;
 884
 885         return bus->state != BUS_UNSET && bus->fd >= 0;
 886 }
 887
 888 int sd_bus_can_send(sd_bus *bus, char type) {
 889         int r;
 890
 891         if (!bus)
 892                 return -EINVAL;
 893         if (bus->fd < 0)
 894                 return -ENOTCONN;
 895
 896         if (type == SD_BUS_TYPE_UNIX_FD) {
 897                 if (!bus->negotiate_fds)
 898                         return 0;
 899
 900                 r = bus_ensure_running(bus);
 901                 if (r < 0)
 902                         return r;
 903
 904                 return bus->can_fds;
 905         }
 906
 907         return bus_type_is_valid(type);
 908 }
 909
 910 int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
 911         int r;
 912
 913         if (!bus)
 914                 return -EINVAL;
 915         if (!server_id)
 916                 return -EINVAL;
 917
 918         r = bus_ensure_running(bus);
 919         if (r < 0)
 920                 return r;
 921
 922         *server_id = bus->server_id;
 923         return 0;
 924 }
 925
 926 static int bus_seal_message(sd_bus *b, sd_bus_message *m) {
 927         assert(m);
 928
 929         if (m->header->version > b->message_version)
 930                 return -EPERM;
 931
 932         if (m->sealed)
 933                 return 0;
 934
 935         return bus_message_seal(m, ++b->serial);
 936 }
 937
 938 static int dispatch_wqueue(sd_bus *bus) {
 939         int r, ret = 0;
 940
 941         assert(bus);
 942         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 943
 944         if (bus->fd < 0)
 945                 return -ENOTCONN;
 946
 947         while (bus->wqueue_size > 0) {
 948
 949                 r = bus_socket_write_message(bus, bus->wqueue[0], &bus->windex);
 950                 if (r < 0) {
 951                         sd_bus_close(bus);
 952                         return r;
 953                 } else if (r == 0)
 954                         /* Didn't do anything this time */
 955                         return ret;
 956                 else if (bus->windex >= bus->wqueue[0]->size) {
 957                         /* Fully written. Let's drop the entry from
 958                          * the queue.
 959                          *
 960                          * This isn't particularly optimized, but
 961                          * well, this is supposed to be our worst-case
 962                          * buffer only, and the socket buffer is
 963                          * supposed to be our primary buffer, and if
 964                          * it got full, then all bets are off
 965                          * anyway. */
 966
 967                         sd_bus_message_unref(bus->wqueue[0]);
 968                         bus->wqueue_size --;
 969                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
 970                         bus->windex = 0;
 971
 972                         ret = 1;
 973                 }
 974         }
 975
 976         return ret;
 977 }
 978
 979 static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
 980         sd_bus_message *z = NULL;
 981         int r, ret = 0;
 982
 983         assert(bus);
 984         assert(m);
 985         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 986
 987         if (bus->fd < 0)
 988                 return -ENOTCONN;
 989
 990         if (bus->rqueue_size > 0) {
 991                 /* Dispatch a queued message */
 992
 993                 *m = bus->rqueue[0];
 994                 bus->rqueue_size --;
 995                 memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
 996                 return 1;
 997         }
 998
 999         /* Try to read a new message */
1000         do {
1001                 r = bus_socket_read_message(bus, &z);
1002                 if (r < 0) {
1003                         sd_bus_close(bus);
1004                         return r;
1005                 }
1006                 if (r == 0)
1007                         return ret;
1008
1009                 r = 1;
1010         } while (!z);
1011
1012         *m = z;
1013         return 1;
1014 }
1015
1016 int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
1017         int r;
1018
1019         if (!bus)
1020                 return -EINVAL;
1021         if (bus->state == BUS_UNSET)
1022                 return -ENOTCONN;
1023         if (bus->fd < 0)
1024                 return -ENOTCONN;
1025         if (!m)
1026                 return -EINVAL;
1027
1028         if (m->n_fds > 0) {
1029                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1030                 if (r < 0)
1031                         return r;
1032                 if (r == 0)
1033                         return -ENOTSUP;
1034         }
1035
1036         /* If the serial number isn't kept, then we know that no reply
1037          * is expected */
1038         if (!serial && !m->sealed)
1039                 m->header->flags |= SD_BUS_MESSAGE_NO_REPLY_EXPECTED;
1040
1041         r = bus_seal_message(bus, m);
1042         if (r < 0)
1043                 return r;
1044
1045         /* If this is a reply and no reply was requested, then let's
1046          * suppress this, if we can */
1047         if (m->dont_send && !serial)
1048                 return 0;
1049
1050         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1051                 size_t idx = 0;
1052
1053                 r = bus_socket_write_message(bus, m, &idx);
1054                 if (r < 0) {
1055                         sd_bus_close(bus);
1056                         return r;
1057                 } else if (idx < m->size)  {
1058                         /* Wasn't fully written. So let's remember how
1059                          * much was written. Note that the first entry
1060                          * of the wqueue array is always allocated so
1061                          * that we always can remember how much was
1062                          * written. */
1063                         bus->wqueue[0] = sd_bus_message_ref(m);
1064                         bus->wqueue_size = 1;
1065                         bus->windex = idx;
1066                 }
1067         } else {
1068                 sd_bus_message **q;
1069
1070                 /* Just append it to the queue. */
1071
1072                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1073                         return -ENOBUFS;
1074
1075                 q = realloc(bus->wqueue, sizeof(sd_bus_message*) * (bus->wqueue_size + 1));
1076                 if (!q)
1077                         return -ENOMEM;
1078
1079                 bus->wqueue = q;
1080                 q[bus->wqueue_size ++] = sd_bus_message_ref(m);
1081         }
1082
1083         if (serial)
1084                 *serial = BUS_MESSAGE_SERIAL(m);
1085
1086         return 0;
1087 }
1088
1089 static usec_t calc_elapse(uint64_t usec) {
1090         if (usec == (uint64_t) -1)
1091                 return 0;
1092
1093         if (usec == 0)
1094                 usec = BUS_DEFAULT_TIMEOUT;
1095
1096         return now(CLOCK_MONOTONIC) + usec;
1097 }
1098
1099 static int timeout_compare(const void *a, const void *b) {
1100         const struct reply_callback *x = a, *y = b;
1101
1102         if (x->timeout != 0 && y->timeout == 0)
1103                 return -1;
1104
1105         if (x->timeout == 0 && y->timeout != 0)
1106                 return 1;
1107
1108         if (x->timeout < y->timeout)
1109                 return -1;
1110
1111         if (x->timeout > y->timeout)
1112                 return 1;
1113
1114         return 0;
1115 }
1116
1117 int sd_bus_send_with_reply(
1118                 sd_bus *bus,
1119                 sd_bus_message *m,
1120                 sd_bus_message_handler_t callback,
1121                 void *userdata,
1122                 uint64_t usec,
1123                 uint64_t *serial) {
1124
1125         struct reply_callback *c;
1126         int r;
1127
1128         if (!bus)
1129                 return -EINVAL;
1130         if (bus->state == BUS_UNSET)
1131                 return -ENOTCONN;
1132         if (bus->fd < 0)
1133                 return -ENOTCONN;
1134         if (!m)
1135                 return -EINVAL;
1136         if (!callback)
1137                 return -EINVAL;
1138         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1139                 return -EINVAL;
1140         if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1141                 return -EINVAL;
1142
1143         r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1144         if (r < 0)
1145                 return r;
1146
1147         if (usec != (uint64_t) -1) {
1148                 r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1149                 if (r < 0)
1150                         return r;
1151         }
1152
1153         r = bus_seal_message(bus, m);
1154         if (r < 0)
1155                 return r;
1156
1157         c = new(struct reply_callback, 1);
1158         if (!c)
1159                 return -ENOMEM;
1160
1161         c->callback = callback;
1162         c->userdata = userdata;
1163         c->serial = BUS_MESSAGE_SERIAL(m);
1164         c->timeout = calc_elapse(usec);
1165
1166         r = hashmap_put(bus->reply_callbacks, &c->serial, c);
1167         if (r < 0) {
1168                 free(c);
1169                 return r;
1170         }
1171
1172         if (c->timeout != 0) {
1173                 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1174                 if (r < 0) {
1175                         c->timeout = 0;
1176                         sd_bus_send_with_reply_cancel(bus, c->serial);
1177                         return r;
1178                 }
1179         }
1180
1181         r = sd_bus_send(bus, m, serial);
1182         if (r < 0) {
1183                 sd_bus_send_with_reply_cancel(bus, c->serial);
1184                 return r;
1185         }
1186
1187         return r;
1188 }
1189
1190 int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
1191         struct reply_callback *c;
1192
1193         if (!bus)
1194                 return -EINVAL;
1195         if (serial == 0)
1196                 return -EINVAL;
1197
1198         c = hashmap_remove(bus->reply_callbacks, &serial);
1199         if (!c)
1200                 return 0;
1201
1202         if (c->timeout != 0)
1203                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1204
1205         free(c);
1206         return 1;
1207 }
1208
1209 int bus_ensure_running(sd_bus *bus) {
1210         int r;
1211
1212         assert(bus);
1213
1214         if (bus->fd < 0)
1215                 return -ENOTCONN;
1216         if (bus->state == BUS_UNSET)
1217                 return -ENOTCONN;
1218
1219         if (bus->state == BUS_RUNNING)
1220                 return 1;
1221
1222         for (;;) {
1223                 r = sd_bus_process(bus, NULL);
1224                 if (r < 0)
1225                         return r;
1226                 if (bus->state == BUS_RUNNING)
1227                         return 1;
1228                 if (r > 0)
1229                         continue;
1230
1231                 r = sd_bus_wait(bus, (uint64_t) -1);
1232                 if (r < 0)
1233                         return r;
1234         }
1235 }
1236
1237 int sd_bus_send_with_reply_and_block(
1238                 sd_bus *bus,
1239                 sd_bus_message *m,
1240                 uint64_t usec,
1241                 sd_bus_error *error,
1242                 sd_bus_message **reply) {
1243
1244         int r;
1245         usec_t timeout;
1246         uint64_t serial;
1247         bool room = false;
1248
1249         if (!bus)
1250                 return -EINVAL;
1251         if (bus->fd < 0)
1252                 return -ENOTCONN;
1253         if (bus->state == BUS_UNSET)
1254                 return -ENOTCONN;
1255         if (!m)
1256                 return -EINVAL;
1257         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1258                 return -EINVAL;
1259         if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1260                 return -EINVAL;
1261         if (bus_error_is_dirty(error))
1262                 return -EINVAL;
1263
1264         r = bus_ensure_running(bus);
1265         if (r < 0)
1266                 return r;
1267
1268         r = sd_bus_send(bus, m, &serial);
1269         if (r < 0)
1270                 return r;
1271
1272         timeout = calc_elapse(usec);
1273
1274         for (;;) {
1275                 usec_t left;
1276                 sd_bus_message *incoming = NULL;
1277
1278                 if (!room) {
1279                         sd_bus_message **q;
1280
1281                         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1282                                 return -ENOBUFS;
1283
1284                         /* Make sure there's room for queuing this
1285                          * locally, before we read the message */
1286
1287                         q = realloc(bus->rqueue, (bus->rqueue_size + 1) * sizeof(sd_bus_message*));
1288                         if (!q)
1289                                 return -ENOMEM;
1290
1291                         bus->rqueue = q;
1292                         room = true;
1293                 }
1294
1295                 r = bus_socket_read_message(bus, &incoming);
1296                 if (r < 0)
1297                         return r;
1298                 if (incoming) {
1299
1300                         if (incoming->reply_serial == serial) {
1301                                 /* Found a match! */
1302
1303                                 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_RETURN) {
1304                                         *reply = incoming;
1305                                         return 0;
1306                                 }
1307
1308                                 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_ERROR) {
1309                                         int k;
1310
1311                                         r = sd_bus_error_copy(error, &incoming->error);
1312                                         if (r < 0) {
1313                                                 sd_bus_message_unref(incoming);
1314                                                 return r;
1315                                         }
1316
1317                                         k = bus_error_to_errno(&incoming->error);
1318                                         sd_bus_message_unref(incoming);
1319                                         return k;
1320                                 }
1321
1322                                 sd_bus_message_unref(incoming);
1323                                 return -EIO;
1324                         }
1325
1326                         /* There's already guaranteed to be room for
1327                          * this, so need to resize things here */
1328                         bus->rqueue[bus->rqueue_size ++] = incoming;
1329                         room = false;
1330
1331                         /* Try to read more, right-away */
1332                         continue;
1333                 }
1334                 if (r != 0)
1335                         continue;
1336
1337                 if (timeout > 0) {
1338                         usec_t n;
1339
1340                         n = now(CLOCK_MONOTONIC);
1341                         if (n >= timeout)
1342                                 return -ETIMEDOUT;
1343
1344                         left = timeout - n;
1345                 } else
1346                         left = (uint64_t) -1;
1347
1348                 r = bus_poll(bus, true, left);
1349                 if (r < 0)
1350                         return r;
1351
1352                 r = dispatch_wqueue(bus);
1353                 if (r < 0)
1354                         return r;
1355         }
1356 }
1357
1358 int sd_bus_get_fd(sd_bus *bus) {
1359         if (!bus)
1360                 return -EINVAL;
1361
1362         if (bus->fd < 0)
1363                 return -ENOTCONN;
1364
1365         return bus->fd;
1366 }
1367
1368 int sd_bus_get_events(sd_bus *bus) {
1369         int flags = 0;
1370
1371         if (!bus)
1372                 return -EINVAL;
1373         if (bus->state == BUS_UNSET)
1374                 return -ENOTCONN;
1375         if (bus->fd < 0)
1376                 return -ENOTCONN;
1377
1378         if (bus->state == BUS_OPENING)
1379                 flags |= POLLOUT;
1380         else if (bus->state == BUS_AUTHENTICATING) {
1381
1382                 if (bus_socket_auth_needs_write(bus))
1383                         flags |= POLLOUT;
1384
1385                 flags |= POLLIN;
1386
1387         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1388                 if (bus->rqueue_size <= 0)
1389                         flags |= POLLIN;
1390                 if (bus->wqueue_size > 0)
1391                         flags |= POLLOUT;
1392         }
1393
1394         return flags;
1395 }
1396
1397 int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1398         struct reply_callback *c;
1399
1400         if (!bus)
1401                 return -EINVAL;
1402         if (!timeout_usec)
1403                 return -EINVAL;
1404         if (bus->state == BUS_UNSET)
1405                 return -ENOTCONN;
1406         if (bus->fd < 0)
1407                 return -ENOTCONN;
1408
1409         if (bus->state == BUS_AUTHENTICATING) {
1410                 *timeout_usec = bus->auth_timeout;
1411                 return 1;
1412         }
1413
1414         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO)
1415                 return 0;
1416
1417         c = prioq_peek(bus->reply_callbacks_prioq);
1418         if (!c)
1419                 return 0;
1420
1421         *timeout_usec = c->timeout;
1422         return 1;
1423 }
1424
1425 static int process_timeout(sd_bus *bus) {
1426         struct reply_callback *c;
1427         usec_t n;
1428         int r;
1429
1430         assert(bus);
1431
1432         c = prioq_peek(bus->reply_callbacks_prioq);
1433         if (!c)
1434                 return 0;
1435
1436         n = now(CLOCK_MONOTONIC);
1437         if (c->timeout > n)
1438                 return 0;
1439
1440         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1441         hashmap_remove(bus->reply_callbacks, &c->serial);
1442
1443         r = c->callback(bus, ETIMEDOUT, NULL, c->userdata);
1444         free(c);
1445
1446         return r < 0 ? r : 1;
1447 }
1448
1449 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1450         assert(bus);
1451         assert(m);
1452
1453         if (bus->state != BUS_HELLO)
1454                 return 0;
1455
1456         /* Let's make sure the first message on the bus is the HELLO
1457          * reply. But note that we don't actually parse the message
1458          * here (we leave that to the usual handling), we just verify
1459          * we don't let any earlier msg through. */
1460
1461         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1462             m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1463                 return -EIO;
1464
1465         if (m->reply_serial != bus->hello_serial)
1466                 return -EIO;
1467
1468         return 0;
1469 }
1470
1471 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1472         struct reply_callback *c;
1473         int r;
1474
1475         assert(bus);
1476         assert(m);
1477
1478         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_RETURN &&
1479             m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_ERROR)
1480                 return 0;
1481
1482         c = hashmap_remove(bus->reply_callbacks, &m->reply_serial);
1483         if (!c)
1484                 return 0;
1485
1486         if (c->timeout != 0)
1487                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1488
1489         r = c->callback(bus, 0, m, c->userdata);
1490         free(c);
1491
1492         return r;
1493 }
1494
1495 static int process_filter(sd_bus *bus, sd_bus_message *m) {
1496         struct filter_callback *l;
1497         int r;
1498
1499         assert(bus);
1500         assert(m);
1501
1502         LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
1503                 r = l->callback(bus, 0, m, l->userdata);
1504                 if (r != 0)
1505                         return r;
1506         }
1507
1508         return 0;
1509 }
1510
1511 static int process_match(sd_bus *bus, sd_bus_message *m) {
1512         assert(bus);
1513         assert(m);
1514
1515         return bus_match_run(bus, &bus->match_callbacks, 0, m);
1516 }
1517
1518 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
1519         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1520         int r;
1521
1522         assert(bus);
1523         assert(m);
1524
1525         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1526                 return 0;
1527
1528         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
1529                 return 0;
1530
1531         if (m->header->flags & SD_BUS_MESSAGE_NO_REPLY_EXPECTED)
1532                 return 1;
1533
1534         if (streq_ptr(m->member, "Ping"))
1535                 r = sd_bus_message_new_method_return(bus, m, &reply);
1536         else if (streq_ptr(m->member, "GetMachineId")) {
1537                 sd_id128_t id;
1538                 char sid[33];
1539
1540                 r = sd_id128_get_machine(&id);
1541                 if (r < 0)
1542                         return r;
1543
1544                 r = sd_bus_message_new_method_return(bus, m, &reply);
1545                 if (r < 0)
1546                         return r;
1547
1548                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
1549         } else {
1550                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_INIT;
1551
1552                 sd_bus_error_set(&error,
1553                                  "org.freedesktop.DBus.Error.UnknownMethod",
1554                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
1555
1556                 r = sd_bus_message_new_method_error(bus, m, &error, &reply);
1557         }
1558
1559         if (r < 0)
1560                 return r;
1561
1562         r = sd_bus_send(bus, reply, NULL);
1563         if (r < 0)
1564                 return r;
1565
1566         return 1;
1567 }
1568
1569 static int process_object(sd_bus *bus, sd_bus_message *m) {
1570         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_INIT;
1571         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1572         struct object_callback *c;
1573         char *p;
1574         int r;
1575         bool found = false;
1576
1577         assert(bus);
1578         assert(m);
1579
1580         if (m->header->type != SD_BUS_MESSAGE_TYPE_METHOD_CALL)
1581                 return 0;
1582
1583         if (hashmap_isempty(bus->object_callbacks))
1584                 return 0;
1585
1586         c = hashmap_get(bus->object_callbacks, m->path);
1587         if (c) {
1588                 r = c->callback(bus, 0, m, c->userdata);
1589                 if (r != 0)
1590                         return r;
1591
1592                 found = true;
1593         }
1594
1595         /* Look for fallback prefixes */
1596         p = strdupa(m->path);
1597         for (;;) {
1598                 char *e;
1599
1600                 e = strrchr(p, '/');
1601                 if (e == p || !e)
1602                         break;
1603
1604                 *e = 0;
1605
1606                 c = hashmap_get(bus->object_callbacks, p);
1607                 if (c && c->is_fallback) {
1608                         r = c->callback(bus, 0, m, c->userdata);
1609                         if (r != 0)
1610                                 return r;
1611
1612                         found = true;
1613                 }
1614         }
1615
1616         /* We found some handlers but none wanted to take this, then
1617          * return this -- with one exception, we can handle
1618          * introspection minimally ourselves */
1619         if (!found || sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect"))
1620                 return 0;
1621
1622         sd_bus_error_set(&error,
1623                          "org.freedesktop.DBus.Error.UnknownMethod",
1624                          "Unknown method '%s' or interface '%s'.", m->member, m->interface);
1625
1626         r = sd_bus_message_new_method_error(bus, m, &error, &reply);
1627         if (r < 0)
1628                 return r;
1629
1630         r = sd_bus_send(bus, reply, NULL);
1631         if (r < 0)
1632                 return r;
1633
1634         return 1;
1635 }
1636
1637 static int process_introspect(sd_bus *bus, sd_bus_message *m) {
1638         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1639         _cleanup_free_ char *introspection = NULL;
1640         _cleanup_set_free_free_ Set *s = NULL;
1641         _cleanup_fclose_ FILE *f = NULL;
1642         struct object_callback *c;
1643         Iterator i;
1644         size_t size = 0;
1645         char *node;
1646         int r;
1647
1648         assert(bus);
1649         assert(m);
1650
1651         if (!sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect"))
1652                 return 0;
1653
1654         if (!m->path)
1655                 return 0;
1656
1657         s = set_new(string_hash_func, string_compare_func);
1658         if (!s)
1659                 return -ENOMEM;
1660
1661         HASHMAP_FOREACH(c, bus->object_callbacks, i) {
1662                 const char *e;
1663                 char *a, *p;
1664
1665                 if (streq(c->path, "/"))
1666                         continue;
1667
1668                 if (streq(m->path, "/"))
1669                         e = c->path;
1670                 else {
1671                         e = startswith(c->path, m->path);
1672                         if (!e || *e != '/')
1673                                 continue;
1674                 }
1675
1676                 a = strdup(e+1);
1677                 if (!a)
1678                         return -ENOMEM;
1679
1680                 p = strchr(a, '/');
1681                 if (p)
1682                         *p = 0;
1683
1684                 r = set_put(s, a);
1685                 if (r < 0) {
1686                         free(a);
1687
1688                         if (r != -EEXIST)
1689                                 return r;
1690                 }
1691         }
1692
1693         f = open_memstream(&introspection, &size);
1694         if (!f)
1695                 return -ENOMEM;
1696
1697         fputs(SD_BUS_INTROSPECT_DOCTYPE, f);
1698         fputs("<node>\n", f);
1699         fputs(SD_BUS_INTROSPECT_INTERFACE_PEER, f);
1700         fputs(SD_BUS_INTROSPECT_INTERFACE_INTROSPECTABLE, f);
1701
1702         while ((node = set_steal_first(s))) {
1703                 fprintf(f, " <node name=\"%s\"/>\n", node);
1704                 free(node);
1705         }
1706
1707         fputs("</node>\n", f);
1708
1709         fflush(f);
1710
1711         if (ferror(f))
1712                 return -ENOMEM;
1713
1714         r = sd_bus_message_new_method_return(bus, m, &reply);
1715         if (r < 0)
1716                 return r;
1717
1718         r = sd_bus_message_append(reply, "s", introspection);
1719         if (r < 0)
1720                 return r;
1721
1722         r = sd_bus_send(bus, reply, NULL);
1723         if (r < 0)
1724                 return r;
1725
1726         return 1;
1727 }
1728
1729 static int process_message(sd_bus *bus, sd_bus_message *m) {
1730         int r;
1731
1732         assert(bus);
1733         assert(m);
1734
1735         r = process_hello(bus, m);
1736         if (r != 0)
1737                 return r;
1738
1739         r = process_reply(bus, m);
1740         if (r != 0)
1741                 return r;
1742
1743         r = process_filter(bus, m);
1744         if (r != 0)
1745                 return r;
1746
1747         r = process_match(bus, m);
1748         if (r != 0)
1749                 return r;
1750
1751         r = process_builtin(bus, m);
1752         if (r != 0)
1753                 return r;
1754
1755         r = process_object(bus, m);
1756         if (r != 0)
1757                 return r;
1758
1759         return process_introspect(bus, m);
1760 }
1761
1762 static int process_running(sd_bus *bus, sd_bus_message **ret) {
1763         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1764         int r;
1765
1766         assert(bus);
1767         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1768
1769         r = process_timeout(bus);
1770         if (r != 0)
1771                 goto null_message;
1772
1773         r = dispatch_wqueue(bus);
1774         if (r != 0)
1775                 goto null_message;
1776
1777         r = dispatch_rqueue(bus, &m);
1778         if (r < 0)
1779                 return r;
1780         if (!m)
1781                 goto null_message;
1782
1783         r = process_message(bus, m);
1784         if (r != 0)
1785                 goto null_message;
1786
1787         if (ret) {
1788                 *ret = m;
1789                 m = NULL;
1790                 return 1;
1791         }
1792
1793         if (m->header->type == SD_BUS_MESSAGE_TYPE_METHOD_CALL) {
1794                 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1795                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_INIT;
1796
1797                 sd_bus_error_set(&error, "org.freedesktop.DBus.Error.UnknownObject", "Unknown object '%s'.", m->path);
1798
1799                 r = sd_bus_message_new_method_error(bus, m, &error, &reply);
1800                 if (r < 0)
1801                         return r;
1802
1803                 r = sd_bus_send(bus, reply, NULL);
1804                 if (r < 0)
1805                         return r;
1806         }
1807
1808         return 1;
1809
1810 null_message:
1811         if (r >= 0 && ret)
1812                 *ret = NULL;
1813
1814         return r;
1815 }
1816
1817 int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
1818         int r;
1819
1820         /* Returns 0 when we didn't do anything. This should cause the
1821          * caller to invoke sd_bus_wait() before returning the next
1822          * time. Returns > 0 when we did something, which possibly
1823          * means *ret is filled in with an unprocessed message. */
1824
1825         if (!bus)
1826                 return -EINVAL;
1827         if (bus->fd < 0)
1828                 return -ENOTCONN;
1829
1830         switch (bus->state) {
1831
1832         case BUS_UNSET:
1833                 return -ENOTCONN;
1834
1835         case BUS_OPENING:
1836                 r = bus_socket_process_opening(bus);
1837                 if (r < 0)
1838                         return r;
1839                 if (ret)
1840                         *ret = NULL;
1841                 return r;
1842
1843         case BUS_AUTHENTICATING:
1844
1845                 r = bus_socket_process_authenticating(bus);
1846                 if (r < 0)
1847                         return r;
1848                 if (ret)
1849                         *ret = NULL;
1850                 return r;
1851
1852         case BUS_RUNNING:
1853         case BUS_HELLO:
1854
1855                 return process_running(bus, ret);
1856         }
1857
1858         assert_not_reached("Unknown state");
1859 }
1860
1861 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
1862         struct pollfd p;
1863         int r, e;
1864         struct timespec ts;
1865         usec_t until, m;
1866
1867         assert(bus);
1868
1869         if (bus->fd < 0)
1870                 return -ENOTCONN;
1871
1872         e = sd_bus_get_events(bus);
1873         if (e < 0)
1874                 return e;
1875
1876         if (need_more)
1877                 e |= POLLIN;
1878
1879         r = sd_bus_get_timeout(bus, &until);
1880         if (r < 0)
1881                 return r;
1882         if (r == 0)
1883                 m = (uint64_t) -1;
1884         else {
1885                 usec_t n;
1886                 n = now(CLOCK_MONOTONIC);
1887                 m = until > n ? until - n : 0;
1888         }
1889
1890         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
1891                 m = timeout_usec;
1892
1893         zero(p);
1894         p.fd = bus->fd;
1895         p.events = e;
1896
1897         r = ppoll(&p, 1, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
1898         if (r < 0)
1899                 return -errno;
1900
1901         return r > 0 ? 1 : 0;
1902 }
1903
1904 int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
1905
1906         if (!bus)
1907                 return -EINVAL;
1908         if (bus->state == BUS_UNSET)
1909                 return -ENOTCONN;
1910         if (bus->fd < 0)
1911                 return -ENOTCONN;
1912         if (bus->rqueue_size > 0)
1913                 return 0;
1914
1915         return bus_poll(bus, false, timeout_usec);
1916 }
1917
1918 int sd_bus_flush(sd_bus *bus) {
1919         int r;
1920
1921         if (!bus)
1922                 return -EINVAL;
1923         if (bus->state == BUS_UNSET)
1924                 return -ENOTCONN;
1925         if (bus->fd < 0)
1926                 return -ENOTCONN;
1927
1928         r = bus_ensure_running(bus);
1929         if (r < 0)
1930                 return r;
1931
1932         if (bus->wqueue_size <= 0)
1933                 return 0;
1934
1935         for (;;) {
1936                 r = dispatch_wqueue(bus);
1937                 if (r < 0)
1938                         return r;
1939
1940                 if (bus->wqueue_size <= 0)
1941                         return 0;
1942
1943                 r = bus_poll(bus, false, (uint64_t) -1);
1944                 if (r < 0)
1945                         return r;
1946         }
1947 }
1948
1949 int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
1950         struct filter_callback *f;
1951
1952         if (!bus)
1953                 return -EINVAL;
1954         if (!callback)
1955                 return -EINVAL;
1956
1957         f = new(struct filter_callback, 1);
1958         if (!f)
1959                 return -ENOMEM;
1960         f->callback = callback;
1961         f->userdata = userdata;
1962
1963         LIST_PREPEND(struct filter_callback, callbacks, bus->filter_callbacks, f);
1964         return 0;
1965 }
1966
1967 int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
1968         struct filter_callback *f;
1969
1970         if (!bus)
1971                 return -EINVAL;
1972         if (!callback)
1973                 return -EINVAL;
1974
1975         LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
1976                 if (f->callback == callback && f->userdata == userdata) {
1977                         LIST_REMOVE(struct filter_callback, callbacks, bus->filter_callbacks, f);
1978                         free(f);
1979                         return 1;
1980                 }
1981         }
1982
1983         return 0;
1984 }
1985
1986 static int bus_add_object(
1987                 sd_bus *bus,
1988                 bool fallback,
1989                 const char *path,
1990                 sd_bus_message_handler_t callback,
1991                 void *userdata) {
1992
1993         struct object_callback *c;
1994         int r;
1995
1996         if (!bus)
1997                 return -EINVAL;
1998         if (!path)
1999                 return -EINVAL;
2000         if (!callback)
2001                 return -EINVAL;
2002
2003         r = hashmap_ensure_allocated(&bus->object_callbacks, string_hash_func, string_compare_func);
2004         if (r < 0)
2005                 return r;
2006
2007         c = new(struct object_callback, 1);
2008         if (!c)
2009                 return -ENOMEM;
2010
2011         c->path = strdup(path);
2012         if (!c->path) {
2013                 free(c);
2014                 return -ENOMEM;
2015         }
2016
2017         c->callback = callback;
2018         c->userdata = userdata;
2019         c->is_fallback = fallback;
2020
2021         r = hashmap_put(bus->object_callbacks, c->path, c);
2022         if (r < 0) {
2023                 free(c->path);
2024                 free(c);
2025                 return r;
2026         }
2027
2028         return 0;
2029 }
2030
2031 static int bus_remove_object(
2032                 sd_bus *bus,
2033                 bool fallback,
2034                 const char *path,
2035                 sd_bus_message_handler_t callback,
2036                 void *userdata) {
2037
2038         struct object_callback *c;
2039
2040         if (!bus)
2041                 return -EINVAL;
2042         if (!path)
2043                 return -EINVAL;
2044         if (!callback)
2045                 return -EINVAL;
2046
2047         c = hashmap_get(bus->object_callbacks, path);
2048         if (!c)
2049                 return 0;
2050
2051         if (c->callback != callback || c->userdata != userdata || c->is_fallback != fallback)
2052                 return 0;
2053
2054         assert_se(c == hashmap_remove(bus->object_callbacks, c->path));
2055
2056         free(c->path);
2057         free(c);
2058
2059         return 1;
2060 }
2061
2062 int sd_bus_add_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
2063         return bus_add_object(bus, false, path, callback, userdata);
2064 }
2065
2066 int sd_bus_remove_object(sd_bus *bus, const char *path, sd_bus_message_handler_t callback, void *userdata) {
2067         return bus_remove_object(bus, false, path, callback, userdata);
2068 }
2069
2070 int sd_bus_add_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
2071         return bus_add_object(bus, true, prefix, callback, userdata);
2072 }
2073
2074 int sd_bus_remove_fallback(sd_bus *bus, const char *prefix, sd_bus_message_handler_t callback, void *userdata) {
2075         return bus_remove_object(bus, true, prefix, callback, userdata);
2076 }
2077
2078 int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
2079         int r = 0;
2080
2081         if (!bus)
2082                 return -EINVAL;
2083         if (!match)
2084                 return -EINVAL;
2085
2086         if (bus->bus_client) {
2087                 r = bus_add_match_internal(bus, match);
2088                 if (r < 0)
2089                         return r;
2090         }
2091
2092         if (callback) {
2093                 r = bus_match_add(&bus->match_callbacks, match, callback, userdata, NULL);
2094                 if (r < 0) {
2095
2096                         if (bus->bus_client)
2097                                 bus_remove_match_internal(bus, match);
2098                 }
2099         }
2100
2101         return r;
2102 }
2103
2104 int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
2105         int r = 0, q = 0;
2106
2107         if (!bus)
2108                 return -EINVAL;
2109         if (!match)
2110                 return -EINVAL;
2111
2112         if (bus->bus_client)
2113                 r = bus_remove_match_internal(bus, match);
2114
2115         if (callback)
2116                 q = bus_match_remove(&bus->match_callbacks, match, callback, userdata);
2117
2118         if (r < 0)
2119                 return r;
2120         return q;
2121 }