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