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