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