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