src/libsystemd/sd-bus/sd-bus.c

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