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

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