src/libelogind/sd-bus/sd-bus.c

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