src/libsystemd-bus/sd-bus.c

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