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                         "org.freedesktop.DBus",
 403                         "/org/freedesktop/DBus",
 404                         "org.freedesktop.DBus",
 405                         "Hello",
 406                         &m);
 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(const char *host, sd_bus **ret) {
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(const char *machine, sd_bus **ret) {
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                 bus_reset_queues(bus);
1369         }
1370
1371         i = REFCNT_DEC(bus->n_ref);
1372         if (i > 0)
1373                 return NULL;
1374
1375         bus_free(bus);
1376         return NULL;
1377 }
1378
1379 _public_ int sd_bus_is_open(sd_bus *bus) {
1380
1381         assert_return(bus, -EINVAL);
1382         assert_return(!bus_pid_changed(bus), -ECHILD);
1383
1384         return BUS_IS_OPEN(bus->state);
1385 }
1386
1387 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1388         int r;
1389
1390         assert_return(bus, -EINVAL);
1391         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1392         assert_return(!bus_pid_changed(bus), -ECHILD);
1393
1394         if (type == SD_BUS_TYPE_UNIX_FD) {
1395                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1396                         return 0;
1397
1398                 r = bus_ensure_running(bus);
1399                 if (r < 0)
1400                         return r;
1401
1402                 return bus->can_fds;
1403         }
1404
1405         return bus_type_is_valid(type);
1406 }
1407
1408 _public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
1409         int r;
1410
1411         assert_return(bus, -EINVAL);
1412         assert_return(server_id, -EINVAL);
1413         assert_return(!bus_pid_changed(bus), -ECHILD);
1414
1415         r = bus_ensure_running(bus);
1416         if (r < 0)
1417                 return r;
1418
1419         *server_id = bus->server_id;
1420         return 0;
1421 }
1422
1423 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1424         assert(b);
1425         assert(m);
1426
1427         if (m->sealed) {
1428                 /* If we copy the same message to multiple
1429                  * destinations, avoid using the same cookie
1430                  * numbers. */
1431                 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1432                 return 0;
1433         }
1434
1435         if (timeout == 0)
1436                 timeout = BUS_DEFAULT_TIMEOUT;
1437
1438         return bus_message_seal(m, ++b->cookie, timeout);
1439 }
1440
1441 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1442         assert(b);
1443
1444         /* Do packet version and endianess already match? */
1445         if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
1446             (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
1447                 return 0;
1448
1449         /* No? Then remarshal! */
1450         return bus_message_remarshal(b, m);
1451 }
1452
1453 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1454         assert(b);
1455         assert(m);
1456
1457         /* The bus specification says the serial number cannot be 0,
1458          * hence let's fill something in for synthetic messages. Since
1459          * synthetic messages might have a fake sender and we don't
1460          * want to interfere with the real sender's serial numbers we
1461          * pick a fixed, artifical one. We use (uint32_t) -1 rather
1462          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1463          * even though kdbus can do 64bit. */
1464
1465         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1466 }
1467
1468 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1469         int r;
1470
1471         assert(bus);
1472         assert(m);
1473
1474         if (bus->is_kernel)
1475                 r = bus_kernel_write_message(bus, m, hint_sync_call);
1476         else
1477                 r = bus_socket_write_message(bus, m, idx);
1478
1479         if (r <= 0)
1480                 return r;
1481
1482         if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1483                 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
1484                           bus_message_type_to_string(m->header->type),
1485                           strna(sd_bus_message_get_sender(m)),
1486                           strna(sd_bus_message_get_destination(m)),
1487                           strna(sd_bus_message_get_path(m)),
1488                           strna(sd_bus_message_get_interface(m)),
1489                           strna(sd_bus_message_get_member(m)),
1490                           (unsigned long) BUS_MESSAGE_COOKIE(m),
1491                           (unsigned long) m->reply_cookie,
1492                           strna(m->error.message));
1493
1494         return r;
1495 }
1496
1497 static int dispatch_wqueue(sd_bus *bus) {
1498         int r, ret = 0;
1499
1500         assert(bus);
1501         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1502
1503         while (bus->wqueue_size > 0) {
1504
1505                 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1506                 if (r < 0)
1507                         return r;
1508                 else if (r == 0)
1509                         /* Didn't do anything this time */
1510                         return ret;
1511                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1512                         /* Fully written. Let's drop the entry from
1513                          * the queue.
1514                          *
1515                          * This isn't particularly optimized, but
1516                          * well, this is supposed to be our worst-case
1517                          * buffer only, and the socket buffer is
1518                          * supposed to be our primary buffer, and if
1519                          * it got full, then all bets are off
1520                          * anyway. */
1521
1522                         bus->wqueue_size --;
1523                         sd_bus_message_unref(bus->wqueue[0]);
1524                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1525                         bus->windex = 0;
1526
1527                         ret = 1;
1528                 }
1529         }
1530
1531         return ret;
1532 }
1533
1534 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1535         assert(bus);
1536
1537         if (bus->is_kernel)
1538                 return bus_kernel_read_message(bus, hint_priority, priority);
1539         else
1540                 return bus_socket_read_message(bus);
1541 }
1542
1543 int bus_rqueue_make_room(sd_bus *bus) {
1544         assert(bus);
1545
1546         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1547                 return -ENOBUFS;
1548
1549         if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1550                 return -ENOMEM;
1551
1552         return 0;
1553 }
1554
1555 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1556         int r, ret = 0;
1557
1558         assert(bus);
1559         assert(m);
1560         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1561
1562         /* Note that the priority logic is only available on kdbus,
1563          * where the rqueue is unused. We check the rqueue here
1564          * anyway, because it's simple... */
1565
1566         for (;;) {
1567                 if (bus->rqueue_size > 0) {
1568                         /* Dispatch a queued message */
1569
1570                         *m = bus->rqueue[0];
1571                         bus->rqueue_size --;
1572                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1573                         return 1;
1574                 }
1575
1576                 /* Try to read a new message */
1577                 r = bus_read_message(bus, hint_priority, priority);
1578                 if (r < 0)
1579                         return r;
1580                 if (r == 0)
1581                         return ret;
1582
1583                 ret = 1;
1584         }
1585 }
1586
1587 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1588         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1589         int r;
1590
1591         assert_return(bus, -EINVAL);
1592         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1593         assert_return(m, -EINVAL);
1594         assert_return(!bus_pid_changed(bus), -ECHILD);
1595
1596         if (m->n_fds > 0) {
1597                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1598                 if (r < 0)
1599                         return r;
1600                 if (r == 0)
1601                         return -ENOTSUP;
1602         }
1603
1604         /* If the cookie number isn't kept, then we know that no reply
1605          * is expected */
1606         if (!cookie && !m->sealed)
1607                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1608
1609         r = bus_seal_message(bus, m, 0);
1610         if (r < 0)
1611                 return r;
1612
1613         /* Remarshall if we have to. This will possibly unref the
1614          * message and place a replacement in m */
1615         r = bus_remarshal_message(bus, &m);
1616         if (r < 0)
1617                 return r;
1618
1619         /* If this is a reply and no reply was requested, then let's
1620          * suppress this, if we can */
1621         if (m->dont_send && !cookie)
1622                 return 1;
1623
1624         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1625                 size_t idx = 0;
1626
1627                 r = bus_write_message(bus, m, hint_sync_call, &idx);
1628                 if (r < 0) {
1629                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1630                                 bus_enter_closing(bus);
1631                                 return -ECONNRESET;
1632                         }
1633
1634                         return r;
1635                 } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1636                         /* Wasn't fully written. So let's remember how
1637                          * much was written. Note that the first entry
1638                          * of the wqueue array is always allocated so
1639                          * that we always can remember how much was
1640                          * written. */
1641                         bus->wqueue[0] = sd_bus_message_ref(m);
1642                         bus->wqueue_size = 1;
1643                         bus->windex = idx;
1644                 }
1645         } else {
1646                 /* Just append it to the queue. */
1647
1648                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1649                         return -ENOBUFS;
1650
1651                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1652                         return -ENOMEM;
1653
1654                 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1655         }
1656
1657         if (cookie)
1658                 *cookie = BUS_MESSAGE_COOKIE(m);
1659
1660         return 1;
1661 }
1662
1663 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1664         return bus_send_internal(bus, m, cookie, false);
1665 }
1666
1667 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1668         int r;
1669
1670         assert_return(bus, -EINVAL);
1671         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1672         assert_return(m, -EINVAL);
1673         assert_return(!bus_pid_changed(bus), -ECHILD);
1674
1675         if (!streq_ptr(m->destination, destination)) {
1676
1677                 if (!destination)
1678                         return -EEXIST;
1679
1680                 r = sd_bus_message_set_destination(m, destination);
1681                 if (r < 0)
1682                         return r;
1683         }
1684
1685         return sd_bus_send(bus, m, cookie);
1686 }
1687
1688 static usec_t calc_elapse(uint64_t usec) {
1689         if (usec == (uint64_t) -1)
1690                 return 0;
1691
1692         return now(CLOCK_MONOTONIC) + usec;
1693 }
1694
1695 static int timeout_compare(const void *a, const void *b) {
1696         const struct reply_callback *x = a, *y = b;
1697
1698         if (x->timeout != 0 && y->timeout == 0)
1699                 return -1;
1700
1701         if (x->timeout == 0 && y->timeout != 0)
1702                 return 1;
1703
1704         if (x->timeout < y->timeout)
1705                 return -1;
1706
1707         if (x->timeout > y->timeout)
1708                 return 1;
1709
1710         return 0;
1711 }
1712
1713 _public_ int sd_bus_call_async(
1714                 sd_bus *bus,
1715                 sd_bus_message *_m,
1716                 sd_bus_message_handler_t callback,
1717                 void *userdata,
1718                 uint64_t usec,
1719                 uint64_t *cookie) {
1720
1721         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1722         struct reply_callback *c;
1723         int r;
1724
1725         assert_return(bus, -EINVAL);
1726         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1727         assert_return(m, -EINVAL);
1728         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1729         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1730         assert_return(callback, -EINVAL);
1731         assert_return(!bus_pid_changed(bus), -ECHILD);
1732
1733         r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func);
1734         if (r < 0)
1735                 return r;
1736
1737         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1738         if (r < 0)
1739                 return r;
1740
1741         r = bus_seal_message(bus, m, usec);
1742         if (r < 0)
1743                 return r;
1744
1745         r = bus_remarshal_message(bus, &m);
1746         if (r < 0)
1747                 return r;
1748
1749         c = new0(struct reply_callback, 1);
1750         if (!c)
1751                 return -ENOMEM;
1752
1753         c->callback = callback;
1754         c->userdata = userdata;
1755         c->cookie = BUS_MESSAGE_COOKIE(m);
1756         c->timeout = calc_elapse(m->timeout);
1757
1758         r = hashmap_put(bus->reply_callbacks, &c->cookie, c);
1759         if (r < 0) {
1760                 free(c);
1761                 return r;
1762         }
1763
1764         if (c->timeout != 0) {
1765                 r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1766                 if (r < 0) {
1767                         c->timeout = 0;
1768                         sd_bus_call_async_cancel(bus, c->cookie);
1769                         return r;
1770                 }
1771         }
1772
1773         r = sd_bus_send(bus, m, cookie);
1774         if (r < 0) {
1775                 sd_bus_call_async_cancel(bus, c->cookie);
1776                 return r;
1777         }
1778
1779         return r;
1780 }
1781
1782 _public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) {
1783         struct reply_callback *c;
1784
1785         assert_return(bus, -EINVAL);
1786         assert_return(cookie != 0, -EINVAL);
1787         assert_return(!bus_pid_changed(bus), -ECHILD);
1788
1789         c = hashmap_remove(bus->reply_callbacks, &cookie);
1790         if (!c)
1791                 return 0;
1792
1793         if (c->timeout != 0)
1794                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
1795
1796         free(c);
1797         return 1;
1798 }
1799
1800 int bus_ensure_running(sd_bus *bus) {
1801         int r;
1802
1803         assert(bus);
1804
1805         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1806                 return -ENOTCONN;
1807         if (bus->state == BUS_RUNNING)
1808                 return 1;
1809
1810         for (;;) {
1811                 r = sd_bus_process(bus, NULL);
1812                 if (r < 0)
1813                         return r;
1814                 if (bus->state == BUS_RUNNING)
1815                         return 1;
1816                 if (r > 0)
1817                         continue;
1818
1819                 r = sd_bus_wait(bus, (uint64_t) -1);
1820                 if (r < 0)
1821                         return r;
1822         }
1823 }
1824
1825 _public_ int sd_bus_call(
1826                 sd_bus *bus,
1827                 sd_bus_message *_m,
1828                 uint64_t usec,
1829                 sd_bus_error *error,
1830                 sd_bus_message **reply) {
1831
1832         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1833         usec_t timeout;
1834         uint64_t cookie;
1835         unsigned i;
1836         int r;
1837
1838         assert_return(bus, -EINVAL);
1839         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
1840         assert_return(m, -EINVAL);
1841         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1842         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1843         assert_return(!bus_error_is_dirty(error), -EINVAL);
1844         assert_return(!bus_pid_changed(bus), -ECHILD);
1845
1846         r = bus_ensure_running(bus);
1847         if (r < 0)
1848                 return r;
1849
1850         i = bus->rqueue_size;
1851
1852         r = bus_seal_message(bus, m, usec);
1853         if (r < 0)
1854                 return r;
1855
1856         r = bus_remarshal_message(bus, &m);
1857         if (r < 0)
1858                 return r;
1859
1860         r = bus_send_internal(bus, m, &cookie, true);
1861         if (r < 0)
1862                 return r;
1863
1864         timeout = calc_elapse(m->timeout);
1865
1866         for (;;) {
1867                 usec_t left;
1868
1869                 while (i < bus->rqueue_size) {
1870                         sd_bus_message *incoming = NULL;
1871
1872                         incoming = bus->rqueue[i];
1873
1874                         if (incoming->reply_cookie == cookie) {
1875                                 /* Found a match! */
1876
1877                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1878                                 bus->rqueue_size--;
1879
1880                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
1881
1882                                         if (reply)
1883                                                 *reply = incoming;
1884                                         else
1885                                                 sd_bus_message_unref(incoming);
1886
1887                                         return 1;
1888                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
1889                                         r = sd_bus_error_copy(error, &incoming->error);
1890                                 else
1891                                         r = -EIO;
1892
1893                                 sd_bus_message_unref(incoming);
1894                                 return r;
1895
1896                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
1897                                    bus->unique_name &&
1898                                    incoming->sender &&
1899                                    streq(bus->unique_name, incoming->sender)) {
1900
1901                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
1902                                 bus->rqueue_size--;
1903
1904                                 /* Our own message? Somebody is trying
1905                                  * to send its own client a message,
1906                                  * let's not dead-lock, let's fail
1907                                  * immediately. */
1908
1909                                 sd_bus_message_unref(incoming);
1910                                 return -ELOOP;
1911                         }
1912
1913                         /* Try to read more, right-away */
1914                         i++;
1915                 }
1916
1917                 r = bus_read_message(bus, false, 0);
1918                 if (r < 0) {
1919                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1920                                 bus_enter_closing(bus);
1921                                 return -ECONNRESET;
1922                         }
1923
1924                         return r;
1925                 }
1926                 if (r > 0)
1927                         continue;
1928
1929                 if (timeout > 0) {
1930                         usec_t n;
1931
1932                         n = now(CLOCK_MONOTONIC);
1933                         if (n >= timeout)
1934                                 return -ETIMEDOUT;
1935
1936                         left = timeout - n;
1937                 } else
1938                         left = (uint64_t) -1;
1939
1940                 r = bus_poll(bus, true, left);
1941                 if (r < 0)
1942                         return r;
1943                 if (r == 0)
1944                         return -ETIMEDOUT;
1945
1946                 r = dispatch_wqueue(bus);
1947                 if (r < 0) {
1948                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1949                                 bus_enter_closing(bus);
1950                                 return -ECONNRESET;
1951                         }
1952
1953                         return r;
1954                 }
1955         }
1956 }
1957
1958 _public_ int sd_bus_get_fd(sd_bus *bus) {
1959
1960         assert_return(bus, -EINVAL);
1961         assert_return(bus->input_fd == bus->output_fd, -EPERM);
1962         assert_return(!bus_pid_changed(bus), -ECHILD);
1963
1964         return bus->input_fd;
1965 }
1966
1967 _public_ int sd_bus_get_events(sd_bus *bus) {
1968         int flags = 0;
1969
1970         assert_return(bus, -EINVAL);
1971         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1972         assert_return(!bus_pid_changed(bus), -ECHILD);
1973
1974         if (bus->state == BUS_OPENING)
1975                 flags |= POLLOUT;
1976         else if (bus->state == BUS_AUTHENTICATING) {
1977
1978                 if (bus_socket_auth_needs_write(bus))
1979                         flags |= POLLOUT;
1980
1981                 flags |= POLLIN;
1982
1983         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
1984                 if (bus->rqueue_size <= 0)
1985                         flags |= POLLIN;
1986                 if (bus->wqueue_size > 0)
1987                         flags |= POLLOUT;
1988         }
1989
1990         return flags;
1991 }
1992
1993 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
1994         struct reply_callback *c;
1995
1996         assert_return(bus, -EINVAL);
1997         assert_return(timeout_usec, -EINVAL);
1998         assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);
1999         assert_return(!bus_pid_changed(bus), -ECHILD);
2000
2001         if (bus->state == BUS_CLOSING) {
2002                 *timeout_usec = 0;
2003                 return 1;
2004         }
2005
2006         if (bus->state == BUS_AUTHENTICATING) {
2007                 *timeout_usec = bus->auth_timeout;
2008                 return 1;
2009         }
2010
2011         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2012                 *timeout_usec = (uint64_t) -1;
2013                 return 0;
2014         }
2015
2016         if (bus->rqueue_size > 0) {
2017                 *timeout_usec = 0;
2018                 return 1;
2019         }
2020
2021         c = prioq_peek(bus->reply_callbacks_prioq);
2022         if (!c) {
2023                 *timeout_usec = (uint64_t) -1;
2024                 return 0;
2025         }
2026
2027         *timeout_usec = c->timeout;
2028         return 1;
2029 }
2030
2031 static int process_timeout(sd_bus *bus) {
2032         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2033         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2034         struct reply_callback *c;
2035         usec_t n;
2036         int r;
2037
2038         assert(bus);
2039
2040         c = prioq_peek(bus->reply_callbacks_prioq);
2041         if (!c)
2042                 return 0;
2043
2044         n = now(CLOCK_MONOTONIC);
2045         if (c->timeout > n)
2046                 return 0;
2047
2048         r = bus_message_new_synthetic_error(
2049                         bus,
2050                         c->cookie,
2051                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2052                         &m);
2053         if (r < 0)
2054                 return r;
2055
2056         m->sender = "org.freedesktop.DBus";
2057
2058         r = bus_seal_synthetic_message(bus, m);
2059         if (r < 0)
2060                 return r;
2061
2062         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2063         hashmap_remove(bus->reply_callbacks, &c->cookie);
2064
2065         bus->current = m;
2066         bus->iteration_counter ++;
2067
2068         r = c->callback(bus, m, c->userdata, &error_buffer);
2069         r = bus_maybe_reply_error(m, r, &error_buffer);
2070         free(c);
2071
2072         bus->current = NULL;
2073
2074         return r;
2075 }
2076
2077 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2078         assert(bus);
2079         assert(m);
2080
2081         if (bus->state != BUS_HELLO)
2082                 return 0;
2083
2084         /* Let's make sure the first message on the bus is the HELLO
2085          * reply. But note that we don't actually parse the message
2086          * here (we leave that to the usual handling), we just verify
2087          * we don't let any earlier msg through. */
2088
2089         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2090             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2091                 return -EIO;
2092
2093         if (m->reply_cookie != bus->hello_cookie)
2094                 return -EIO;
2095
2096         return 0;
2097 }
2098
2099 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2100         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2101         struct reply_callback *c;
2102         int r;
2103
2104         assert(bus);
2105         assert(m);
2106
2107         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2108             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2109                 return 0;
2110
2111         c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2112         if (!c)
2113                 return 0;
2114
2115         if (c->timeout != 0)
2116                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2117
2118         r = sd_bus_message_rewind(m, true);
2119         if (r < 0)
2120                 return r;
2121
2122         r = c->callback(bus, m, c->userdata, &error_buffer);
2123         r = bus_maybe_reply_error(m, r, &error_buffer);
2124         free(c);
2125
2126         return r;
2127 }
2128
2129 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2130         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2131         struct filter_callback *l;
2132         int r;
2133
2134         assert(bus);
2135         assert(m);
2136
2137         do {
2138                 bus->filter_callbacks_modified = false;
2139
2140                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2141
2142                         if (bus->filter_callbacks_modified)
2143                                 break;
2144
2145                         /* Don't run this more than once per iteration */
2146                         if (l->last_iteration == bus->iteration_counter)
2147                                 continue;
2148
2149                         l->last_iteration = bus->iteration_counter;
2150
2151                         r = sd_bus_message_rewind(m, true);
2152                         if (r < 0)
2153                                 return r;
2154
2155                         r = l->callback(bus, m, l->userdata, &error_buffer);
2156                         r = bus_maybe_reply_error(m, r, &error_buffer);
2157                         if (r != 0)
2158                                 return r;
2159
2160                 }
2161
2162         } while (bus->filter_callbacks_modified);
2163
2164         return 0;
2165 }
2166
2167 static int process_match(sd_bus *bus, sd_bus_message *m) {
2168         int r;
2169
2170         assert(bus);
2171         assert(m);
2172
2173         do {
2174                 bus->match_callbacks_modified = false;
2175
2176                 r = bus_match_run(bus, &bus->match_callbacks, m);
2177                 if (r != 0)
2178                         return r;
2179
2180         } while (bus->match_callbacks_modified);
2181
2182         return 0;
2183 }
2184
2185 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2186         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2187         int r;
2188
2189         assert(bus);
2190         assert(m);
2191
2192         if (bus->manual_peer_interface)
2193                 return 0;
2194
2195         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2196                 return 0;
2197
2198         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2199                 return 0;
2200
2201         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2202                 return 1;
2203
2204         if (streq_ptr(m->member, "Ping"))
2205                 r = sd_bus_message_new_method_return(m, &reply);
2206         else if (streq_ptr(m->member, "GetMachineId")) {
2207                 sd_id128_t id;
2208                 char sid[33];
2209
2210                 r = sd_id128_get_machine(&id);
2211                 if (r < 0)
2212                         return r;
2213
2214                 r = sd_bus_message_new_method_return(m, &reply);
2215                 if (r < 0)
2216                         return r;
2217
2218                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2219         } else {
2220                 r = sd_bus_message_new_method_errorf(
2221                                 m, &reply,
2222                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2223                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2224         }
2225
2226         if (r < 0)
2227                 return r;
2228
2229         r = sd_bus_send(bus, reply, NULL);
2230         if (r < 0)
2231                 return r;
2232
2233         return 1;
2234 }
2235
2236 static int process_message(sd_bus *bus, sd_bus_message *m) {
2237         int r;
2238
2239         assert(bus);
2240         assert(m);
2241
2242         bus->current = m;
2243         bus->iteration_counter++;
2244
2245         log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s",
2246                   bus_message_type_to_string(m->header->type),
2247                   strna(sd_bus_message_get_sender(m)),
2248                   strna(sd_bus_message_get_destination(m)),
2249                   strna(sd_bus_message_get_path(m)),
2250                   strna(sd_bus_message_get_interface(m)),
2251                   strna(sd_bus_message_get_member(m)),
2252                   (unsigned long) BUS_MESSAGE_COOKIE(m),
2253                   (unsigned long) m->reply_cookie,
2254                   strna(m->error.message));
2255
2256         r = process_hello(bus, m);
2257         if (r != 0)
2258                 goto finish;
2259
2260         r = process_reply(bus, m);
2261         if (r != 0)
2262                 goto finish;
2263
2264         r = process_filter(bus, m);
2265         if (r != 0)
2266                 goto finish;
2267
2268         r = process_match(bus, m);
2269         if (r != 0)
2270                 goto finish;
2271
2272         r = process_builtin(bus, m);
2273         if (r != 0)
2274                 goto finish;
2275
2276         r = bus_process_object(bus, m);
2277
2278 finish:
2279         bus->current = NULL;
2280         return r;
2281 }
2282
2283 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2284         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2285         int r;
2286
2287         assert(bus);
2288         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2289
2290         r = process_timeout(bus);
2291         if (r != 0)
2292                 goto null_message;
2293
2294         r = dispatch_wqueue(bus);
2295         if (r != 0)
2296                 goto null_message;
2297
2298         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2299         if (r < 0)
2300                 return r;
2301         if (!m)
2302                 goto null_message;
2303
2304         r = process_message(bus, m);
2305         if (r != 0)
2306                 goto null_message;
2307
2308         if (ret) {
2309                 r = sd_bus_message_rewind(m, true);
2310                 if (r < 0)
2311                         return r;
2312
2313                 *ret = m;
2314                 m = NULL;
2315                 return 1;
2316         }
2317
2318         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2319
2320                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2321                           strna(sd_bus_message_get_sender(m)),
2322                           strna(sd_bus_message_get_path(m)),
2323                           strna(sd_bus_message_get_interface(m)),
2324                           strna(sd_bus_message_get_member(m)));
2325
2326                 r = sd_bus_reply_method_errorf(
2327                                 m,
2328                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2329                                 "Unknown object '%s'.", m->path);
2330                 if (r < 0)
2331                         return r;
2332         }
2333
2334         return 1;
2335
2336 null_message:
2337         if (r >= 0 && ret)
2338                 *ret = NULL;
2339
2340         return r;
2341 }
2342
2343 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2344         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2345         struct reply_callback *c;
2346         int r;
2347
2348         assert(bus);
2349         assert(bus->state == BUS_CLOSING);
2350
2351         c = hashmap_first(bus->reply_callbacks);
2352         if (c) {
2353                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2354
2355                 /* First, fail all outstanding method calls */
2356                 r = bus_message_new_synthetic_error(
2357                                 bus,
2358                                 c->cookie,
2359                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2360                                 &m);
2361                 if (r < 0)
2362                         return r;
2363
2364                 r = bus_seal_synthetic_message(bus, m);
2365                 if (r < 0)
2366                         return r;
2367
2368                 if (c->timeout != 0)
2369                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2370
2371                 hashmap_remove(bus->reply_callbacks, &c->cookie);
2372
2373                 bus->current = m;
2374                 bus->iteration_counter++;
2375
2376                 r = c->callback(bus, m, c->userdata, &error_buffer);
2377                 r = bus_maybe_reply_error(m, r, &error_buffer);
2378                 free(c);
2379
2380                 goto finish;
2381         }
2382
2383         /* Then, synthesize a Disconnected message */
2384         r = sd_bus_message_new_signal(
2385                         bus,
2386                         "/org/freedesktop/DBus/Local",
2387                         "org.freedesktop.DBus.Local",
2388                         "Disconnected",
2389                         &m);
2390         if (r < 0)
2391                 return r;
2392
2393         m->sender = "org.freedesktop.DBus.Local";
2394
2395         r = bus_seal_synthetic_message(bus, m);
2396         if (r < 0)
2397                 return r;
2398
2399         sd_bus_close(bus);
2400
2401         bus->current = m;
2402         bus->iteration_counter++;
2403
2404         r = process_filter(bus, m);
2405         if (r != 0)
2406                 goto finish;
2407
2408         r = process_match(bus, m);
2409         if (r != 0)
2410                 goto finish;
2411
2412         if (ret) {
2413                 *ret = m;
2414                 m = NULL;
2415         }
2416
2417         r = 1;
2418
2419 finish:
2420         bus->current = NULL;
2421         return r;
2422 }
2423
2424 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2425         BUS_DONT_DESTROY(bus);
2426         int r;
2427
2428         /* Returns 0 when we didn't do anything. This should cause the
2429          * caller to invoke sd_bus_wait() before returning the next
2430          * time. Returns > 0 when we did something, which possibly
2431          * means *ret is filled in with an unprocessed message. */
2432
2433         assert_return(bus, -EINVAL);
2434         assert_return(!bus_pid_changed(bus), -ECHILD);
2435
2436         /* We don't allow recursively invoking sd_bus_process(). */
2437         assert_return(!bus->current, -EBUSY);
2438
2439         switch (bus->state) {
2440
2441         case BUS_UNSET:
2442                 return -ENOTCONN;
2443
2444         case BUS_CLOSED:
2445                 return -ECONNRESET;
2446
2447         case BUS_OPENING:
2448                 r = bus_socket_process_opening(bus);
2449                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2450                         bus_enter_closing(bus);
2451                         r = 1;
2452                 } else if (r < 0)
2453                         return r;
2454                 if (ret)
2455                         *ret = NULL;
2456                 return r;
2457
2458         case BUS_AUTHENTICATING:
2459                 r = bus_socket_process_authenticating(bus);
2460                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2461                         bus_enter_closing(bus);
2462                         r = 1;
2463                 } else if (r < 0)
2464                         return r;
2465
2466                 if (ret)
2467                         *ret = NULL;
2468
2469                 return r;
2470
2471         case BUS_RUNNING:
2472         case BUS_HELLO:
2473                 r = process_running(bus, hint_priority, priority, ret);
2474                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2475                         bus_enter_closing(bus);
2476                         r = 1;
2477
2478                         if (ret)
2479                                 *ret = NULL;
2480                 }
2481
2482                 return r;
2483
2484         case BUS_CLOSING:
2485                 return process_closing(bus, ret);
2486         }
2487
2488         assert_not_reached("Unknown state");
2489 }
2490
2491 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2492         return bus_process_internal(bus, false, 0, ret);
2493 }
2494
2495 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2496         return bus_process_internal(bus, true, priority, ret);
2497 }
2498
2499 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2500         struct pollfd p[2] = {};
2501         int r, e, n;
2502         struct timespec ts;
2503         usec_t m = (usec_t) -1;
2504
2505         assert(bus);
2506
2507         if (bus->state == BUS_CLOSING)
2508                 return 1;
2509
2510         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2511
2512         e = sd_bus_get_events(bus);
2513         if (e < 0)
2514                 return e;
2515
2516         if (need_more)
2517                 /* The caller really needs some more data, he doesn't
2518                  * care about what's already read, or any timeouts
2519                  * except its own.*/
2520                 e |= POLLIN;
2521         else {
2522                 usec_t until;
2523                 /* The caller wants to process if there's something to
2524                  * process, but doesn't care otherwise */
2525
2526                 r = sd_bus_get_timeout(bus, &until);
2527                 if (r < 0)
2528                         return r;
2529                 if (r > 0) {
2530                         usec_t nw;
2531                         nw = now(CLOCK_MONOTONIC);
2532                         m = until > nw ? until - nw : 0;
2533                 }
2534         }
2535
2536         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2537                 m = timeout_usec;
2538
2539         p[0].fd = bus->input_fd;
2540         if (bus->output_fd == bus->input_fd) {
2541                 p[0].events = e;
2542                 n = 1;
2543         } else {
2544                 p[0].events = e & POLLIN;
2545                 p[1].fd = bus->output_fd;
2546                 p[1].events = e & POLLOUT;
2547                 n = 2;
2548         }
2549
2550         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2551         if (r < 0)
2552                 return -errno;
2553
2554         return r > 0 ? 1 : 0;
2555 }
2556
2557 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2558
2559         assert_return(bus, -EINVAL);
2560         assert_return(!bus_pid_changed(bus), -ECHILD);
2561
2562         if (bus->state == BUS_CLOSING)
2563                 return 0;
2564
2565         assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
2566
2567         if (bus->rqueue_size > 0)
2568                 return 0;
2569
2570         return bus_poll(bus, false, timeout_usec);
2571 }
2572
2573 _public_ int sd_bus_flush(sd_bus *bus) {
2574         int r;
2575
2576         assert_return(bus, -EINVAL);
2577         assert_return(!bus_pid_changed(bus), -ECHILD);
2578
2579         if (bus->state == BUS_CLOSING)
2580                 return 0;
2581
2582         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
2583
2584         r = bus_ensure_running(bus);
2585         if (r < 0)
2586                 return r;
2587
2588         if (bus->wqueue_size <= 0)
2589                 return 0;
2590
2591         for (;;) {
2592                 r = dispatch_wqueue(bus);
2593                 if (r < 0) {
2594                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2595                                 bus_enter_closing(bus);
2596                                 return -ECONNRESET;
2597                         }
2598
2599                         return r;
2600                 }
2601
2602                 if (bus->wqueue_size <= 0)
2603                         return 0;
2604
2605                 r = bus_poll(bus, false, (uint64_t) -1);
2606                 if (r < 0)
2607                         return r;
2608         }
2609 }
2610
2611 _public_ int sd_bus_add_filter(sd_bus *bus,
2612                                sd_bus_message_handler_t callback,
2613                                void *userdata) {
2614
2615         struct filter_callback *f;
2616
2617         assert_return(bus, -EINVAL);
2618         assert_return(callback, -EINVAL);
2619         assert_return(!bus_pid_changed(bus), -ECHILD);
2620
2621         f = new0(struct filter_callback, 1);
2622         if (!f)
2623                 return -ENOMEM;
2624         f->callback = callback;
2625         f->userdata = userdata;
2626
2627         bus->filter_callbacks_modified = true;
2628         LIST_PREPEND(callbacks, bus->filter_callbacks, f);
2629         return 0;
2630 }
2631
2632 _public_ int sd_bus_remove_filter(sd_bus *bus,
2633                                   sd_bus_message_handler_t callback,
2634                                   void *userdata) {
2635
2636         struct filter_callback *f;
2637
2638         assert_return(bus, -EINVAL);
2639         assert_return(callback, -EINVAL);
2640         assert_return(!bus_pid_changed(bus), -ECHILD);
2641
2642         LIST_FOREACH(callbacks, f, bus->filter_callbacks) {
2643                 if (f->callback == callback && f->userdata == userdata) {
2644                         bus->filter_callbacks_modified = true;
2645                         LIST_REMOVE(callbacks, bus->filter_callbacks, f);
2646                         free(f);
2647                         return 1;
2648                 }
2649         }
2650
2651         return 0;
2652 }
2653
2654 _public_ int sd_bus_add_match(sd_bus *bus,
2655                               const char *match,
2656                               sd_bus_message_handler_t callback,
2657                               void *userdata) {
2658
2659         struct bus_match_component *components = NULL;
2660         unsigned n_components = 0;
2661         uint64_t cookie = 0;
2662         int r = 0;
2663
2664         assert_return(bus, -EINVAL);
2665         assert_return(match, -EINVAL);
2666         assert_return(!bus_pid_changed(bus), -ECHILD);
2667
2668         r = bus_match_parse(match, &components, &n_components);
2669         if (r < 0)
2670                 goto finish;
2671
2672         if (bus->bus_client) {
2673                 cookie = ++bus->match_cookie;
2674
2675                 r = bus_add_match_internal(bus, match, components, n_components, cookie);
2676                 if (r < 0)
2677                         goto finish;
2678         }
2679
2680         bus->match_callbacks_modified = true;
2681         r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL);
2682         if (r < 0) {
2683                 if (bus->bus_client)
2684                         bus_remove_match_internal(bus, match, cookie);
2685         }
2686
2687 finish:
2688         bus_match_parse_free(components, n_components);
2689         return r;
2690 }
2691
2692 _public_ int sd_bus_remove_match(sd_bus *bus,
2693                                  const char *match,
2694                                  sd_bus_message_handler_t callback,
2695                                  void *userdata) {
2696
2697         struct bus_match_component *components = NULL;
2698         unsigned n_components = 0;
2699         int r = 0, q = 0;
2700         uint64_t cookie = 0;
2701
2702         assert_return(bus, -EINVAL);
2703         assert_return(match, -EINVAL);
2704         assert_return(!bus_pid_changed(bus), -ECHILD);
2705
2706         r = bus_match_parse(match, &components, &n_components);
2707         if (r < 0)
2708                 return r;
2709
2710         bus->match_callbacks_modified = true;
2711         r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie);
2712
2713         if (bus->bus_client)
2714                 q = bus_remove_match_internal(bus, match, cookie);
2715
2716         bus_match_parse_free(components, n_components);
2717
2718         return r < 0 ? r : q;
2719 }
2720
2721 bool bus_pid_changed(sd_bus *bus) {
2722         assert(bus);
2723
2724         /* We don't support people creating a bus connection and
2725          * keeping it around over a fork(). Let's complain. */
2726
2727         return bus->original_pid != getpid();
2728 }
2729
2730 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2731         sd_bus *bus = userdata;
2732         int r;
2733
2734         assert(bus);
2735
2736         r = sd_bus_process(bus, NULL);
2737         if (r < 0)
2738                 return r;
2739
2740         return 1;
2741 }
2742
2743 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
2744         sd_bus *bus = userdata;
2745         int r;
2746
2747         assert(bus);
2748
2749         r = sd_bus_process(bus, NULL);
2750         if (r < 0)
2751                 return r;
2752
2753         return 1;
2754 }
2755
2756 static int prepare_callback(sd_event_source *s, void *userdata) {
2757         sd_bus *bus = userdata;
2758         int r, e;
2759         usec_t until;
2760
2761         assert(s);
2762         assert(bus);
2763
2764         e = sd_bus_get_events(bus);
2765         if (e < 0)
2766                 return e;
2767
2768         if (bus->output_fd != bus->input_fd) {
2769
2770                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
2771                 if (r < 0)
2772                         return r;
2773
2774                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
2775                 if (r < 0)
2776                         return r;
2777         } else {
2778                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
2779                 if (r < 0)
2780                         return r;
2781         }
2782
2783         r = sd_bus_get_timeout(bus, &until);
2784         if (r < 0)
2785                 return r;
2786         if (r > 0) {
2787                 int j;
2788
2789                 j = sd_event_source_set_time(bus->time_event_source, until);
2790                 if (j < 0)
2791                         return j;
2792         }
2793
2794         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
2795         if (r < 0)
2796                 return r;
2797
2798         return 1;
2799 }
2800
2801 static int quit_callback(sd_event_source *event, void *userdata) {
2802         sd_bus *bus = userdata;
2803
2804         assert(event);
2805
2806         sd_bus_flush(bus);
2807
2808         return 1;
2809 }
2810
2811 static int attach_io_events(sd_bus *bus) {
2812         int r;
2813
2814         assert(bus);
2815
2816         if (bus->input_fd < 0)
2817                 return 0;
2818
2819         if (!bus->event)
2820                 return 0;
2821
2822         if (!bus->input_io_event_source) {
2823                 r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source);
2824                 if (r < 0)
2825                         return r;
2826
2827                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
2828                 if (r < 0)
2829                         return r;
2830
2831                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
2832         } else
2833                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
2834
2835         if (r < 0)
2836                 return r;
2837
2838         if (bus->output_fd != bus->input_fd) {
2839                 assert(bus->output_fd >= 0);
2840
2841                 if (!bus->output_io_event_source) {
2842                         r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source);
2843                         if (r < 0)
2844                                 return r;
2845
2846                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
2847                 } else
2848                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
2849
2850                 if (r < 0)
2851                         return r;
2852         }
2853
2854         return 0;
2855 }
2856
2857 static void detach_io_events(sd_bus *bus) {
2858         assert(bus);
2859
2860         if (bus->input_io_event_source) {
2861                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
2862                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
2863         }
2864
2865         if (bus->output_io_event_source) {
2866                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
2867                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
2868         }
2869 }
2870
2871 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
2872         int r;
2873
2874         assert_return(bus, -EINVAL);
2875         assert_return(!bus->event, -EBUSY);
2876
2877         assert(!bus->input_io_event_source);
2878         assert(!bus->output_io_event_source);
2879         assert(!bus->time_event_source);
2880
2881         if (event)
2882                 bus->event = sd_event_ref(event);
2883         else  {
2884                 r = sd_event_default(&bus->event);
2885                 if (r < 0)
2886                         return r;
2887         }
2888
2889         bus->event_priority = priority;
2890
2891         r = sd_event_add_monotonic(bus->event, 0, 0, time_callback, bus, &bus->time_event_source);
2892         if (r < 0)
2893                 goto fail;
2894
2895         r = sd_event_source_set_priority(bus->time_event_source, priority);
2896         if (r < 0)
2897                 goto fail;
2898
2899         r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
2900         if (r < 0)
2901                 goto fail;
2902
2903         r = attach_io_events(bus);
2904         if (r < 0)
2905                 goto fail;
2906
2907         return 0;
2908
2909 fail:
2910         sd_bus_detach_event(bus);
2911         return r;
2912 }
2913
2914 _public_ int sd_bus_detach_event(sd_bus *bus) {
2915         assert_return(bus, -EINVAL);
2916
2917         if (!bus->event)
2918                 return 0;
2919
2920         detach_io_events(bus);
2921
2922         if (bus->time_event_source) {
2923                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
2924                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
2925         }
2926
2927         if (bus->quit_event_source) {
2928                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
2929                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
2930         }
2931
2932         if (bus->event)
2933                 bus->event = sd_event_unref(bus->event);
2934
2935         return 1;
2936 }
2937
2938 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
2939         assert_return(bus, NULL);
2940
2941         return bus->event;
2942 }
2943
2944 _public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) {
2945         assert_return(bus, NULL);
2946
2947         return bus->current;
2948 }
2949
2950 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
2951         sd_bus *b = NULL;
2952         int r;
2953
2954         assert(bus_open);
2955         assert(default_bus);
2956
2957         if (!ret)
2958                 return !!*default_bus;
2959
2960         if (*default_bus) {
2961                 *ret = sd_bus_ref(*default_bus);
2962                 return 0;
2963         }
2964
2965         r = bus_open(&b);
2966         if (r < 0)
2967                 return r;
2968
2969         b->default_bus_ptr = default_bus;
2970         b->tid = gettid();
2971         *default_bus = b;
2972
2973         *ret = b;
2974         return 1;
2975 }
2976
2977 _public_ int sd_bus_default_system(sd_bus **ret) {
2978         static thread_local sd_bus *default_system_bus = NULL;
2979
2980         return bus_default(sd_bus_open_system, &default_system_bus, ret);
2981 }
2982
2983 _public_ int sd_bus_default_user(sd_bus **ret) {
2984         static thread_local sd_bus *default_user_bus = NULL;
2985
2986         return bus_default(sd_bus_open_user, &default_user_bus, ret);
2987 }
2988
2989 _public_ int sd_bus_default(sd_bus **ret) {
2990
2991         const char *e;
2992
2993         /* Let's try our best to reuse another cached connection. If
2994          * the starter bus type is set, connect via our normal
2995          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
2996          * we can share the connection with the user/system default
2997          * bus. */
2998
2999         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3000         if (e) {
3001                 if (streq(e, "system"))
3002                         return sd_bus_default_system(ret);
3003                 else if (streq(e, "user") || streq(e, "session"))
3004                         return sd_bus_default_user(ret);
3005         }
3006
3007         /* No type is specified, so we have not other option than to
3008          * use the starter address if it is set. */
3009
3010         e = secure_getenv("DBUS_STARTER_ADDRESS");
3011         if (e) {
3012                 static thread_local sd_bus *default_starter_bus = NULL;
3013
3014                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3015         }
3016
3017         /* Finally, if nothing is set use the cached connection for
3018          * the right scope */
3019
3020         if (cg_pid_get_owner_uid(0, NULL) >= 0)
3021                 return sd_bus_default_user(ret);
3022         else
3023                 return sd_bus_default_system(ret);
3024 }
3025
3026 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3027         assert_return(b, -EINVAL);
3028         assert_return(tid, -EINVAL);
3029         assert_return(!bus_pid_changed(b), -ECHILD);
3030
3031         if (b->tid != 0) {
3032                 *tid = b->tid;
3033                 return 0;
3034         }
3035
3036         if (b->event)
3037                 return sd_event_get_tid(b->event, tid);
3038
3039         return -ENXIO;
3040 }
3041
3042 _public_ char *sd_bus_label_escape(const char *s) {
3043         char *r, *t;
3044         const char *f;
3045
3046         assert_return(s, NULL);
3047
3048         /* Escapes all chars that D-Bus' object path cannot deal
3049          * with. Can be reversed with bus_path_unescape(). We special
3050          * case the empty string. */
3051
3052         if (*s == 0)
3053                 return strdup("_");
3054
3055         r = new(char, strlen(s)*3 + 1);
3056         if (!r)
3057                 return NULL;
3058
3059         for (f = s, t = r; *f; f++) {
3060
3061                 /* Escape everything that is not a-zA-Z0-9. We also
3062                  * escape 0-9 if it's the first character */
3063
3064                 if (!(*f >= 'A' && *f <= 'Z') &&
3065                     !(*f >= 'a' && *f <= 'z') &&
3066                     !(f > s && *f >= '0' && *f <= '9')) {
3067                         *(t++) = '_';
3068                         *(t++) = hexchar(*f >> 4);
3069                         *(t++) = hexchar(*f);
3070                 } else
3071                         *(t++) = *f;
3072         }
3073
3074         *t = 0;
3075
3076         return r;
3077 }
3078
3079 _public_ char *sd_bus_label_unescape(const char *f) {
3080         char *r, *t;
3081
3082         assert_return(f, NULL);
3083
3084         /* Special case for the empty string */
3085         if (streq(f, "_"))
3086                 return strdup("");
3087
3088         r = new(char, strlen(f) + 1);
3089         if (!r)
3090                 return NULL;
3091
3092         for (t = r; *f; f++) {
3093
3094                 if (*f == '_') {
3095                         int a, b;
3096
3097                         if ((a = unhexchar(f[1])) < 0 ||
3098                             (b = unhexchar(f[2])) < 0) {
3099                                 /* Invalid escape code, let's take it literal then */
3100                                 *(t++) = '_';
3101                         } else {
3102                                 *(t++) = (char) ((a << 4) | b);
3103                                 f += 2;
3104                         }
3105                 } else
3106                         *(t++) = *f;
3107         }
3108
3109         *t = 0;
3110
3111         return r;
3112 }
3113
3114 _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) {
3115         sd_bus_creds *c;
3116         pid_t pid = 0;
3117         int r;
3118
3119         assert_return(bus, -EINVAL);
3120         assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
3121         assert_return(ret, -EINVAL);
3122         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3123         assert_return(!bus_pid_changed(bus), -ECHILD);
3124         assert_return(!bus->is_kernel, -ENOTSUP);
3125
3126         if (!bus->ucred_valid && !isempty(bus->label))
3127                 return -ENODATA;
3128
3129         c = bus_creds_new();
3130         if (!c)
3131                 return -ENOMEM;
3132
3133         if (bus->ucred_valid) {
3134                 pid = c->pid = bus->ucred.pid;
3135                 c->uid = bus->ucred.uid;
3136                 c->gid = bus->ucred.gid;
3137
3138                 c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
3139         }
3140
3141         if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) {
3142                 c->label = strdup(bus->label);
3143                 if (!c->label) {
3144                         sd_bus_creds_unref(c);
3145                         return -ENOMEM;
3146                 }
3147
3148                 c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
3149         }
3150
3151         r = bus_creds_add_more(c, mask, pid, 0);
3152         if (r < 0)
3153                 return r;
3154
3155         *ret = c;
3156         return 0;
3157 }
3158
3159 _public_ int sd_bus_try_close(sd_bus *bus) {
3160         int r;
3161
3162         assert_return(bus, -EINVAL);
3163         assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
3164         assert_return(!bus_pid_changed(bus), -ECHILD);
3165         assert_return(bus->is_kernel, -ENOTSUP);
3166
3167         if (bus->rqueue_size > 0)
3168                 return -EBUSY;
3169
3170         if (bus->wqueue_size > 0)
3171                 return -EBUSY;
3172
3173         r = bus_kernel_try_close(bus);
3174         if (r < 0)
3175                 return r;
3176
3177         sd_bus_close(bus);
3178         return 0;
3179 }
3180
3181 _public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
3182         assert_return(bus, -EINVAL);
3183         assert_return(name, -EINVAL);
3184         assert_return(!bus_pid_changed(bus), -ECHILD);
3185
3186         *name = bus->connection_name;
3187         return 0;
3188 }