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

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