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                 b->machine = mfree(b->machine);
 833         }
 834
 835         if (pid) {
 836                 r = parse_pid(pid, &b->nspid);
 837                 if (r < 0)
 838                         return r;
 839         } else
 840                 b->nspid = 0;
 841
 842         b->sockaddr.un.sun_family = AF_UNIX;
 843         strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
 844         b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket");
 845
 846         return 0;
 847 }
 848
 849 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
 850         _cleanup_free_ char *machine = NULL, *pid = NULL;
 851         int r;
 852
 853         assert(b);
 854         assert(p);
 855         assert(*p);
 856         assert(guid);
 857
 858         while (**p != 0 && **p != ';') {
 859                 r = parse_address_key(p, "guid", guid);
 860                 if (r < 0)
 861                         return r;
 862                 else if (r > 0)
 863                         continue;
 864
 865                 r = parse_address_key(p, "machine", &machine);
 866                 if (r < 0)
 867                         return r;
 868                 else if (r > 0)
 869                         continue;
 870
 871                 r = parse_address_key(p, "pid", &pid);
 872                 if (r < 0)
 873                         return r;
 874                 else if (r > 0)
 875                         continue;
 876
 877                 skip_address_key(p);
 878         }
 879
 880         if (!machine == !pid)
 881                 return -EINVAL;
 882
 883         if (machine) {
 884                 if (!machine_name_is_valid(machine))
 885                         return -EINVAL;
 886
 887                 free(b->machine);
 888                 b->machine = machine;
 889                 machine = NULL;
 890         } else {
 891                 b->machine = mfree(b->machine);
 892         }
 893
 894         if (pid) {
 895                 r = parse_pid(pid, &b->nspid);
 896                 if (r < 0)
 897                         return r;
 898         } else
 899                 b->nspid = 0;
 900
 901         r = free_and_strdup(&b->kernel, "/sys/fs/kdbus/0-system/bus");
 902         if (r < 0)
 903                 return r;
 904
 905         return 0;
 906 }
 907
 908 static void bus_reset_parsed_address(sd_bus *b) {
 909         assert(b);
 910
 911         zero(b->sockaddr);
 912         b->sockaddr_size = 0;
 913         b->exec_argv = strv_free(b->exec_argv);
 914         b->exec_path = mfree(b->exec_path);
 915         b->server_id = SD_ID128_NULL;
 916         b->kernel = mfree(b->kernel);
 917         b->machine = mfree(b->machine);
 918         b->nspid = 0;
 919 }
 920
 921 static int bus_parse_next_address(sd_bus *b) {
 922         _cleanup_free_ char *guid = NULL;
 923         const char *a;
 924         int r;
 925
 926         assert(b);
 927
 928         if (!b->address)
 929                 return 0;
 930         if (b->address[b->address_index] == 0)
 931                 return 0;
 932
 933         bus_reset_parsed_address(b);
 934
 935         a = b->address + b->address_index;
 936
 937         while (*a != 0) {
 938
 939                 if (*a == ';') {
 940                         a++;
 941                         continue;
 942                 }
 943
 944                 if (startswith(a, "unix:")) {
 945                         a += 5;
 946
 947                         r = parse_unix_address(b, &a, &guid);
 948                         if (r < 0)
 949                                 return r;
 950                         break;
 951
 952                 } else if (startswith(a, "tcp:")) {
 953
 954                         a += 4;
 955                         r = parse_tcp_address(b, &a, &guid);
 956                         if (r < 0)
 957                                 return r;
 958
 959                         break;
 960
 961                 } else if (startswith(a, "unixexec:")) {
 962
 963                         a += 9;
 964                         r = parse_exec_address(b, &a, &guid);
 965                         if (r < 0)
 966                                 return r;
 967
 968                         break;
 969
 970                 } else if (startswith(a, "kernel:")) {
 971
 972                         a += 7;
 973                         r = parse_kernel_address(b, &a, &guid);
 974                         if (r < 0)
 975                                 return r;
 976
 977                         break;
 978                 } else if (startswith(a, "x-machine-unix:")) {
 979
 980                         a += 15;
 981                         r = parse_container_unix_address(b, &a, &guid);
 982                         if (r < 0)
 983                                 return r;
 984
 985                         break;
 986                 } else if (startswith(a, "x-machine-kernel:")) {
 987
 988                         a += 17;
 989                         r = parse_container_kernel_address(b, &a, &guid);
 990                         if (r < 0)
 991                                 return r;
 992
 993                         break;
 994                 }
 995
 996                 a = strchr(a, ';');
 997                 if (!a)
 998                         return 0;
 999         }
1000
1001         if (guid) {
1002                 r = sd_id128_from_string(guid, &b->server_id);
1003                 if (r < 0)
1004                         return r;
1005         }
1006
1007         b->address_index = a - b->address;
1008         return 1;
1009 }
1010
1011 static int bus_start_address(sd_bus *b) {
1012         bool container_kdbus_available = false;
1013         bool kdbus_available = false;
1014         int r;
1015
1016         assert(b);
1017
1018         for (;;) {
1019                 bool skipped = false;
1020
1021                 bus_close_fds(b);
1022
1023                 /*
1024                  * Usually, if you provide multiple different bus-addresses, we
1025                  * try all of them in order. We use the first one that
1026                  * succeeds. However, if you mix kernel and unix addresses, we
1027                  * never try unix-addresses if a previous kernel address was
1028                  * tried and kdbus was available. This is required to prevent
1029                  * clients to fallback to the bus-proxy if kdbus is available
1030                  * but failed (eg., too many connections).
1031                  */
1032
1033                 if (b->exec_path)
1034                         r = bus_socket_exec(b);
1035
1036                 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1037                         r = bus_container_connect_kernel(b);
1038                         if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1039                                 container_kdbus_available = true;
1040
1041                 } else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) {
1042                         if (!container_kdbus_available)
1043                                 r = bus_container_connect_socket(b);
1044                         else
1045                                 skipped = true;
1046
1047                 } else if (b->kernel) {
1048                         r = bus_kernel_connect(b);
1049                         if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1050                                 kdbus_available = true;
1051
1052                 } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
1053                         if (!kdbus_available)
1054                                 r = bus_socket_connect(b);
1055                         else
1056                                 skipped = true;
1057
1058                 } else
1059                         skipped = true;
1060
1061                 if (!skipped) {
1062                         if (r >= 0) {
1063                                 r = attach_io_events(b);
1064                                 if (r >= 0)
1065                                         return r;
1066                         }
1067
1068                         b->last_connect_error = -r;
1069                 }
1070
1071                 r = bus_parse_next_address(b);
1072                 if (r < 0)
1073                         return r;
1074                 if (r == 0)
1075                         return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1076         }
1077 }
1078
1079 int bus_next_address(sd_bus *b) {
1080         assert(b);
1081
1082         bus_reset_parsed_address(b);
1083         return bus_start_address(b);
1084 }
1085
1086 static int bus_start_fd(sd_bus *b) {
1087         struct stat st;
1088         int r;
1089
1090         assert(b);
1091         assert(b->input_fd >= 0);
1092         assert(b->output_fd >= 0);
1093
1094         r = fd_nonblock(b->input_fd, true);
1095         if (r < 0)
1096                 return r;
1097
1098         r = fd_cloexec(b->input_fd, true);
1099         if (r < 0)
1100                 return r;
1101
1102         if (b->input_fd != b->output_fd) {
1103                 r = fd_nonblock(b->output_fd, true);
1104                 if (r < 0)
1105                         return r;
1106
1107                 r = fd_cloexec(b->output_fd, true);
1108                 if (r < 0)
1109                         return r;
1110         }
1111
1112         if (fstat(b->input_fd, &st) < 0)
1113                 return -errno;
1114
1115         if (S_ISCHR(b->input_fd))
1116                 return bus_kernel_take_fd(b);
1117         else
1118                 return bus_socket_take_fd(b);
1119 }
1120
1121 _public_ int sd_bus_start(sd_bus *bus) {
1122         int r;
1123
1124         assert_return(bus, -EINVAL);
1125         assert_return(bus->state == BUS_UNSET, -EPERM);
1126         assert_return(!bus_pid_changed(bus), -ECHILD);
1127
1128         bus->state = BUS_OPENING;
1129
1130         if (bus->is_server && bus->bus_client)
1131                 return -EINVAL;
1132
1133         if (bus->input_fd >= 0)
1134                 r = bus_start_fd(bus);
1135         else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1136                 r = bus_start_address(bus);
1137         else
1138                 return -EINVAL;
1139
1140         if (r < 0) {
1141                 sd_bus_close(bus);
1142                 return r;
1143         }
1144
1145         return bus_send_hello(bus);
1146 }
1147
1148 _public_ int sd_bus_open(sd_bus **ret) {
1149         const char *e;
1150         sd_bus *b;
1151         int r;
1152
1153         assert_return(ret, -EINVAL);
1154
1155         /* Let's connect to the starter bus if it is set, and
1156          * otherwise to the bus that is appropropriate for the scope
1157          * we are running in */
1158
1159         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1160         if (e) {
1161                 if (streq(e, "system"))
1162                         return sd_bus_open_system(ret);
1163 /// elogind does not support systemd units
1164 #if 0
1165                 else if (STR_IN_SET(e, "session", "user"))
1166                         return sd_bus_open_user(ret);
1167 #endif // 0
1168         }
1169
1170         e = secure_getenv("DBUS_STARTER_ADDRESS");
1171         if (!e) {
1172 /// elogind does not support systemd units
1173 #if 0
1174                 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1175                         return sd_bus_open_user(ret);
1176                 else
1177 #endif // 0
1178                 return sd_bus_open_system(ret);
1179         }
1180
1181         r = sd_bus_new(&b);
1182         if (r < 0)
1183                 return r;
1184
1185         r = sd_bus_set_address(b, e);
1186         if (r < 0)
1187                 goto fail;
1188
1189         b->bus_client = true;
1190
1191         /* We don't know whether the bus is trusted or not, so better
1192          * be safe, and authenticate everything */
1193         b->trusted = false;
1194         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1195         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1196
1197         r = sd_bus_start(b);
1198         if (r < 0)
1199                 goto fail;
1200
1201         *ret = b;
1202         return 0;
1203
1204 fail:
1205         bus_free(b);
1206         return r;
1207 }
1208
1209 int bus_set_address_system(sd_bus *b) {
1210         const char *e;
1211         assert(b);
1212
1213         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1214         if (e)
1215                 return sd_bus_set_address(b, e);
1216
1217         return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1218 }
1219
1220 _public_ int sd_bus_open_system(sd_bus **ret) {
1221         sd_bus *b;
1222         int r;
1223
1224         assert_return(ret, -EINVAL);
1225
1226         r = sd_bus_new(&b);
1227         if (r < 0)
1228                 return r;
1229
1230         r = bus_set_address_system(b);
1231         if (r < 0)
1232                 goto fail;
1233
1234         b->bus_client = true;
1235         b->is_system = true;
1236
1237         /* Let's do per-method access control on the system bus. We
1238          * need the caller's UID and capability set for that. */
1239         b->trusted = false;
1240         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1241         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1242
1243         r = sd_bus_start(b);
1244         if (r < 0)
1245                 goto fail;
1246
1247         *ret = b;
1248         return 0;
1249
1250 fail:
1251         bus_free(b);
1252         return r;
1253 }
1254
1255 /// elogind can not open/use a user bus
1256 #if 0
1257 int bus_set_address_user(sd_bus *b) {
1258         const char *e;
1259         uid_t uid;
1260         int r;
1261
1262         assert(b);
1263
1264         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1265         if (e)
1266                 return sd_bus_set_address(b, e);
1267
1268         r = cg_pid_get_owner_uid(0, &uid);
1269         if (r < 0)
1270                 uid = getuid();
1271
1272         e = secure_getenv("XDG_RUNTIME_DIR");
1273         if (e) {
1274                 _cleanup_free_ char *ee = NULL;
1275
1276                 ee = bus_address_escape(e);
1277                 if (!ee)
1278                         return -ENOMEM;
1279
1280                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, uid, ee);
1281         } else
1282                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, uid);
1283
1284         if (!b->address)
1285                 return -ENOMEM;
1286
1287         return 0;
1288 }
1289 #endif // 0
1290
1291 _public_ int sd_bus_open_user(sd_bus **ret) {
1292 /// elogind does not support user buses
1293 #if 0
1294         sd_bus *b;
1295         int r;
1296
1297         assert_return(ret, -EINVAL);
1298
1299         r = sd_bus_new(&b);
1300         if (r < 0)
1301                 return r;
1302
1303         r = bus_set_address_user(b);
1304         if (r < 0)
1305                 return r;
1306
1307         b->bus_client = true;
1308         b->is_user = true;
1309
1310         /* We don't do any per-method access control on the user
1311          * bus. */
1312         b->trusted = true;
1313
1314         r = sd_bus_start(b);
1315         if (r < 0)
1316                 goto fail;
1317
1318         *ret = b;
1319         return 0;
1320
1321 fail:
1322         bus_free(b);
1323         return r;
1324 #else
1325         return sd_bus_open_system(ret);
1326 #endif // 0
1327 }
1328
1329 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1330         _cleanup_free_ char *e = NULL;
1331         char *m = NULL, *c = NULL;
1332
1333         assert(b);
1334         assert(host);
1335
1336         /* Let's see if we shall enter some container */
1337         m = strchr(host, ':');
1338         if (m) {
1339                 m++;
1340
1341                 /* Let's make sure this is not a port of some kind,
1342                  * and is a valid machine name. */
1343                 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1344                         char *t;
1345
1346                         /* Cut out the host part */
1347                         t = strndupa(host, m - host - 1);
1348                         e = bus_address_escape(t);
1349                         if (!e)
1350                                 return -ENOMEM;
1351
1352                         c = strjoina(",argv4=--machine=", m);
1353                 }
1354         }
1355
1356         if (!e) {
1357                 e = bus_address_escape(host);
1358                 if (!e)
1359                         return -ENOMEM;
1360         }
1361
1362         b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1363         if (!b->address)
1364                 return -ENOMEM;
1365
1366         return 0;
1367  }
1368
1369 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1370         sd_bus *bus;
1371         int r;
1372
1373         assert_return(host, -EINVAL);
1374         assert_return(ret, -EINVAL);
1375
1376         r = sd_bus_new(&bus);
1377         if (r < 0)
1378                 return r;
1379
1380         r = bus_set_address_system_remote(bus, host);
1381         if (r < 0)
1382                 goto fail;
1383
1384         bus->bus_client = true;
1385         bus->trusted = false;
1386         bus->is_system = true;
1387
1388         r = sd_bus_start(bus);
1389         if (r < 0)
1390                 goto fail;
1391
1392         *ret = bus;
1393         return 0;
1394
1395 fail:
1396         bus_free(bus);
1397         return r;
1398 }
1399
1400 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1401         _cleanup_free_ char *e = NULL;
1402
1403         assert(b);
1404         assert(machine);
1405
1406         e = bus_address_escape(machine);
1407         if (!e)
1408                 return -ENOMEM;
1409
1410         b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1411         if (!b->address)
1412                 return -ENOMEM;
1413
1414         return 0;
1415 }
1416
1417 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1418         sd_bus *bus;
1419         int r;
1420
1421         assert_return(machine, -EINVAL);
1422         assert_return(ret, -EINVAL);
1423         assert_return(machine_name_is_valid(machine), -EINVAL);
1424
1425         r = sd_bus_new(&bus);
1426         if (r < 0)
1427                 return r;
1428
1429         r = bus_set_address_system_machine(bus, machine);
1430         if (r < 0)
1431                 goto fail;
1432
1433         bus->bus_client = true;
1434         bus->trusted = false;
1435         bus->is_system = true;
1436
1437         r = sd_bus_start(bus);
1438         if (r < 0)
1439                 goto fail;
1440
1441         *ret = bus;
1442         return 0;
1443
1444 fail:
1445         bus_free(bus);
1446         return r;
1447 }
1448
1449 _public_ void sd_bus_close(sd_bus *bus) {
1450
1451         if (!bus)
1452                 return;
1453         if (bus->state == BUS_CLOSED)
1454                 return;
1455         if (bus_pid_changed(bus))
1456                 return;
1457
1458         bus->state = BUS_CLOSED;
1459
1460         sd_bus_detach_event(bus);
1461
1462         /* Drop all queued messages so that they drop references to
1463          * the bus object and the bus may be freed */
1464         bus_reset_queues(bus);
1465
1466         if (!bus->is_kernel)
1467                 bus_close_fds(bus);
1468
1469         /* We'll leave the fd open in case this is a kernel bus, since
1470          * there might still be memblocks around that reference this
1471          * bus, and they might need to invoke the KDBUS_CMD_FREE
1472          * ioctl on the fd when they are freed. */
1473 }
1474
1475 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1476
1477         if (!bus)
1478                 return NULL;
1479
1480         sd_bus_flush(bus);
1481         sd_bus_close(bus);
1482
1483         return sd_bus_unref(bus);
1484 }
1485
1486 static void bus_enter_closing(sd_bus *bus) {
1487         assert(bus);
1488
1489         if (bus->state != BUS_OPENING &&
1490             bus->state != BUS_AUTHENTICATING &&
1491             bus->state != BUS_HELLO &&
1492             bus->state != BUS_RUNNING)
1493                 return;
1494
1495         bus->state = BUS_CLOSING;
1496 }
1497
1498 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1499         assert_return(bus, NULL);
1500
1501         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1502
1503         return bus;
1504 }
1505
1506 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1507         unsigned i;
1508
1509         if (!bus)
1510                 return NULL;
1511
1512         i = REFCNT_DEC(bus->n_ref);
1513         if (i > 0)
1514                 return NULL;
1515
1516         bus_free(bus);
1517         return NULL;
1518 }
1519
1520 /// UNNEEDED by elogind
1521 #if 0
1522 _public_ int sd_bus_is_open(sd_bus *bus) {
1523
1524         assert_return(bus, -EINVAL);
1525         assert_return(!bus_pid_changed(bus), -ECHILD);
1526
1527         return BUS_IS_OPEN(bus->state);
1528 }
1529 #endif // 0
1530
1531 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1532         int r;
1533
1534         assert_return(bus, -EINVAL);
1535         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1536         assert_return(!bus_pid_changed(bus), -ECHILD);
1537
1538         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1539                 return 0;
1540
1541         if (type == SD_BUS_TYPE_UNIX_FD) {
1542                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1543                         return 0;
1544
1545                 r = bus_ensure_running(bus);
1546                 if (r < 0)
1547                         return r;
1548
1549                 return bus->can_fds;
1550         }
1551
1552         return bus_type_is_valid(type);
1553 }
1554
1555 /// UNNEEDED by elogind
1556 #if 0
1557 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1558         int r;
1559
1560         assert_return(bus, -EINVAL);
1561         assert_return(id, -EINVAL);
1562         assert_return(!bus_pid_changed(bus), -ECHILD);
1563
1564         r = bus_ensure_running(bus);
1565         if (r < 0)
1566                 return r;
1567
1568         *id = bus->server_id;
1569         return 0;
1570 }
1571 #endif // 0
1572
1573 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1574         assert(b);
1575         assert(m);
1576
1577         if (m->sealed) {
1578                 /* If we copy the same message to multiple
1579                  * destinations, avoid using the same cookie
1580                  * numbers. */
1581                 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1582                 return 0;
1583         }
1584
1585         if (timeout == 0)
1586                 timeout = BUS_DEFAULT_TIMEOUT;
1587
1588         return bus_message_seal(m, ++b->cookie, timeout);
1589 }
1590
1591 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1592         bool remarshal = false;
1593
1594         assert(b);
1595
1596         /* wrong packet version */
1597         if (b->message_version != 0 && b->message_version != (*m)->header->version)
1598                 remarshal = true;
1599
1600         /* wrong packet endianness */
1601         if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1602                 remarshal = true;
1603
1604         /* TODO: kdbus-messages received from the kernel contain data which is
1605          * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1606          * force remarshaling of the message. Technically, we could just
1607          * recreate the kdbus message, but that is non-trivial as other parts of
1608          * the message refer to m->kdbus already. This should be fixed! */
1609         if ((*m)->kdbus && (*m)->release_kdbus)
1610                 remarshal = true;
1611
1612         return remarshal ? bus_message_remarshal(b, m) : 0;
1613 }
1614
1615 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1616         assert(b);
1617         assert(m);
1618
1619         /* Fake some timestamps, if they were requested, and not
1620          * already initialized */
1621         if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1622                 if (m->realtime <= 0)
1623                         m->realtime = now(CLOCK_REALTIME);
1624
1625                 if (m->monotonic <= 0)
1626                         m->monotonic = now(CLOCK_MONOTONIC);
1627         }
1628
1629         /* The bus specification says the serial number cannot be 0,
1630          * hence let's fill something in for synthetic messages. Since
1631          * synthetic messages might have a fake sender and we don't
1632          * want to interfere with the real sender's serial numbers we
1633          * pick a fixed, artificial one. We use (uint32_t) -1 rather
1634          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1635          * even though kdbus can do 64bit. */
1636         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1637 }
1638
1639 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1640         int r;
1641
1642         assert(bus);
1643         assert(m);
1644
1645         if (bus->is_kernel)
1646                 r = bus_kernel_write_message(bus, m, hint_sync_call);
1647         else
1648                 r = bus_socket_write_message(bus, m, idx);
1649
1650         if (r <= 0)
1651                 return r;
1652
1653         if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1654                 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1655                           bus_message_type_to_string(m->header->type),
1656                           strna(sd_bus_message_get_sender(m)),
1657                           strna(sd_bus_message_get_destination(m)),
1658                           strna(sd_bus_message_get_path(m)),
1659                           strna(sd_bus_message_get_interface(m)),
1660                           strna(sd_bus_message_get_member(m)),
1661                           BUS_MESSAGE_COOKIE(m),
1662                           m->reply_cookie,
1663                           strna(m->error.message));
1664
1665         return r;
1666 }
1667
1668 static int dispatch_wqueue(sd_bus *bus) {
1669         int r, ret = 0;
1670
1671         assert(bus);
1672         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1673
1674         while (bus->wqueue_size > 0) {
1675
1676                 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1677                 if (r < 0)
1678                         return r;
1679                 else if (r == 0)
1680                         /* Didn't do anything this time */
1681                         return ret;
1682                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1683                         /* Fully written. Let's drop the entry from
1684                          * the queue.
1685                          *
1686                          * This isn't particularly optimized, but
1687                          * well, this is supposed to be our worst-case
1688                          * buffer only, and the socket buffer is
1689                          * supposed to be our primary buffer, and if
1690                          * it got full, then all bets are off
1691                          * anyway. */
1692
1693                         bus->wqueue_size --;
1694                         sd_bus_message_unref(bus->wqueue[0]);
1695                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1696                         bus->windex = 0;
1697
1698                         ret = 1;
1699                 }
1700         }
1701
1702         return ret;
1703 }
1704
1705 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1706         assert(bus);
1707
1708         if (bus->is_kernel)
1709                 return bus_kernel_read_message(bus, hint_priority, priority);
1710         else
1711                 return bus_socket_read_message(bus);
1712 }
1713
1714 int bus_rqueue_make_room(sd_bus *bus) {
1715         assert(bus);
1716
1717         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1718                 return -ENOBUFS;
1719
1720         if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1721                 return -ENOMEM;
1722
1723         return 0;
1724 }
1725
1726 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1727         int r, ret = 0;
1728
1729         assert(bus);
1730         assert(m);
1731         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1732
1733         /* Note that the priority logic is only available on kdbus,
1734          * where the rqueue is unused. We check the rqueue here
1735          * anyway, because it's simple... */
1736
1737         for (;;) {
1738                 if (bus->rqueue_size > 0) {
1739                         /* Dispatch a queued message */
1740
1741                         *m = bus->rqueue[0];
1742                         bus->rqueue_size --;
1743                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1744                         return 1;
1745                 }
1746
1747                 /* Try to read a new message */
1748                 r = bus_read_message(bus, hint_priority, priority);
1749                 if (r < 0)
1750                         return r;
1751                 if (r == 0)
1752                         return ret;
1753
1754                 ret = 1;
1755         }
1756 }
1757
1758 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1759         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1760         int r;
1761
1762         assert_return(m, -EINVAL);
1763
1764         if (!bus)
1765                 bus = m->bus;
1766
1767         assert_return(!bus_pid_changed(bus), -ECHILD);
1768         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1769
1770         if (!BUS_IS_OPEN(bus->state))
1771                 return -ENOTCONN;
1772
1773         if (m->n_fds > 0) {
1774                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1775                 if (r < 0)
1776                         return r;
1777                 if (r == 0)
1778                         return -EOPNOTSUPP;
1779         }
1780
1781         /* If the cookie number isn't kept, then we know that no reply
1782          * is expected */
1783         if (!cookie && !m->sealed)
1784                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1785
1786         r = bus_seal_message(bus, m, 0);
1787         if (r < 0)
1788                 return r;
1789
1790         /* Remarshall if we have to. This will possibly unref the
1791          * message and place a replacement in m */
1792         r = bus_remarshal_message(bus, &m);
1793         if (r < 0)
1794                 return r;
1795
1796         /* If this is a reply and no reply was requested, then let's
1797          * suppress this, if we can */
1798         if (m->dont_send)
1799                 goto finish;
1800
1801         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1802                 size_t idx = 0;
1803
1804                 r = bus_write_message(bus, m, hint_sync_call, &idx);
1805                 if (r < 0) {
1806                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1807                                 bus_enter_closing(bus);
1808                                 return -ECONNRESET;
1809                         }
1810
1811                         return r;
1812                 }
1813
1814                 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1815                         /* Wasn't fully written. So let's remember how
1816                          * much was written. Note that the first entry
1817                          * of the wqueue array is always allocated so
1818                          * that we always can remember how much was
1819                          * written. */
1820                         bus->wqueue[0] = sd_bus_message_ref(m);
1821                         bus->wqueue_size = 1;
1822                         bus->windex = idx;
1823                 }
1824
1825         } else {
1826                 /* Just append it to the queue. */
1827
1828                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1829                         return -ENOBUFS;
1830
1831                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1832                         return -ENOMEM;
1833
1834                 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1835         }
1836
1837 finish:
1838         if (cookie)
1839                 *cookie = BUS_MESSAGE_COOKIE(m);
1840
1841         return 1;
1842 }
1843
1844 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1845         return bus_send_internal(bus, m, cookie, false);
1846 }
1847
1848 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1849         int r;
1850
1851         assert_return(m, -EINVAL);
1852
1853         if (!bus)
1854                 bus = m->bus;
1855
1856         assert_return(!bus_pid_changed(bus), -ECHILD);
1857
1858         if (!BUS_IS_OPEN(bus->state))
1859                 return -ENOTCONN;
1860
1861         if (!streq_ptr(m->destination, destination)) {
1862
1863                 if (!destination)
1864                         return -EEXIST;
1865
1866                 r = sd_bus_message_set_destination(m, destination);
1867                 if (r < 0)
1868                         return r;
1869         }
1870
1871         return sd_bus_send(bus, m, cookie);
1872 }
1873
1874 static usec_t calc_elapse(uint64_t usec) {
1875         if (usec == (uint64_t) -1)
1876                 return 0;
1877
1878         return now(CLOCK_MONOTONIC) + usec;
1879 }
1880
1881 static int timeout_compare(const void *a, const void *b) {
1882         const struct reply_callback *x = a, *y = b;
1883
1884         if (x->timeout != 0 && y->timeout == 0)
1885                 return -1;
1886
1887         if (x->timeout == 0 && y->timeout != 0)
1888                 return 1;
1889
1890         if (x->timeout < y->timeout)
1891                 return -1;
1892
1893         if (x->timeout > y->timeout)
1894                 return 1;
1895
1896         return 0;
1897 }
1898
1899 _public_ int sd_bus_call_async(
1900                 sd_bus *bus,
1901                 sd_bus_slot **slot,
1902                 sd_bus_message *_m,
1903                 sd_bus_message_handler_t callback,
1904                 void *userdata,
1905                 uint64_t usec) {
1906
1907         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1908         _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1909         int r;
1910
1911         assert_return(m, -EINVAL);
1912         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1913         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1914         assert_return(callback, -EINVAL);
1915
1916         if (!bus)
1917                 bus = m->bus;
1918
1919         assert_return(!bus_pid_changed(bus), -ECHILD);
1920         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1921
1922         if (!BUS_IS_OPEN(bus->state))
1923                 return -ENOTCONN;
1924
1925         r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1926         if (r < 0)
1927                 return r;
1928
1929         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1930         if (r < 0)
1931                 return r;
1932
1933         r = bus_seal_message(bus, m, usec);
1934         if (r < 0)
1935                 return r;
1936
1937         r = bus_remarshal_message(bus, &m);
1938         if (r < 0)
1939                 return r;
1940
1941         s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1942         if (!s)
1943                 return -ENOMEM;
1944
1945         s->reply_callback.callback = callback;
1946
1947         s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1948         r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1949         if (r < 0) {
1950                 s->reply_callback.cookie = 0;
1951                 return r;
1952         }
1953
1954         s->reply_callback.timeout = calc_elapse(m->timeout);
1955         if (s->reply_callback.timeout != 0) {
1956                 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1957                 if (r < 0) {
1958                         s->reply_callback.timeout = 0;
1959                         return r;
1960                 }
1961         }
1962
1963         r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1964         if (r < 0)
1965                 return r;
1966
1967         if (slot)
1968                 *slot = s;
1969         s = NULL;
1970
1971         return r;
1972 }
1973
1974 int bus_ensure_running(sd_bus *bus) {
1975         int r;
1976
1977         assert(bus);
1978
1979         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1980                 return -ENOTCONN;
1981         if (bus->state == BUS_RUNNING)
1982                 return 1;
1983
1984         for (;;) {
1985                 r = sd_bus_process(bus, NULL);
1986                 if (r < 0)
1987                         return r;
1988                 if (bus->state == BUS_RUNNING)
1989                         return 1;
1990                 if (r > 0)
1991                         continue;
1992
1993                 r = sd_bus_wait(bus, (uint64_t) -1);
1994                 if (r < 0)
1995                         return r;
1996         }
1997 }
1998
1999 _public_ int sd_bus_call(
2000                 sd_bus *bus,
2001                 sd_bus_message *_m,
2002                 uint64_t usec,
2003                 sd_bus_error *error,
2004                 sd_bus_message **reply) {
2005
2006         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
2007         usec_t timeout;
2008         uint64_t cookie;
2009         unsigned i;
2010         int r;
2011
2012         bus_assert_return(m, -EINVAL, error);
2013         bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
2014         bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
2015         bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
2016
2017         if (!bus)
2018                 bus = m->bus;
2019
2020         bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
2021         bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
2022
2023         if (!BUS_IS_OPEN(bus->state)) {
2024                 r = -ENOTCONN;
2025                 goto fail;
2026         }
2027
2028         r = bus_ensure_running(bus);
2029         if (r < 0)
2030                 goto fail;
2031
2032         i = bus->rqueue_size;
2033
2034         r = bus_seal_message(bus, m, usec);
2035         if (r < 0)
2036                 goto fail;
2037
2038         r = bus_remarshal_message(bus, &m);
2039         if (r < 0)
2040                 goto fail;
2041
2042         r = bus_send_internal(bus, m, &cookie, true);
2043         if (r < 0)
2044                 goto fail;
2045
2046         timeout = calc_elapse(m->timeout);
2047
2048         for (;;) {
2049                 usec_t left;
2050
2051                 while (i < bus->rqueue_size) {
2052                         sd_bus_message *incoming = NULL;
2053
2054                         incoming = bus->rqueue[i];
2055
2056                         if (incoming->reply_cookie == cookie) {
2057                                 /* Found a match! */
2058
2059                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2060                                 bus->rqueue_size--;
2061                                 log_debug_bus_message(incoming);
2062
2063                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2064
2065                                         if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2066                                                 if (reply)
2067                                                         *reply = incoming;
2068                                                 else
2069                                                         sd_bus_message_unref(incoming);
2070
2071                                                 return 1;
2072                                         }
2073
2074                                         r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2075                                         sd_bus_message_unref(incoming);
2076                                         return r;
2077
2078                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2079                                         r = sd_bus_error_copy(error, &incoming->error);
2080                                 sd_bus_message_unref(incoming);
2081                                 return r;
2082                                 } else {
2083                                         r = -EIO;
2084                                         goto fail;
2085                                 }
2086
2087                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2088                                    bus->unique_name &&
2089                                    incoming->sender &&
2090                                    streq(bus->unique_name, incoming->sender)) {
2091
2092                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2093                                 bus->rqueue_size--;
2094
2095                                 /* Our own message? Somebody is trying
2096                                  * to send its own client a message,
2097                                  * let's not dead-lock, let's fail
2098                                  * immediately. */
2099
2100                                 sd_bus_message_unref(incoming);
2101                                 r = -ELOOP;
2102                                 goto fail;
2103                         }
2104
2105                         /* Try to read more, right-away */
2106                         i++;
2107                 }
2108
2109                 r = bus_read_message(bus, false, 0);
2110                 if (r < 0) {
2111                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2112                                 bus_enter_closing(bus);
2113                                 r = -ECONNRESET;
2114                         }
2115
2116                         goto fail;
2117                 }
2118                 if (r > 0)
2119                         continue;
2120
2121                 if (timeout > 0) {
2122                         usec_t n;
2123
2124                         n = now(CLOCK_MONOTONIC);
2125                         if (n >= timeout) {
2126                                 r = -ETIMEDOUT;
2127                                 goto fail;
2128                         }
2129
2130                         left = timeout - n;
2131                 } else
2132                         left = (uint64_t) -1;
2133
2134                 r = bus_poll(bus, true, left);
2135                 if (r < 0)
2136                         goto fail;
2137                 if (r == 0) {
2138                         r = -ETIMEDOUT;
2139                         goto fail;
2140                 }
2141
2142                 r = dispatch_wqueue(bus);
2143                 if (r < 0) {
2144                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2145                                 bus_enter_closing(bus);
2146                                 r = -ECONNRESET;
2147                         }
2148
2149                         goto fail;
2150                 }
2151         }
2152
2153 fail:
2154         return sd_bus_error_set_errno(error, r);
2155 }
2156
2157 _public_ int sd_bus_get_fd(sd_bus *bus) {
2158
2159         assert_return(bus, -EINVAL);
2160         assert_return(bus->input_fd == bus->output_fd, -EPERM);
2161         assert_return(!bus_pid_changed(bus), -ECHILD);
2162
2163         return bus->input_fd;
2164 }
2165
2166 _public_ int sd_bus_get_events(sd_bus *bus) {
2167         int flags = 0;
2168
2169         assert_return(bus, -EINVAL);
2170         assert_return(!bus_pid_changed(bus), -ECHILD);
2171
2172         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2173                 return -ENOTCONN;
2174
2175         if (bus->state == BUS_OPENING)
2176                 flags |= POLLOUT;
2177         else if (bus->state == BUS_AUTHENTICATING) {
2178
2179                 if (bus_socket_auth_needs_write(bus))
2180                         flags |= POLLOUT;
2181
2182                 flags |= POLLIN;
2183
2184         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2185                 if (bus->rqueue_size <= 0)
2186                         flags |= POLLIN;
2187                 if (bus->wqueue_size > 0)
2188                         flags |= POLLOUT;
2189         }
2190
2191         return flags;
2192 }
2193
2194 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2195         struct reply_callback *c;
2196
2197         assert_return(bus, -EINVAL);
2198         assert_return(timeout_usec, -EINVAL);
2199         assert_return(!bus_pid_changed(bus), -ECHILD);
2200
2201         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2202                 return -ENOTCONN;
2203
2204         if (bus->track_queue) {
2205                 *timeout_usec = 0;
2206                 return 1;
2207         }
2208
2209         if (bus->state == BUS_CLOSING) {
2210                 *timeout_usec = 0;
2211                 return 1;
2212         }
2213
2214         if (bus->state == BUS_AUTHENTICATING) {
2215                 *timeout_usec = bus->auth_timeout;
2216                 return 1;
2217         }
2218
2219         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2220                 *timeout_usec = (uint64_t) -1;
2221                 return 0;
2222         }
2223
2224         if (bus->rqueue_size > 0) {
2225                 *timeout_usec = 0;
2226                 return 1;
2227         }
2228
2229         c = prioq_peek(bus->reply_callbacks_prioq);
2230         if (!c) {
2231                 *timeout_usec = (uint64_t) -1;
2232                 return 0;
2233         }
2234
2235         if (c->timeout == 0) {
2236                 *timeout_usec = (uint64_t) -1;
2237                 return 0;
2238         }
2239
2240         *timeout_usec = c->timeout;
2241         return 1;
2242 }
2243
2244 static int process_timeout(sd_bus *bus) {
2245         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2246         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2247         struct reply_callback *c;
2248         sd_bus_slot *slot;
2249         usec_t n;
2250         int r;
2251
2252         assert(bus);
2253
2254         c = prioq_peek(bus->reply_callbacks_prioq);
2255         if (!c)
2256                 return 0;
2257
2258         n = now(CLOCK_MONOTONIC);
2259         if (c->timeout > n)
2260                 return 0;
2261
2262         r = bus_message_new_synthetic_error(
2263                         bus,
2264                         c->cookie,
2265                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2266                         &m);
2267         if (r < 0)
2268                 return r;
2269
2270         r = bus_seal_synthetic_message(bus, m);
2271         if (r < 0)
2272                 return r;
2273
2274         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2275         c->timeout = 0;
2276
2277         ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2278         c->cookie = 0;
2279
2280         slot = container_of(c, sd_bus_slot, reply_callback);
2281
2282         bus->iteration_counter ++;
2283
2284         bus->current_message = m;
2285         bus->current_slot = sd_bus_slot_ref(slot);
2286         bus->current_handler = c->callback;
2287         bus->current_userdata = slot->userdata;
2288         r = c->callback(m, slot->userdata, &error_buffer);
2289         bus->current_userdata = NULL;
2290         bus->current_handler = NULL;
2291         bus->current_slot = NULL;
2292         bus->current_message = NULL;
2293
2294         if (slot->floating) {
2295                 bus_slot_disconnect(slot);
2296                 sd_bus_slot_unref(slot);
2297         }
2298
2299         sd_bus_slot_unref(slot);
2300
2301         return bus_maybe_reply_error(m, r, &error_buffer);
2302 }
2303
2304 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2305         assert(bus);
2306         assert(m);
2307
2308         if (bus->state != BUS_HELLO)
2309                 return 0;
2310
2311         /* Let's make sure the first message on the bus is the HELLO
2312          * reply. But note that we don't actually parse the message
2313          * here (we leave that to the usual handling), we just verify
2314          * we don't let any earlier msg through. */
2315
2316         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2317             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2318                 return -EIO;
2319
2320         if (m->reply_cookie != 1)
2321                 return -EIO;
2322
2323         return 0;
2324 }
2325
2326 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2327         _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2328         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2329         struct reply_callback *c;
2330         sd_bus_slot *slot;
2331         int r;
2332
2333         assert(bus);
2334         assert(m);
2335
2336         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2337             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2338                 return 0;
2339
2340         if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2341                 return 0;
2342
2343         if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2344                 return 0;
2345
2346         c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2347         if (!c)
2348                 return 0;
2349
2350         c->cookie = 0;
2351
2352         slot = container_of(c, sd_bus_slot, reply_callback);
2353
2354         if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2355
2356                 /* If the reply contained a file descriptor which we
2357                  * didn't want we pass an error instead. */
2358
2359                 r = bus_message_new_synthetic_error(
2360                                 bus,
2361                                 m->reply_cookie,
2362                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2363                                 &synthetic_reply);
2364                 if (r < 0)
2365                         return r;
2366
2367                 /* Copy over original timestamp */
2368                 synthetic_reply->realtime = m->realtime;
2369                 synthetic_reply->monotonic = m->monotonic;
2370                 synthetic_reply->seqnum = m->seqnum;
2371
2372                 r = bus_seal_synthetic_message(bus, synthetic_reply);
2373                 if (r < 0)
2374                         return r;
2375
2376                 m = synthetic_reply;
2377         } else {
2378                 r = sd_bus_message_rewind(m, true);
2379                 if (r < 0)
2380                         return r;
2381         }
2382
2383         if (c->timeout != 0) {
2384                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2385                 c->timeout = 0;
2386         }
2387
2388         bus->current_slot = sd_bus_slot_ref(slot);
2389         bus->current_handler = c->callback;
2390         bus->current_userdata = slot->userdata;
2391         r = c->callback(m, slot->userdata, &error_buffer);
2392         bus->current_userdata = NULL;
2393         bus->current_handler = NULL;
2394         bus->current_slot = NULL;
2395
2396         if (slot->floating) {
2397                 bus_slot_disconnect(slot);
2398                 sd_bus_slot_unref(slot);
2399         }
2400
2401         sd_bus_slot_unref(slot);
2402
2403         return bus_maybe_reply_error(m, r, &error_buffer);
2404 }
2405
2406 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2407         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2408         struct filter_callback *l;
2409         int r;
2410
2411         assert(bus);
2412         assert(m);
2413
2414         do {
2415                 bus->filter_callbacks_modified = false;
2416
2417                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2418                         sd_bus_slot *slot;
2419
2420                         if (bus->filter_callbacks_modified)
2421                                 break;
2422
2423                         /* Don't run this more than once per iteration */
2424                         if (l->last_iteration == bus->iteration_counter)
2425                                 continue;
2426
2427                         l->last_iteration = bus->iteration_counter;
2428
2429                         r = sd_bus_message_rewind(m, true);
2430                         if (r < 0)
2431                                 return r;
2432
2433                         slot = container_of(l, sd_bus_slot, filter_callback);
2434
2435                         bus->current_slot = sd_bus_slot_ref(slot);
2436                         bus->current_handler = l->callback;
2437                         bus->current_userdata = slot->userdata;
2438                         r = l->callback(m, slot->userdata, &error_buffer);
2439                         bus->current_userdata = NULL;
2440                         bus->current_handler = NULL;
2441                         bus->current_slot = sd_bus_slot_unref(slot);
2442
2443                         r = bus_maybe_reply_error(m, r, &error_buffer);
2444                         if (r != 0)
2445                                 return r;
2446
2447                 }
2448
2449         } while (bus->filter_callbacks_modified);
2450
2451         return 0;
2452 }
2453
2454 static int process_match(sd_bus *bus, sd_bus_message *m) {
2455         int r;
2456
2457         assert(bus);
2458         assert(m);
2459
2460         do {
2461                 bus->match_callbacks_modified = false;
2462
2463                 r = bus_match_run(bus, &bus->match_callbacks, m);
2464                 if (r != 0)
2465                         return r;
2466
2467         } while (bus->match_callbacks_modified);
2468
2469         return 0;
2470 }
2471
2472 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2473         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2474         int r;
2475
2476         assert(bus);
2477         assert(m);
2478
2479         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2480                 return 0;
2481
2482         if (bus->manual_peer_interface)
2483                 return 0;
2484
2485         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2486                 return 0;
2487
2488         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2489                 return 0;
2490
2491         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2492                 return 1;
2493
2494         if (streq_ptr(m->member, "Ping"))
2495                 r = sd_bus_message_new_method_return(m, &reply);
2496         else if (streq_ptr(m->member, "GetMachineId")) {
2497                 sd_id128_t id;
2498                 char sid[33];
2499
2500                 r = sd_id128_get_machine(&id);
2501                 if (r < 0)
2502                         return r;
2503
2504                 r = sd_bus_message_new_method_return(m, &reply);
2505                 if (r < 0)
2506                         return r;
2507
2508                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2509         } else {
2510                 r = sd_bus_message_new_method_errorf(
2511                                 m, &reply,
2512                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2513                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2514         }
2515
2516         if (r < 0)
2517                 return r;
2518
2519         r = sd_bus_send(bus, reply, NULL);
2520         if (r < 0)
2521                 return r;
2522
2523         return 1;
2524 }
2525
2526 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2527         assert(bus);
2528         assert(m);
2529
2530         /* If we got a message with a file descriptor which we didn't
2531          * want to accept, then let's drop it. How can this even
2532          * happen? For example, when the kernel queues a message into
2533          * an activatable names's queue which allows fds, and then is
2534          * delivered to us later even though we ourselves did not
2535          * negotiate it. */
2536
2537         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2538                 return 0;
2539
2540         if (m->n_fds <= 0)
2541                 return 0;
2542
2543         if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2544                 return 0;
2545
2546         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2547                 return 1; /* just eat it up */
2548
2549         return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2550 }
2551
2552 static int process_message(sd_bus *bus, sd_bus_message *m) {
2553         int r;
2554
2555         assert(bus);
2556         assert(m);
2557
2558         bus->current_message = m;
2559         bus->iteration_counter++;
2560
2561         log_debug_bus_message(m);
2562
2563         r = process_hello(bus, m);
2564         if (r != 0)
2565                 goto finish;
2566
2567         r = process_reply(bus, m);
2568         if (r != 0)
2569                 goto finish;
2570
2571         r = process_fd_check(bus, m);
2572         if (r != 0)
2573                 goto finish;
2574
2575         r = process_filter(bus, m);
2576         if (r != 0)
2577                 goto finish;
2578
2579         r = process_match(bus, m);
2580         if (r != 0)
2581                 goto finish;
2582
2583         r = process_builtin(bus, m);
2584         if (r != 0)
2585                 goto finish;
2586
2587         r = bus_process_object(bus, m);
2588
2589 finish:
2590         bus->current_message = NULL;
2591         return r;
2592 }
2593
2594 static int dispatch_track(sd_bus *bus) {
2595         assert(bus);
2596
2597         if (!bus->track_queue)
2598                 return 0;
2599
2600         bus_track_dispatch(bus->track_queue);
2601         return 1;
2602 }
2603
2604 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2605         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2606         int r;
2607
2608         assert(bus);
2609         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2610
2611         r = process_timeout(bus);
2612         if (r != 0)
2613                 goto null_message;
2614
2615         r = dispatch_wqueue(bus);
2616         if (r != 0)
2617                 goto null_message;
2618
2619         r = dispatch_track(bus);
2620         if (r != 0)
2621                 goto null_message;
2622
2623         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2624         if (r < 0)
2625                 return r;
2626         if (!m)
2627                 goto null_message;
2628
2629         r = process_message(bus, m);
2630         if (r != 0)
2631                 goto null_message;
2632
2633         if (ret) {
2634                 r = sd_bus_message_rewind(m, true);
2635                 if (r < 0)
2636                         return r;
2637
2638                 *ret = m;
2639                 m = NULL;
2640                 return 1;
2641         }
2642
2643         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2644
2645                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2646                           strna(sd_bus_message_get_sender(m)),
2647                           strna(sd_bus_message_get_path(m)),
2648                           strna(sd_bus_message_get_interface(m)),
2649                           strna(sd_bus_message_get_member(m)));
2650
2651                 r = sd_bus_reply_method_errorf(
2652                                 m,
2653                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2654                                 "Unknown object '%s'.", m->path);
2655                 if (r < 0)
2656                         return r;
2657         }
2658
2659         return 1;
2660
2661 null_message:
2662         if (r >= 0 && ret)
2663                 *ret = NULL;
2664
2665         return r;
2666 }
2667
2668 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2669         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2670         struct reply_callback *c;
2671         int r;
2672
2673         assert(bus);
2674         assert(bus->state == BUS_CLOSING);
2675
2676         c = ordered_hashmap_first(bus->reply_callbacks);
2677         if (c) {
2678                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2679                 sd_bus_slot *slot;
2680
2681                 /* First, fail all outstanding method calls */
2682                 r = bus_message_new_synthetic_error(
2683                                 bus,
2684                                 c->cookie,
2685                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2686                                 &m);
2687                 if (r < 0)
2688                         return r;
2689
2690                 r = bus_seal_synthetic_message(bus, m);
2691                 if (r < 0)
2692                         return r;
2693
2694                 if (c->timeout != 0) {
2695                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2696                         c->timeout = 0;
2697                 }
2698
2699                 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2700                 c->cookie = 0;
2701
2702                 slot = container_of(c, sd_bus_slot, reply_callback);
2703
2704                 bus->iteration_counter++;
2705
2706                 bus->current_message = m;
2707                 bus->current_slot = sd_bus_slot_ref(slot);
2708                 bus->current_handler = c->callback;
2709                 bus->current_userdata = slot->userdata;
2710                 r = c->callback(m, slot->userdata, &error_buffer);
2711                 bus->current_userdata = NULL;
2712                 bus->current_handler = NULL;
2713                 bus->current_slot = NULL;
2714                 bus->current_message = NULL;
2715
2716                 if (slot->floating) {
2717                         bus_slot_disconnect(slot);
2718                         sd_bus_slot_unref(slot);
2719                 }
2720
2721                 sd_bus_slot_unref(slot);
2722
2723                 return bus_maybe_reply_error(m, r, &error_buffer);
2724         }
2725
2726         /* Then, synthesize a Disconnected message */
2727         r = sd_bus_message_new_signal(
2728                         bus,
2729                         &m,
2730                         "/org/freedesktop/DBus/Local",
2731                         "org.freedesktop.DBus.Local",
2732                         "Disconnected");
2733         if (r < 0)
2734                 return r;
2735
2736         bus_message_set_sender_local(bus, m);
2737
2738         r = bus_seal_synthetic_message(bus, m);
2739         if (r < 0)
2740                 return r;
2741
2742         sd_bus_close(bus);
2743
2744         bus->current_message = m;
2745         bus->iteration_counter++;
2746
2747         r = process_filter(bus, m);
2748         if (r != 0)
2749                 goto finish;
2750
2751         r = process_match(bus, m);
2752         if (r != 0)
2753                 goto finish;
2754
2755         if (ret) {
2756                 *ret = m;
2757                 m = NULL;
2758         }
2759
2760         r = 1;
2761
2762 finish:
2763         bus->current_message = NULL;
2764
2765         return r;
2766 }
2767
2768 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2769         BUS_DONT_DESTROY(bus);
2770         int r;
2771
2772         /* Returns 0 when we didn't do anything. This should cause the
2773          * caller to invoke sd_bus_wait() before returning the next
2774          * time. Returns > 0 when we did something, which possibly
2775          * means *ret is filled in with an unprocessed message. */
2776
2777         assert_return(bus, -EINVAL);
2778         assert_return(!bus_pid_changed(bus), -ECHILD);
2779
2780         /* We don't allow recursively invoking sd_bus_process(). */
2781         assert_return(!bus->current_message, -EBUSY);
2782         assert(!bus->current_slot);
2783
2784         switch (bus->state) {
2785
2786         case BUS_UNSET:
2787                 return -ENOTCONN;
2788
2789         case BUS_CLOSED:
2790                 return -ECONNRESET;
2791
2792         case BUS_OPENING:
2793                 r = bus_socket_process_opening(bus);
2794                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2795                         bus_enter_closing(bus);
2796                         r = 1;
2797                 } else if (r < 0)
2798                         return r;
2799                 if (ret)
2800                         *ret = NULL;
2801                 return r;
2802
2803         case BUS_AUTHENTICATING:
2804                 r = bus_socket_process_authenticating(bus);
2805                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2806                         bus_enter_closing(bus);
2807                         r = 1;
2808                 } else if (r < 0)
2809                         return r;
2810
2811                 if (ret)
2812                         *ret = NULL;
2813
2814                 return r;
2815
2816         case BUS_RUNNING:
2817         case BUS_HELLO:
2818                 r = process_running(bus, hint_priority, priority, ret);
2819                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2820                         bus_enter_closing(bus);
2821                         r = 1;
2822
2823                         if (ret)
2824                                 *ret = NULL;
2825                 }
2826
2827                 return r;
2828
2829         case BUS_CLOSING:
2830                 return process_closing(bus, ret);
2831         }
2832
2833         assert_not_reached("Unknown state");
2834 }
2835
2836 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2837         return bus_process_internal(bus, false, 0, ret);
2838 }
2839
2840 /// UNNEEDED by elogind
2841 #if 0
2842 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2843         return bus_process_internal(bus, true, priority, ret);
2844 }
2845 #endif // 0
2846
2847 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2848         struct pollfd p[2] = {};
2849         int r, e, n;
2850         struct timespec ts;
2851         usec_t m = USEC_INFINITY;
2852
2853         assert(bus);
2854
2855         if (bus->state == BUS_CLOSING)
2856                 return 1;
2857
2858         if (!BUS_IS_OPEN(bus->state))
2859                 return -ENOTCONN;
2860
2861         e = sd_bus_get_events(bus);
2862         if (e < 0)
2863                 return e;
2864
2865         if (need_more)
2866                 /* The caller really needs some more data, he doesn't
2867                  * care about what's already read, or any timeouts
2868                  * except its own. */
2869                 e |= POLLIN;
2870         else {
2871                 usec_t until;
2872                 /* The caller wants to process if there's something to
2873                  * process, but doesn't care otherwise */
2874
2875                 r = sd_bus_get_timeout(bus, &until);
2876                 if (r < 0)
2877                         return r;
2878                 if (r > 0) {
2879                         usec_t nw;
2880                         nw = now(CLOCK_MONOTONIC);
2881                         m = until > nw ? until - nw : 0;
2882                 }
2883         }
2884
2885         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2886                 m = timeout_usec;
2887
2888         p[0].fd = bus->input_fd;
2889         if (bus->output_fd == bus->input_fd) {
2890                 p[0].events = e;
2891                 n = 1;
2892         } else {
2893                 p[0].events = e & POLLIN;
2894                 p[1].fd = bus->output_fd;
2895                 p[1].events = e & POLLOUT;
2896                 n = 2;
2897         }
2898
2899         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2900         if (r < 0)
2901                 return -errno;
2902
2903         return r > 0 ? 1 : 0;
2904 }
2905
2906 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2907
2908         assert_return(bus, -EINVAL);
2909         assert_return(!bus_pid_changed(bus), -ECHILD);
2910
2911         if (bus->state == BUS_CLOSING)
2912                 return 0;
2913
2914         if (!BUS_IS_OPEN(bus->state))
2915                 return -ENOTCONN;
2916
2917         if (bus->rqueue_size > 0)
2918                 return 0;
2919
2920         return bus_poll(bus, false, timeout_usec);
2921 }
2922
2923 _public_ int sd_bus_flush(sd_bus *bus) {
2924         int r;
2925
2926         assert_return(bus, -EINVAL);
2927         assert_return(!bus_pid_changed(bus), -ECHILD);
2928
2929         if (bus->state == BUS_CLOSING)
2930                 return 0;
2931
2932         if (!BUS_IS_OPEN(bus->state))
2933                 return -ENOTCONN;
2934
2935         r = bus_ensure_running(bus);
2936         if (r < 0)
2937                 return r;
2938
2939         if (bus->wqueue_size <= 0)
2940                 return 0;
2941
2942         for (;;) {
2943                 r = dispatch_wqueue(bus);
2944                 if (r < 0) {
2945                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2946                                 bus_enter_closing(bus);
2947                                 return -ECONNRESET;
2948                         }
2949
2950                         return r;
2951                 }
2952
2953                 if (bus->wqueue_size <= 0)
2954                         return 0;
2955
2956                 r = bus_poll(bus, false, (uint64_t) -1);
2957                 if (r < 0)
2958                         return r;
2959         }
2960 }
2961
2962 _public_ int sd_bus_add_filter(
2963                 sd_bus *bus,
2964                 sd_bus_slot **slot,
2965                 sd_bus_message_handler_t callback,
2966                 void *userdata) {
2967
2968         sd_bus_slot *s;
2969
2970         assert_return(bus, -EINVAL);
2971         assert_return(callback, -EINVAL);
2972         assert_return(!bus_pid_changed(bus), -ECHILD);
2973
2974         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2975         if (!s)
2976                 return -ENOMEM;
2977
2978         s->filter_callback.callback = callback;
2979
2980         bus->filter_callbacks_modified = true;
2981         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2982
2983         if (slot)
2984                 *slot = s;
2985
2986         return 0;
2987 }
2988
2989 _public_ int sd_bus_add_match(
2990                 sd_bus *bus,
2991                 sd_bus_slot **slot,
2992                 const char *match,
2993                 sd_bus_message_handler_t callback,
2994                 void *userdata) {
2995
2996         struct bus_match_component *components = NULL;
2997         unsigned n_components = 0;
2998         sd_bus_slot *s = NULL;
2999         int r = 0;
3000
3001         assert_return(bus, -EINVAL);
3002         assert_return(match, -EINVAL);
3003         assert_return(!bus_pid_changed(bus), -ECHILD);
3004
3005         r = bus_match_parse(match, &components, &n_components);
3006         if (r < 0)
3007                 goto finish;
3008
3009         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
3010         if (!s) {
3011                 r = -ENOMEM;
3012                 goto finish;
3013         }
3014
3015         s->match_callback.callback = callback;
3016         s->match_callback.cookie = ++bus->match_cookie;
3017
3018         if (bus->bus_client) {
3019                 enum bus_match_scope scope;
3020
3021                 scope = bus_match_get_scope(components, n_components);
3022
3023                 /* Do not install server-side matches for matches
3024                  * against the local service, interface or bus
3025                  * path. */
3026                 if (scope != BUS_MATCH_LOCAL) {
3027
3028                         if (!bus->is_kernel) {
3029                                 /* When this is not a kernel transport, we
3030                                  * store the original match string, so that we
3031                                  * can use it to remove the match again */
3032
3033                                 s->match_callback.match_string = strdup(match);
3034                                 if (!s->match_callback.match_string) {
3035                                         r = -ENOMEM;
3036                                         goto finish;
3037                                 }
3038                         }
3039
3040                         r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3041                         if (r < 0)
3042                                 goto finish;
3043
3044                         s->match_added = true;
3045                 }
3046         }
3047
3048         bus->match_callbacks_modified = true;
3049         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3050         if (r < 0)
3051                 goto finish;
3052
3053         if (slot)
3054                 *slot = s;
3055         s = NULL;
3056
3057 finish:
3058         bus_match_parse_free(components, n_components);
3059         sd_bus_slot_unref(s);
3060
3061         return r;
3062 }
3063
3064 /// UNNEEDED by elogind
3065 #if 0
3066 int bus_remove_match_by_string(
3067                 sd_bus *bus,
3068                 const char *match,
3069                 sd_bus_message_handler_t callback,
3070                 void *userdata) {
3071
3072         struct bus_match_component *components = NULL;
3073         unsigned n_components = 0;
3074         struct match_callback *c;
3075         int r = 0;
3076
3077         assert_return(bus, -EINVAL);
3078         assert_return(match, -EINVAL);
3079         assert_return(!bus_pid_changed(bus), -ECHILD);
3080
3081         r = bus_match_parse(match, &components, &n_components);
3082         if (r < 0)
3083                 goto finish;
3084
3085         r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3086         if (r <= 0)
3087                 goto finish;
3088
3089         sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3090
3091 finish:
3092         bus_match_parse_free(components, n_components);
3093
3094         return r;
3095 }
3096 #endif // 0
3097
3098 bool bus_pid_changed(sd_bus *bus) {
3099         assert(bus);
3100
3101         /* We don't support people creating a bus connection and
3102          * keeping it around over a fork(). Let's complain. */
3103
3104         return bus->original_pid != getpid();
3105 }
3106
3107 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3108         sd_bus *bus = userdata;
3109         int r;
3110
3111         assert(bus);
3112
3113         r = sd_bus_process(bus, NULL);
3114         if (r < 0)
3115                 return r;
3116
3117         return 1;
3118 }
3119
3120 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3121         sd_bus *bus = userdata;
3122         int r;
3123
3124         assert(bus);
3125
3126         r = sd_bus_process(bus, NULL);
3127         if (r < 0)
3128                 return r;
3129
3130         return 1;
3131 }
3132
3133 static int prepare_callback(sd_event_source *s, void *userdata) {
3134         sd_bus *bus = userdata;
3135         int r, e;
3136         usec_t until;
3137
3138         assert(s);
3139         assert(bus);
3140
3141         e = sd_bus_get_events(bus);
3142         if (e < 0)
3143                 return e;
3144
3145         if (bus->output_fd != bus->input_fd) {
3146
3147                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3148                 if (r < 0)
3149                         return r;
3150
3151                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3152                 if (r < 0)
3153                         return r;
3154         } else {
3155                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3156                 if (r < 0)
3157                         return r;
3158         }
3159
3160         r = sd_bus_get_timeout(bus, &until);
3161         if (r < 0)
3162                 return r;
3163         if (r > 0) {
3164                 int j;
3165
3166                 j = sd_event_source_set_time(bus->time_event_source, until);
3167                 if (j < 0)
3168                         return j;
3169         }
3170
3171         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3172         if (r < 0)
3173                 return r;
3174
3175         return 1;
3176 }
3177
3178 static int quit_callback(sd_event_source *event, void *userdata) {
3179         sd_bus *bus = userdata;
3180
3181         assert(event);
3182
3183         sd_bus_flush(bus);
3184         sd_bus_close(bus);
3185
3186         return 1;
3187 }
3188
3189 static int attach_io_events(sd_bus *bus) {
3190         int r;
3191
3192         assert(bus);
3193
3194         if (bus->input_fd < 0)
3195                 return 0;
3196
3197         if (!bus->event)
3198                 return 0;
3199
3200         if (!bus->input_io_event_source) {
3201                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3202                 if (r < 0)
3203                         return r;
3204
3205                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3206                 if (r < 0)
3207                         return r;
3208
3209                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3210                 if (r < 0)
3211                         return r;
3212
3213                 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3214         } else
3215                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3216
3217         if (r < 0)
3218                 return r;
3219
3220         if (bus->output_fd != bus->input_fd) {
3221                 assert(bus->output_fd >= 0);
3222
3223                 if (!bus->output_io_event_source) {
3224                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3225                         if (r < 0)
3226                                 return r;
3227
3228                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3229                         if (r < 0)
3230                                 return r;
3231
3232                         r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3233                 } else
3234                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3235
3236                 if (r < 0)
3237                         return r;
3238         }
3239
3240         return 0;
3241 }
3242
3243 static void detach_io_events(sd_bus *bus) {
3244         assert(bus);
3245
3246         if (bus->input_io_event_source) {
3247                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3248                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3249         }
3250
3251         if (bus->output_io_event_source) {
3252                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3253                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3254         }
3255 }
3256
3257 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3258         int r;
3259
3260         assert_return(bus, -EINVAL);
3261         assert_return(!bus->event, -EBUSY);
3262
3263         assert(!bus->input_io_event_source);
3264         assert(!bus->output_io_event_source);
3265         assert(!bus->time_event_source);
3266
3267         if (event)
3268                 bus->event = sd_event_ref(event);
3269         else  {
3270                 r = sd_event_default(&bus->event);
3271                 if (r < 0)
3272                         return r;
3273         }
3274
3275         bus->event_priority = priority;
3276
3277         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3278         if (r < 0)
3279                 goto fail;
3280
3281         r = sd_event_source_set_priority(bus->time_event_source, priority);
3282         if (r < 0)
3283                 goto fail;
3284
3285         r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3286         if (r < 0)
3287                 goto fail;
3288
3289         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3290         if (r < 0)
3291                 goto fail;
3292
3293         r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3294         if (r < 0)
3295                 goto fail;
3296
3297         r = attach_io_events(bus);
3298         if (r < 0)
3299                 goto fail;
3300
3301         return 0;
3302
3303 fail:
3304         sd_bus_detach_event(bus);
3305         return r;
3306 }
3307
3308 _public_ int sd_bus_detach_event(sd_bus *bus) {
3309         assert_return(bus, -EINVAL);
3310
3311         if (!bus->event)
3312                 return 0;
3313
3314         detach_io_events(bus);
3315
3316         if (bus->time_event_source) {
3317                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3318                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3319         }
3320
3321         if (bus->quit_event_source) {
3322                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3323                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3324         }
3325
3326         bus->event = sd_event_unref(bus->event);
3327         return 1;
3328 }
3329
3330 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3331         assert_return(bus, NULL);
3332
3333         return bus->event;
3334 }
3335
3336 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3337         assert_return(bus, NULL);
3338
3339         return bus->current_message;
3340 }
3341
3342 /// UNNEEDED by elogind
3343 #if 0
3344 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3345         assert_return(bus, NULL);
3346
3347         return bus->current_slot;
3348 }
3349 #endif // 0
3350
3351 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3352         assert_return(bus, NULL);
3353
3354         return bus->current_handler;
3355 }
3356
3357 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3358         assert_return(bus, NULL);
3359
3360         return bus->current_userdata;
3361 }
3362
3363 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3364         sd_bus *b = NULL;
3365         int r;
3366
3367         assert(bus_open);
3368         assert(default_bus);
3369
3370         if (!ret)
3371                 return !!*default_bus;
3372
3373         if (*default_bus) {
3374                 *ret = sd_bus_ref(*default_bus);
3375                 return 0;
3376         }
3377
3378         r = bus_open(&b);
3379         if (r < 0)
3380                 return r;
3381
3382         b->default_bus_ptr = default_bus;
3383         b->tid = gettid();
3384         *default_bus = b;
3385
3386         *ret = b;
3387         return 1;
3388 }
3389
3390 _public_ int sd_bus_default_system(sd_bus **ret) {
3391         static thread_local sd_bus *default_system_bus = NULL;
3392
3393         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3394 }
3395
3396 _public_ int sd_bus_default_user(sd_bus **ret) {
3397 /// elogind does not support user buses
3398 #if 0
3399         static thread_local sd_bus *default_user_bus = NULL;
3400
3401         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3402 #else
3403         return sd_bus_default_system(ret);
3404 #endif // 0
3405 }
3406
3407 _public_ int sd_bus_default(sd_bus **ret) {
3408
3409         const char *e;
3410
3411         /* Let's try our best to reuse another cached connection. If
3412          * the starter bus type is set, connect via our normal
3413          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3414          * we can share the connection with the user/system default
3415          * bus. */
3416
3417         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3418         if (e) {
3419                 if (streq(e, "system"))
3420                         return sd_bus_default_system(ret);
3421 /// elogind does not support systemd units
3422 #if 0
3423                 else if (STR_IN_SET(e, "user", "session"))
3424                         return sd_bus_default_user(ret);
3425 #endif // 0
3426         }
3427
3428         /* No type is specified, so we have not other option than to
3429          * use the starter address if it is set. */
3430
3431         e = secure_getenv("DBUS_STARTER_ADDRESS");
3432         if (e) {
3433                 static thread_local sd_bus *default_starter_bus = NULL;
3434
3435                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3436         }
3437
3438         /* Finally, if nothing is set use the cached connection for
3439          * the right scope */
3440 /// elogind does not support systemd units
3441 #if 0
3442         if (cg_pid_get_owner_uid(0, NULL) >= 0)
3443                 return sd_bus_default_user(ret);
3444         else
3445 #endif // 0
3446         return sd_bus_default_system(ret);
3447 }
3448
3449 /// UNNEEDED by elogind
3450 #if 0
3451 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3452         assert_return(b, -EINVAL);
3453         assert_return(tid, -EINVAL);
3454         assert_return(!bus_pid_changed(b), -ECHILD);
3455
3456         if (b->tid != 0) {
3457                 *tid = b->tid;
3458                 return 0;
3459         }
3460
3461         if (b->event)
3462                 return sd_event_get_tid(b->event, tid);
3463
3464         return -ENXIO;
3465 }
3466
3467 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3468         _cleanup_free_ char *e = NULL;
3469         char *ret;
3470
3471         assert_return(object_path_is_valid(prefix), -EINVAL);
3472         assert_return(external_id, -EINVAL);
3473         assert_return(ret_path, -EINVAL);
3474
3475         e = bus_label_escape(external_id);
3476         if (!e)
3477                 return -ENOMEM;
3478
3479         ret = strjoin(prefix, "/", e, NULL);
3480         if (!ret)
3481                 return -ENOMEM;
3482
3483         *ret_path = ret;
3484         return 0;
3485 }
3486
3487 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3488         const char *e;
3489         char *ret;
3490
3491         assert_return(object_path_is_valid(path), -EINVAL);
3492         assert_return(object_path_is_valid(prefix), -EINVAL);
3493         assert_return(external_id, -EINVAL);
3494
3495         e = object_path_startswith(path, prefix);
3496         if (!e) {
3497                 *external_id = NULL;
3498                 return 0;
3499         }
3500
3501         ret = bus_label_unescape(e);
3502         if (!ret)
3503                 return -ENOMEM;
3504
3505         *external_id = ret;
3506         return 1;
3507 }
3508 #endif // 0
3509
3510 _public_ int sd_bus_try_close(sd_bus *bus) {
3511         int r;
3512
3513         assert_return(bus, -EINVAL);
3514         assert_return(!bus_pid_changed(bus), -ECHILD);
3515
3516         if (!bus->is_kernel)
3517                 return -EOPNOTSUPP;
3518
3519         if (!BUS_IS_OPEN(bus->state))
3520                 return -ENOTCONN;
3521
3522         if (bus->rqueue_size > 0)
3523                 return -EBUSY;
3524
3525         if (bus->wqueue_size > 0)
3526                 return -EBUSY;
3527
3528         r = bus_kernel_try_close(bus);
3529         if (r < 0)
3530                 return r;
3531
3532         sd_bus_close(bus);
3533         return 0;
3534 }
3535
3536 /// UNNEEDED by elogind
3537 #if 0
3538 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3539         assert_return(bus, -EINVAL);
3540         assert_return(description, -EINVAL);
3541         assert_return(bus->description, -ENXIO);
3542         assert_return(!bus_pid_changed(bus), -ECHILD);
3543
3544         *description = bus->description;
3545         return 0;
3546 }
3547 #endif // 0
3548
3549 int bus_get_root_path(sd_bus *bus) {
3550         int r;
3551
3552         if (bus->cgroup_root)
3553                 return 0;
3554
3555         r = cg_get_root_path(&bus->cgroup_root);
3556         if (r == -ENOENT) {
3557                 bus->cgroup_root = strdup("/");
3558                 if (!bus->cgroup_root)
3559                         return -ENOMEM;
3560
3561                 r = 0;
3562         }
3563
3564         return r;
3565 }
3566
3567 /// UNNEEDED by elogind
3568 #if 0
3569 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3570         int r;
3571
3572         assert_return(bus, -EINVAL);
3573         assert_return(scope, -EINVAL);
3574         assert_return(!bus_pid_changed(bus), -ECHILD);
3575
3576         if (bus->is_kernel) {
3577                 _cleanup_free_ char *n = NULL;
3578                 const char *dash;
3579
3580                 r = bus_kernel_get_bus_name(bus, &n);
3581                 if (r < 0)
3582                         return r;
3583
3584                 if (streq(n, "0-system")) {
3585                         *scope = "system";
3586                         return 0;
3587                 }
3588
3589                 dash = strchr(n, '-');
3590                 if (streq_ptr(dash, "-user")) {
3591                         *scope = "user";
3592                         return 0;
3593                 }
3594         }
3595
3596         if (bus->is_user) {
3597                 *scope = "user";
3598                 return 0;
3599         }
3600
3601         if (bus->is_system) {
3602                 *scope = "system";
3603                 return 0;
3604         }
3605
3606         return -ENODATA;
3607 }
3608
3609 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3610
3611         assert_return(bus, -EINVAL);
3612         assert_return(address, -EINVAL);
3613         assert_return(!bus_pid_changed(bus), -ECHILD);
3614
3615         if (bus->address) {
3616                 *address = bus->address;
3617                 return 0;
3618         }
3619
3620         return -ENODATA;
3621 }
3622
3623 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3624         assert_return(bus, -EINVAL);
3625         assert_return(mask, -EINVAL);
3626         assert_return(!bus_pid_changed(bus), -ECHILD);
3627
3628         *mask = bus->creds_mask;
3629         return 0;
3630 }
3631
3632 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3633         assert_return(bus, -EINVAL);
3634         assert_return(!bus_pid_changed(bus), -ECHILD);
3635
3636         return bus->bus_client;
3637 }
3638
3639 _public_ int sd_bus_is_server(sd_bus *bus) {
3640         assert_return(bus, -EINVAL);
3641         assert_return(!bus_pid_changed(bus), -ECHILD);
3642
3643         return bus->is_server;
3644 }
3645
3646 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3647         assert_return(bus, -EINVAL);
3648         assert_return(!bus_pid_changed(bus), -ECHILD);
3649
3650         return bus->anonymous_auth;
3651 }
3652
3653 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3654         assert_return(bus, -EINVAL);
3655         assert_return(!bus_pid_changed(bus), -ECHILD);
3656
3657         return bus->trusted;
3658 }
3659
3660 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3661         assert_return(bus, -EINVAL);
3662         assert_return(!bus_pid_changed(bus), -ECHILD);
3663
3664         return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3665 }
3666 #endif // 0