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