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