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