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