src/libsystemd-bus/sd-bus.c

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