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                         sd_bus_message_unref(bus->wqueue[0]);
1429                         bus->wqueue_size --;
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 _public_ int sd_bus_call(
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         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1731         usec_t timeout;
1732         uint64_t cookie;
1733         unsigned i;
1734         int r;
1735
1736         assert_return(bus, -EINVAL);
1737         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1738         assert_return(m, -EINVAL);
1739         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1740         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1741         assert_return(!bus_error_is_dirty(error), -EINVAL);
1742         assert_return(!bus_pid_changed(bus), -ECHILD);
1743
1744         r = bus_ensure_running(bus);
1745         if (r < 0)
1746                 return r;
1747
1748         i = bus->rqueue_size;
1749
1750         r = bus_seal_message(bus, m, usec);
1751         if (r < 0)
1752                 return r;
1753
1754         r = bus_remarshal_message(bus, &m);
1755         if (r < 0)
1756                 return r;
1757
1758         r = sd_bus_send(bus, m, &cookie);
1759         if (r < 0)
1760                 return r;
1761
1762         timeout = calc_elapse(m->timeout);
1763
1764         for (;;) {
1765                 usec_t left;
1766
1767                 while (i < bus->rqueue_size) {
1768                         sd_bus_message *incoming = NULL;
1769
1770                         incoming = bus->rqueue[i];
1771
1772                         if (incoming->reply_cookie == cookie) {
1773                                 /* Found a match! */
1774
1775                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1776                                 bus->rqueue_size--;
1777
1778                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1779
1780                                         if (reply)
1781                                                 *reply = incoming;
1782                                         else
1783                                                 sd_bus_message_unref(incoming);
1784
1785                                         return 1;
1786                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1787                                         r = sd_bus_error_copy(error, &incoming->error);
1788                                 else
1789                                         r = -EIO;
1790
1791                                 sd_bus_message_unref(incoming);
1792                                 return r;
1793
1794                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1795                                    bus->unique_name &&
1796                                    incoming->sender &&
1797                                    streq(bus->unique_name, incoming->sender)) {
1798
1799                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1800                                 bus->rqueue_size--;
1801
1802                                 /* Our own message? Somebody is trying
1803                                  * to send its own client a message,
1804                                  * let's not dead-lock, let's fail
1805                                  * immediately. */
1806
1807                                 sd_bus_message_unref(incoming);
1808                                 return -ELOOP;
1809                         }
1810
1811                         /* Try to read more, right-away */
1812                         i++;
1813                 }
1814
1815                 r = bus_read_message(bus);
1816                 if (r < 0) {
1817                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1818                                 bus_enter_closing(bus);
1819                                 return -ECONNRESET;
1820                         }
1821
1822                         return r;
1823                 }
1824                 if (r > 0)
1825                         continue;
1826
1827                 if (timeout > 0) {
1828                         usec_t n;
1829
1830                         n = now(CLOCK_MONOTONIC);
1831                         if (n >= timeout)
1832                                 return -ETIMEDOUT;
1833
1834                         left = timeout - n;
1835                 } else
1836                         left = (uint64_t) -1;
1837
1838                 r = bus_poll(bus, true, left);
1839                 if (r < 0)
1840                         return r;
1841                 if (r == 0)
1842                         return -ETIMEDOUT;
1843
1844                 r = dispatch_wqueue(bus);
1845                 if (r < 0) {
1846                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1847                                 bus_enter_closing(bus);
1848                                 return -ECONNRESET;
1849                         }
1850
1851                         return r;
1852                 }
1853         }
1854 }
1855
1856 _public_ int sd_bus_get_fd(sd_bus *bus) {
1857
1858         assert_return(bus, -EINVAL);
1859         assert_return(bus->input_fd == bus->output_fd, -EPERM);
1860         assert_return(!bus_pid_changed(bus), -ECHILD);
1861
1862         return bus->input_fd;
1863 }
1864
1865 _public_ int sd_bus_get_events(sd_bus *bus) {
1866         int flags = 0;
1867
1868         assert_return(bus, -EINVAL);
1869         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1870         assert_return(!bus_pid_changed(bus), -ECHILD);
1871
1872         if (bus->state == BUS_OPENING)
1873                 flags |= POLLOUT;
1874         else if (bus->state == BUS_AUTHENTICATING) {
1875
1876                 if (bus_socket_auth_needs_write(bus))
1877                         flags |= POLLOUT;
1878
1879                 flags |= POLLIN;
1880
1881         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1882                 if (bus->rqueue_size <= 0)
1883                         flags |= POLLIN;
1884                 if (bus->wqueue_size > 0)
1885                         flags |= POLLOUT;
1886         }
1887
1888         return flags;
1889 }
1890
1891 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1892         struct reply_callback *c;
1893
1894         assert_return(bus, -EINVAL);
1895         assert_return(timeout_usec, -EINVAL);
1896         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1897         assert_return(!bus_pid_changed(bus), -ECHILD);
1898
1899         if (bus->state == BUS_CLOSING) {
1900                 *timeout_usec = 0;
1901                 return 1;
1902         }
1903
1904         if (bus->state == BUS_AUTHENTICATING) {
1905                 *timeout_usec = bus->auth_timeout;
1906                 return 1;
1907         }
1908
1909         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
1910                 *timeout_usec = (uint64_t) -1;
1911                 return 0;
1912         }
1913
1914         if (bus->rqueue_size > 0) {
1915                 *timeout_usec = 0;
1916                 return 1;
1917         }
1918
1919         c = prioq_peek(bus->reply_callbacks_prioq);
1920         if (!c) {
1921                 *timeout_usec = (uint64_t) -1;
1922                 return 0;
1923         }
1924
1925         *timeout_usec = c->timeout;
1926         return 1;
1927 }
1928
1929 static int process_timeout(sd_bus *bus) {
1930         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1931         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
1932         struct reply_callback *c;
1933         usec_t n;
1934         int r;
1935
1936         assert(bus);
1937
1938         c = prioq_peek(bus->reply_callbacks_prioq);
1939         if (!c)
1940                 return 0;
1941
1942         n = now(CLOCK_MONOTONIC);
1943         if (c->timeout > n)
1944                 return 0;
1945
1946         r = bus_message_new_synthetic_error(
1947                         bus,
1948                         c->cookie,
1949                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
1950                         &m);
1951         if (r < 0)
1952                 return r;
1953
1954         m->sender = "org.freedesktop.DBus";
1955
1956         r = bus_seal_synthetic_message(bus, m);
1957         if (r < 0)
1958                 return r;
1959
1960         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
1961         hashmap_remove(bus->reply_callbacks, &c->cookie);
1962
1963         bus->current = m;
1964         bus->iteration_counter ++;
1965
1966         r = c->callback(bus, m, c->userdata, &error_buffer);
1967         r = bus_maybe_reply_error(m, r, &error_buffer);
1968         free(c);
1969
1970         bus->current = NULL;
1971
1972         return r;
1973 }
1974
1975 static int process_hello(sd_bus *bus, sd_bus_message *m) {
1976         assert(bus);
1977         assert(m);
1978
1979         if (bus->state != BUS_HELLO)
1980                 return 0;
1981
1982         /* Let's make sure the first message on the bus is the HELLO
1983          * reply. But note that we don't actually parse the message
1984          * here (we leave that to the usual handling), we just verify
1985          * we don't let any earlier msg through. */
1986
1987         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
1988             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
1989                 return -EIO;
1990
1991         if (m->reply_cookie != bus->hello_cookie)
1992                 return -EIO;
1993
1994         return 0;
1995 }
1996
1997 static int process_reply(sd_bus *bus, sd_bus_message *m) {
1998         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
1999         struct reply_callback *c;
2000         int r;
2001
2002         assert(bus);
2003         assert(m);
2004
2005         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2006             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2007                 return 0;
2008
2009         c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2010         if (!c)
2011                 return 0;
2012
2013         if (c->timeout != 0)
2014                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2015
2016         r = sd_bus_message_rewind(m, true);
2017         if (r < 0)
2018                 return r;
2019
2020         r = c->callback(bus, m, c->userdata, &error_buffer);
2021         r = bus_maybe_reply_error(m, r, &error_buffer);
2022         free(c);
2023
2024         return r;
2025 }
2026
2027 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2028         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2029         struct filter_callback *l;
2030         int r;
2031
2032         assert(bus);
2033         assert(m);
2034
2035         do {
2036                 bus->filter_callbacks_modified = false;
2037
2038                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2039
2040                         if (bus->filter_callbacks_modified)
2041                                 break;
2042
2043                         /* Don't run this more than once per iteration */
2044                         if (l->last_iteration == bus->iteration_counter)
2045                                 continue;
2046
2047                         l->last_iteration = bus->iteration_counter;
2048
2049                         r = sd_bus_message_rewind(m, true);
2050                         if (r < 0)
2051                                 return r;
2052
2053                         r = l->callback(bus, m, l->userdata, &error_buffer);
2054                         r = bus_maybe_reply_error(m, r, &error_buffer);
2055                         if (r != 0)
2056                                 return r;
2057
2058                 }
2059
2060         } while (bus->filter_callbacks_modified);
2061
2062         return 0;
2063 }
2064
2065 static int process_match(sd_bus *bus, sd_bus_message *m) {
2066         int r;
2067
2068         assert(bus);
2069         assert(m);
2070
2071         do {
2072                 bus->match_callbacks_modified = false;
2073
2074                 r = bus_match_run(bus, &bus->match_callbacks, m);
2075                 if (r != 0)
2076                         return r;
2077
2078         } while (bus->match_callbacks_modified);
2079
2080         return 0;
2081 }
2082
2083 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2084         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2085         int r;
2086
2087         assert(bus);
2088         assert(m);
2089
2090         if (bus->manual_peer_interface)
2091                 return 0;
2092
2093         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2094                 return 0;
2095
2096         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2097                 return 0;
2098
2099         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2100                 return 1;
2101
2102         if (streq_ptr(m->member, "Ping"))
2103                 r = sd_bus_message_new_method_return(m, &reply);
2104         else if (streq_ptr(m->member, "GetMachineId")) {
2105                 sd_id128_t id;
2106                 char sid[33];
2107
2108                 r = sd_id128_get_machine(&id);
2109                 if (r < 0)
2110                         return r;
2111
2112                 r = sd_bus_message_new_method_return(m, &reply);
2113                 if (r < 0)
2114                         return r;
2115
2116                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2117         } else {
2118                 r = sd_bus_message_new_method_errorf(
2119                                 m, &reply,
2120                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2121                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2122         }
2123
2124         if (r < 0)
2125                 return r;
2126
2127         r = sd_bus_send(bus, reply, NULL);
2128         if (r < 0)
2129                 return r;
2130
2131         return 1;
2132 }
2133
2134 static int process_message(sd_bus *bus, sd_bus_message *m) {
2135         int r;
2136
2137         assert(bus);
2138         assert(m);
2139
2140         bus->current = m;
2141         bus->iteration_counter++;
2142
2143         log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2144                   bus_message_type_to_string(m->header->type),
2145                   strna(sd_bus_message_get_sender(m)),
2146                   strna(sd_bus_message_get_destination(m)),
2147                   strna(sd_bus_message_get_path(m)),
2148                   strna(sd_bus_message_get_interface(m)),
2149                   strna(sd_bus_message_get_member(m)),
2150                   (unsigned long) BUS_MESSAGE_COOKIE(m),
2151                   (unsigned long) m->reply_cookie,
2152                   strna(m->error.message));
2153
2154         r = process_hello(bus, m);
2155         if (r != 0)
2156                 goto finish;
2157
2158         r = process_reply(bus, m);
2159         if (r != 0)
2160                 goto finish;
2161
2162         r = process_filter(bus, m);
2163         if (r != 0)
2164                 goto finish;
2165
2166         r = process_match(bus, m);
2167         if (r != 0)
2168                 goto finish;
2169
2170         r = process_builtin(bus, m);
2171         if (r != 0)
2172                 goto finish;
2173
2174         r = bus_process_object(bus, m);
2175
2176 finish:
2177         bus->current = NULL;
2178         return r;
2179 }
2180
2181 static int process_running(sd_bus *bus, sd_bus_message **ret) {
2182         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2183         int r;
2184
2185         assert(bus);
2186         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2187
2188         r = process_timeout(bus);
2189         if (r != 0)
2190                 goto null_message;
2191
2192         r = dispatch_wqueue(bus);
2193         if (r != 0)
2194                 goto null_message;
2195
2196         r = dispatch_rqueue(bus, &m);
2197         if (r < 0)
2198                 return r;
2199         if (!m)
2200                 goto null_message;
2201
2202         r = process_message(bus, m);
2203         if (r != 0)
2204                 goto null_message;
2205
2206         if (ret) {
2207                 r = sd_bus_message_rewind(m, true);
2208                 if (r < 0)
2209                         return r;
2210
2211                 *ret = m;
2212                 m = NULL;
2213                 return 1;
2214         }
2215
2216         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2217
2218                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2219                           strna(sd_bus_message_get_sender(m)),
2220                           strna(sd_bus_message_get_path(m)),
2221                           strna(sd_bus_message_get_interface(m)),
2222                           strna(sd_bus_message_get_member(m)));
2223
2224                 r = sd_bus_reply_method_errorf(
2225                                 m,
2226                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2227                                 "Unknown object '%s'.", m->path);
2228                 if (r < 0)
2229                         return r;
2230         }
2231
2232         return 1;
2233
2234 null_message:
2235         if (r >= 0 && ret)
2236                 *ret = NULL;
2237
2238         return r;
2239 }
2240
2241 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2242         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2243         struct reply_callback *c;
2244         int r;
2245
2246         assert(bus);
2247         assert(bus->state == BUS_CLOSING);
2248
2249         c = hashmap_first(bus->reply_callbacks);
2250         if (c) {
2251                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2252
2253                 /* First, fail all outstanding method calls */
2254                 r = bus_message_new_synthetic_error(
2255                                 bus,
2256                                 c->cookie,
2257                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2258                                 &m);
2259                 if (r < 0)
2260                         return r;
2261
2262                 r = bus_seal_synthetic_message(bus, m);
2263                 if (r < 0)
2264                         return r;
2265
2266                 if (c->timeout != 0)
2267                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2268
2269                 hashmap_remove(bus->reply_callbacks, &c->cookie);
2270
2271                 bus->current = m;
2272                 bus->iteration_counter++;
2273
2274                 r = c->callback(bus, m, c->userdata, &error_buffer);
2275                 r = bus_maybe_reply_error(m, r, &error_buffer);
2276                 free(c);
2277
2278                 goto finish;
2279         }
2280
2281         /* Then, synthesize a Disconnected message */
2282         r = sd_bus_message_new_signal(
2283                         bus,
2284                         "/org/freedesktop/DBus/Local",
2285                         "org.freedesktop.DBus.Local",
2286                         "Disconnected",
2287                         &m);
2288         if (r < 0)
2289                 return r;
2290
2291         m->sender = "org.freedesktop.DBus.Local";
2292
2293         r = bus_seal_synthetic_message(bus, m);
2294         if (r < 0)
2295                 return r;
2296
2297         sd_bus_close(bus);
2298
2299         bus->current = m;
2300         bus->iteration_counter++;
2301
2302         r = process_filter(bus, m);
2303         if (r != 0)
2304                 goto finish;
2305
2306         r = process_match(bus, m);
2307         if (r != 0)
2308                 goto finish;
2309
2310         if (ret) {
2311                 *ret = m;
2312                 m = NULL;
2313         }
2314
2315         r = 1;
2316
2317 finish:
2318         bus->current = NULL;
2319         return r;
2320 }
2321
2322 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2323         BUS_DONT_DESTROY(bus);
2324         int r;
2325
2326         /* Returns 0 when we didn't do anything. This should cause the
2327          * caller to invoke sd_bus_wait() before returning the next
2328          * time. Returns > 0 when we did something, which possibly
2329          * means *ret is filled in with an unprocessed message. */
2330
2331         assert_return(bus, -EINVAL);
2332         assert_return(!bus_pid_changed(bus), -ECHILD);
2333
2334         /* We don't allow recursively invoking sd_bus_process(). */
2335         assert_return(!bus->current, -EBUSY);
2336
2337         switch (bus->state) {
2338
2339         case BUS_UNSET:
2340                 return -ENOTCONN;
2341
2342         case BUS_CLOSED:
2343                 return -ECONNRESET;
2344
2345         case BUS_OPENING:
2346                 r = bus_socket_process_opening(bus);
2347                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2348                         bus_enter_closing(bus);
2349                         r = 1;
2350                 } else if (r < 0)
2351                         return r;
2352                 if (ret)
2353                         *ret = NULL;
2354                 return r;
2355
2356         case BUS_AUTHENTICATING:
2357                 r = bus_socket_process_authenticating(bus);
2358                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2359                         bus_enter_closing(bus);
2360                         r = 1;
2361                 } else if (r < 0)
2362                         return r;
2363
2364                 if (ret)
2365                         *ret = NULL;
2366
2367                 return r;
2368
2369         case BUS_RUNNING:
2370         case BUS_HELLO:
2371                 r = process_running(bus, ret);
2372                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2373                         bus_enter_closing(bus);
2374                         r = 1;
2375
2376                         if (ret)
2377                                 *ret = NULL;
2378                 }
2379
2380                 return r;
2381
2382         case BUS_CLOSING:
2383                 return process_closing(bus, ret);
2384         }
2385
2386         assert_not_reached("Unknown state");
2387 }
2388
2389 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2390         struct pollfd p[2] = {};
2391         int r, e, n;
2392         struct timespec ts;
2393         usec_t m = (usec_t) -1;
2394
2395         assert(bus);
2396
2397         if (bus->state == BUS_CLOSING)
2398                 return 1;
2399
2400         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2401
2402         e = sd_bus_get_events(bus);
2403         if (e < 0)
2404                 return e;
2405
2406         if (need_more)
2407                 /* The caller really needs some more data, he doesn't
2408                  * care about what's already read, or any timeouts
2409                  * except its own.*/
2410                 e |= POLLIN;
2411         else {
2412                 usec_t until;
2413                 /* The caller wants to process if there's something to
2414                  * process, but doesn't care otherwise */
2415
2416                 r = sd_bus_get_timeout(bus, &until);
2417                 if (r < 0)
2418                         return r;
2419                 if (r > 0) {
2420                         usec_t nw;
2421                         nw = now(CLOCK_MONOTONIC);
2422                         m = until > nw ? until - nw : 0;
2423                 }
2424         }
2425
2426         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2427                 m = timeout_usec;
2428
2429         p[0].fd = bus->input_fd;
2430         if (bus->output_fd == bus->input_fd) {
2431                 p[0].events = e;
2432                 n = 1;
2433         } else {
2434                 p[0].events = e & POLLIN;
2435                 p[1].fd = bus->output_fd;
2436                 p[1].events = e & POLLOUT;
2437                 n = 2;
2438         }
2439
2440         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2441         if (r < 0)
2442                 return -errno;
2443
2444         return r > 0 ? 1 : 0;
2445 }
2446
2447 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2448
2449         assert_return(bus, -EINVAL);
2450         assert_return(!bus_pid_changed(bus), -ECHILD);
2451
2452         if (bus->state == BUS_CLOSING)
2453                 return 0;
2454
2455         assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2456
2457         if (bus->rqueue_size > 0)
2458                 return 0;
2459
2460         return bus_poll(bus, false, timeout_usec);
2461 }
2462
2463 _public_ int sd_bus_flush(sd_bus *bus) {
2464         int r;
2465
2466         assert_return(bus, -EINVAL);
2467         assert_return(!bus_pid_changed(bus), -ECHILD);
2468
2469         if (bus->state == BUS_CLOSING)
2470                 return 0;
2471
2472         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2473
2474         r = bus_ensure_running(bus);
2475         if (r < 0)
2476                 return r;
2477
2478         if (bus->wqueue_size <= 0)
2479                 return 0;
2480
2481         for (;;) {
2482                 r = dispatch_wqueue(bus);
2483                 if (r < 0) {
2484                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2485                                 bus_enter_closing(bus);
2486                                 return -ECONNRESET;
2487                         }
2488
2489                         return r;
2490                 }
2491
2492                 if (bus->wqueue_size <= 0)
2493                         return 0;
2494
2495                 r = bus_poll(bus, false, (uint64_t) -1);
2496                 if (r < 0)
2497                         return r;
2498         }
2499 }
2500
2501 _public_ int sd_bus_add_filter(sd_bus *bus,
2502                                sd_bus_message_handler_t callback,
2503                                void *userdata) {
2504
2505         struct filter_callback *f;
2506
2507         assert_return(bus, -EINVAL);
2508         assert_return(callback, -EINVAL);
2509         assert_return(!bus_pid_changed(bus), -ECHILD);
2510
2511         f = new0(struct filter_callback, 1);
2512         if (!f)
2513                 return -ENOMEM;
2514         f->callback = callback;
2515         f->userdata = userdata;
2516
2517         bus->filter_callbacks_modified = true;
2518         LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2519         return 0;
2520 }
2521
2522 _public_ int sd_bus_remove_filter(sd_bus *bus,
2523                                   sd_bus_message_handler_t callback,
2524                                   void *userdata) {
2525
2526         struct filter_callback *f;
2527
2528         assert_return(bus, -EINVAL);
2529         assert_return(callback, -EINVAL);
2530         assert_return(!bus_pid_changed(bus), -ECHILD);
2531
2532         LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2533                 if (f->callback == callback && f->userdata == userdata) {
2534                         bus->filter_callbacks_modified = true;
2535                         LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2536                         free(f);
2537                         return 1;
2538                 }
2539         }
2540
2541         return 0;
2542 }
2543
2544 _public_ int sd_bus_add_match(sd_bus *bus,
2545                               const char *match,
2546                               sd_bus_message_handler_t callback,
2547                               void *userdata) {
2548
2549         struct bus_match_component *components = NULL;
2550         unsigned n_components = 0;
2551         uint64_t cookie = 0;
2552         int r = 0;
2553
2554         assert_return(bus, -EINVAL);
2555         assert_return(match, -EINVAL);
2556         assert_return(!bus_pid_changed(bus), -ECHILD);
2557
2558         r = bus_match_parse(match, &components, &n_components);
2559         if (r < 0)
2560                 goto finish;
2561
2562         if (bus->bus_client) {
2563                 cookie = ++bus->match_cookie;
2564
2565                 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2566                 if (r < 0)
2567                         goto finish;
2568         }
2569
2570         bus->match_callbacks_modified = true;
2571         r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2572         if (r < 0) {
2573                 if (bus->bus_client)
2574                         bus_remove_match_internal(bus, match, cookie);
2575         }
2576
2577 finish:
2578         bus_match_parse_free(components, n_components);
2579         return r;
2580 }
2581
2582 _public_ int sd_bus_remove_match(sd_bus *bus,
2583                                  const char *match,
2584                                  sd_bus_message_handler_t callback,
2585                                  void *userdata) {
2586
2587         struct bus_match_component *components = NULL;
2588         unsigned n_components = 0;
2589         int r = 0, q = 0;
2590         uint64_t cookie = 0;
2591
2592         assert_return(bus, -EINVAL);
2593         assert_return(match, -EINVAL);
2594         assert_return(!bus_pid_changed(bus), -ECHILD);
2595
2596         r = bus_match_parse(match, &components, &n_components);
2597         if (r < 0)
2598                 return r;
2599
2600         bus->match_callbacks_modified = true;
2601         r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2602
2603         if (bus->bus_client)
2604                 q = bus_remove_match_internal(bus, match, cookie);
2605
2606         bus_match_parse_free(components, n_components);
2607
2608         return r < 0 ? r : q;
2609 }
2610
2611 bool bus_pid_changed(sd_bus *bus) {
2612         assert(bus);
2613
2614         /* We don't support people creating a bus connection and
2615          * keeping it around over a fork(). Let's complain. */
2616
2617         return bus->original_pid != getpid();
2618 }
2619
2620 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2621         sd_bus *bus = userdata;
2622         int r;
2623
2624         assert(bus);
2625
2626         r = sd_bus_process(bus, NULL);
2627         if (r < 0)
2628                 return r;
2629
2630         return 1;
2631 }
2632
2633 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2634         sd_bus *bus = userdata;
2635         int r;
2636
2637         assert(bus);
2638
2639         r = sd_bus_process(bus, NULL);
2640         if (r < 0)
2641                 return r;
2642
2643         return 1;
2644 }
2645
2646 static int prepare_callback(sd_event_source *s, void *userdata) {
2647         sd_bus *bus = userdata;
2648         int r, e;
2649         usec_t until;
2650
2651         assert(s);
2652         assert(bus);
2653
2654         e = sd_bus_get_events(bus);
2655         if (e < 0)
2656                 return e;
2657
2658         if (bus->output_fd != bus->input_fd) {
2659
2660                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2661                 if (r < 0)
2662                         return r;
2663
2664                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2665                 if (r < 0)
2666                         return r;
2667         } else {
2668                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2669                 if (r < 0)
2670                         return r;
2671         }
2672
2673         r = sd_bus_get_timeout(bus, &until);
2674         if (r < 0)
2675                 return r;
2676         if (r > 0) {
2677                 int j;
2678
2679                 j = sd_event_source_set_time(bus->time_event_source, until);
2680                 if (j < 0)
2681                         return j;
2682         }
2683
2684         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2685         if (r < 0)
2686                 return r;
2687
2688         return 1;
2689 }
2690
2691 static int quit_callback(sd_event_source *event, void *userdata) {
2692         sd_bus *bus = userdata;
2693
2694         assert(event);
2695
2696         sd_bus_flush(bus);
2697
2698         return 1;
2699 }
2700
2701 static int attach_io_events(sd_bus *bus) {
2702         int r;
2703
2704         assert(bus);
2705
2706         if (bus->input_fd < 0)
2707                 return 0;
2708
2709         if (!bus->event)
2710                 return 0;
2711
2712         if (!bus->input_io_event_source) {
2713                 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2714                 if (r < 0)
2715                         return r;
2716
2717                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2718                 if (r < 0)
2719                         return r;
2720
2721                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2722         } else
2723                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2724
2725         if (r < 0)
2726                 return r;
2727
2728         if (bus->output_fd != bus->input_fd) {
2729                 assert(bus->output_fd >= 0);
2730
2731                 if (!bus->output_io_event_source) {
2732                         r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2733                         if (r < 0)
2734                                 return r;
2735
2736                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2737                 } else
2738                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2739
2740                 if (r < 0)
2741                         return r;
2742         }
2743
2744         return 0;
2745 }
2746
2747 static void detach_io_events(sd_bus *bus) {
2748         assert(bus);
2749
2750         if (bus->input_io_event_source) {
2751                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2752                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2753         }
2754
2755         if (bus->output_io_event_source) {
2756                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2757                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2758         }
2759 }
2760
2761 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2762         int r;
2763
2764         assert_return(bus, -EINVAL);
2765         assert_return(!bus->event, -EBUSY);
2766
2767         assert(!bus->input_io_event_source);
2768         assert(!bus->output_io_event_source);
2769         assert(!bus->time_event_source);
2770
2771         if (event)
2772                 bus->event = sd_event_ref(event);
2773         else  {
2774                 r = sd_event_default(&bus->event);
2775                 if (r < 0)
2776                         return r;
2777         }
2778
2779         bus->event_priority = priority;
2780
2781         r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2782         if (r < 0)
2783                 goto fail;
2784
2785         r = sd_event_source_set_priority(bus->time_event_source, priority);
2786         if (r < 0)
2787                 goto fail;
2788
2789         r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
2790         if (r < 0)
2791                 goto fail;
2792
2793         r = attach_io_events(bus);
2794         if (r < 0)
2795                 goto fail;
2796
2797         return 0;
2798
2799 fail:
2800         sd_bus_detach_event(bus);
2801         return r;
2802 }
2803
2804 _public_ int sd_bus_detach_event(sd_bus *bus) {
2805         assert_return(bus, -EINVAL);
2806
2807         if (!bus->event)
2808                 return 0;
2809
2810         detach_io_events(bus);
2811
2812         if (bus->time_event_source) {
2813                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2814                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2815         }
2816
2817         if (bus->quit_event_source) {
2818                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2819                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2820         }
2821
2822         if (bus->event)
2823                 bus->event = sd_event_unref(bus->event);
2824
2825         return 1;
2826 }
2827
2828 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2829         assert_return(bus, NULL);
2830
2831         return bus->event;
2832 }
2833
2834 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2835         assert_return(bus, NULL);
2836
2837         return bus->current;
2838 }
2839
2840 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2841         sd_bus *b = NULL;
2842         int r;
2843
2844         assert(bus_open);
2845         assert(default_bus);
2846
2847         if (!ret)
2848                 return !!*default_bus;
2849
2850         if (*default_bus) {
2851                 *ret = sd_bus_ref(*default_bus);
2852                 return 0;
2853         }
2854
2855         r = bus_open(&b);
2856         if (r < 0)
2857                 return r;
2858
2859         b->default_bus_ptr = default_bus;
2860         b->tid = gettid();
2861         *default_bus = b;
2862
2863         *ret = b;
2864         return 1;
2865 }
2866
2867 _public_ int sd_bus_default_system(sd_bus **ret) {
2868         static thread_local sd_bus *default_system_bus = NULL;
2869
2870         return bus_default(sd_bus_open_system, &default_system_bus, ret);
2871 }
2872
2873 _public_ int sd_bus_default_user(sd_bus **ret) {
2874         static thread_local sd_bus *default_user_bus = NULL;
2875
2876         return bus_default(sd_bus_open_user, &default_user_bus, ret);
2877 }
2878
2879 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
2880         assert_return(b, -EINVAL);
2881         assert_return(tid, -EINVAL);
2882         assert_return(!bus_pid_changed(b), -ECHILD);
2883
2884         if (b->tid != 0) {
2885                 *tid = b->tid;
2886                 return 0;
2887         }
2888
2889         if (b->event)
2890                 return sd_event_get_tid(b->event, tid);
2891
2892         return -ENXIO;
2893 }
2894
2895 _public_ char *sd_bus_label_escape(const char *s) {
2896         char *r, *t;
2897         const char *f;
2898
2899         assert_return(s, NULL);
2900
2901         /* Escapes all chars that D-Bus' object path cannot deal
2902          * with. Can be reversed with bus_path_unescape(). We special
2903          * case the empty string. */
2904
2905         if (*s == 0)
2906                 return strdup("_");
2907
2908         r = new(char, strlen(s)*3 + 1);
2909         if (!r)
2910                 return NULL;
2911
2912         for (f = s, t = r; *f; f++) {
2913
2914                 /* Escape everything that is not a-zA-Z0-9. We also
2915                  * escape 0-9 if it's the first character */
2916
2917                 if (!(*f >= 'A' && *f <= 'Z') &&
2918                     !(*f >= 'a' && *f <= 'z') &&
2919                     !(f > s && *f >= '0' && *f <= '9')) {
2920                         *(t++) = '_';
2921                         *(t++) = hexchar(*f >> 4);
2922                         *(t++) = hexchar(*f);
2923                 } else
2924                         *(t++) = *f;
2925         }
2926
2927         *t = 0;
2928
2929         return r;
2930 }
2931
2932 _public_ char *sd_bus_label_unescape(const char *f) {
2933         char *r, *t;
2934
2935         assert_return(f, NULL);
2936
2937         /* Special case for the empty string */
2938         if (streq(f, "_"))
2939                 return strdup("");
2940
2941         r = new(char, strlen(f) + 1);
2942         if (!r)
2943                 return NULL;
2944
2945         for (t = r; *f; f++) {
2946
2947                 if (*f == '_') {
2948                         int a, b;
2949
2950                         if ((a = unhexchar(f[1])) < 0 ||
2951                             (b = unhexchar(f[2])) < 0) {
2952                                 /* Invalid escape code, let's take it literal then */
2953                                 *(t++) = '_';
2954                         } else {
2955                                 *(t++) = (char) ((a << 4) | b);
2956                                 f += 2;
2957                         }
2958                 } else
2959                         *(t++) = *f;
2960         }
2961
2962         *t = 0;
2963
2964         return r;
2965 }
2966
2967 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
2968         sd_bus_creds *c;
2969         pid_t pid = 0;
2970         int r;
2971
2972         assert_return(bus, -EINVAL);
2973         assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
2974         assert_return(ret, -EINVAL);
2975         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2976         assert_return(!bus_pid_changed(bus), -ECHILD);
2977         assert_return(!bus->is_kernel, -ENOTSUP);
2978
2979         if (!bus->ucred_valid && !isempty(bus->label))
2980                 return -ENODATA;
2981
2982         c = bus_creds_new();
2983         if (!c)
2984                 return -ENOMEM;
2985
2986         if (bus->ucred_valid) {
2987                 pid = c->pid = bus->ucred.pid;
2988                 c->uid = bus->ucred.uid;
2989                 c->gid = bus->ucred.gid;
2990
2991                 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
2992         }
2993
2994         if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
2995                 c->label = strdup(bus->label);
2996                 if (!c->label) {
2997                         sd_bus_creds_unref(c);
2998                         return -ENOMEM;
2999                 }
3000
3001                 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3002         }
3003
3004         r = bus_creds_add_more(c, mask, pid, 0);
3005         if (r < 0)
3006                 return r;
3007
3008         *ret = c;
3009         return 0;
3010 }
3011
3012 _public_ int sd_bus_try_close(sd_bus *bus) {
3013         int r;
3014
3015         assert_return(bus, -EINVAL);
3016         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3017         assert_return(!bus_pid_changed(bus), -ECHILD);
3018         assert_return(bus->is_kernel, -ENOTSUP);
3019
3020         if (bus->rqueue_size > 0)
3021                 return -EBUSY;
3022
3023         if (bus->wqueue_size > 0)
3024                 return -EBUSY;
3025
3026         r = bus_kernel_try_close(bus);
3027         if (r < 0)
3028                 return r;
3029
3030         sd_bus_close(bus);
3031         return 0;
3032 }