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

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