src/libsystemd-bus/sd-bus.c

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