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