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

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