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                 else if ((b->nspid > 0 || b->machine) && b->kernel) {
1038                         r = bus_container_connect_kernel(b);
1039                         if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1040                                 container_kdbus_available = true;
1041                 } else if (!container_kdbus_available && (b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC)
1042                         r = bus_container_connect_socket(b);
1043                 else if (b->kernel) {
1044                         r = bus_kernel_connect(b);
1045                         if (r < 0 && !IN_SET(r, -ENOENT, -ESOCKTNOSUPPORT))
1046                                 kdbus_available = true;
1047                 } else if (!kdbus_available && b->sockaddr.sa.sa_family != AF_UNSPEC)
1048                         r = bus_socket_connect(b);
1049                 else
1050                         skipped = true;
1051
1052                 if (!skipped) {
1053                         if (r >= 0) {
1054                                 r = attach_io_events(b);
1055                                 if (r >= 0)
1056                                         return r;
1057                         }
1058
1059                         b->last_connect_error = -r;
1060                 }
1061
1062                 r = bus_parse_next_address(b);
1063                 if (r < 0)
1064                         return r;
1065                 if (r == 0)
1066                         return b->last_connect_error ? -b->last_connect_error : -ECONNREFUSED;
1067         }
1068 }
1069
1070 int bus_next_address(sd_bus *b) {
1071         assert(b);
1072
1073         bus_reset_parsed_address(b);
1074         return bus_start_address(b);
1075 }
1076
1077 static int bus_start_fd(sd_bus *b) {
1078         struct stat st;
1079         int r;
1080
1081         assert(b);
1082         assert(b->input_fd >= 0);
1083         assert(b->output_fd >= 0);
1084
1085         r = fd_nonblock(b->input_fd, true);
1086         if (r < 0)
1087                 return r;
1088
1089         r = fd_cloexec(b->input_fd, true);
1090         if (r < 0)
1091                 return r;
1092
1093         if (b->input_fd != b->output_fd) {
1094                 r = fd_nonblock(b->output_fd, true);
1095                 if (r < 0)
1096                         return r;
1097
1098                 r = fd_cloexec(b->output_fd, true);
1099                 if (r < 0)
1100                         return r;
1101         }
1102
1103         if (fstat(b->input_fd, &st) < 0)
1104                 return -errno;
1105
1106         if (S_ISCHR(b->input_fd))
1107                 return bus_kernel_take_fd(b);
1108         else
1109                 return bus_socket_take_fd(b);
1110 }
1111
1112 _public_ int sd_bus_start(sd_bus *bus) {
1113         int r;
1114
1115         assert_return(bus, -EINVAL);
1116         assert_return(bus->state == BUS_UNSET, -EPERM);
1117         assert_return(!bus_pid_changed(bus), -ECHILD);
1118
1119         bus->state = BUS_OPENING;
1120
1121         if (bus->is_server && bus->bus_client)
1122                 return -EINVAL;
1123
1124         if (bus->input_fd >= 0)
1125                 r = bus_start_fd(bus);
1126         else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
1127                 r = bus_start_address(bus);
1128         else
1129                 return -EINVAL;
1130
1131         if (r < 0) {
1132                 sd_bus_close(bus);
1133                 return r;
1134         }
1135
1136         return bus_send_hello(bus);
1137 }
1138
1139 _public_ int sd_bus_open(sd_bus **ret) {
1140         const char *e;
1141         sd_bus *b;
1142         int r;
1143
1144         assert_return(ret, -EINVAL);
1145
1146         /* Let's connect to the starter bus if it is set, and
1147          * otherwise to the bus that is appropropriate for the scope
1148          * we are running in */
1149
1150         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
1151         if (e) {
1152                 if (streq(e, "system"))
1153                         return sd_bus_open_system(ret);
1154                 else if (STR_IN_SET(e, "session", "user"))
1155                         return sd_bus_open_user(ret);
1156         }
1157
1158         e = secure_getenv("DBUS_STARTER_ADDRESS");
1159         if (!e) {
1160                 if (cg_pid_get_owner_uid(0, NULL) >= 0)
1161                         return sd_bus_open_user(ret);
1162                 else
1163                 return sd_bus_open_system(ret);
1164         }
1165
1166         r = sd_bus_new(&b);
1167         if (r < 0)
1168                 return r;
1169
1170         r = sd_bus_set_address(b, e);
1171         if (r < 0)
1172                 goto fail;
1173
1174         b->bus_client = true;
1175
1176         /* We don't know whether the bus is trusted or not, so better
1177          * be safe, and authenticate everything */
1178         b->trusted = false;
1179         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1180         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1181
1182         r = sd_bus_start(b);
1183         if (r < 0)
1184                 goto fail;
1185
1186         *ret = b;
1187         return 0;
1188
1189 fail:
1190         bus_free(b);
1191         return r;
1192 }
1193
1194 int bus_set_address_system(sd_bus *b) {
1195         const char *e;
1196         assert(b);
1197
1198         e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS");
1199         if (e)
1200                 return sd_bus_set_address(b, e);
1201
1202         return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS);
1203 }
1204
1205 _public_ int sd_bus_open_system(sd_bus **ret) {
1206         sd_bus *b;
1207         int r;
1208
1209         assert_return(ret, -EINVAL);
1210
1211         r = sd_bus_new(&b);
1212         if (r < 0)
1213                 return r;
1214
1215         r = bus_set_address_system(b);
1216         if (r < 0)
1217                 goto fail;
1218
1219         b->bus_client = true;
1220         b->is_system = true;
1221
1222         /* Let's do per-method access control on the system bus. We
1223          * need the caller's UID and capability set for that. */
1224         b->trusted = false;
1225         b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS;
1226         b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS;
1227
1228         r = sd_bus_start(b);
1229         if (r < 0)
1230                 goto fail;
1231
1232         *ret = b;
1233         return 0;
1234
1235 fail:
1236         bus_free(b);
1237         return r;
1238 }
1239
1240 int bus_set_address_user(sd_bus *b) {
1241         const char *e;
1242
1243         assert(b);
1244
1245         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
1246         if (e)
1247                 return sd_bus_set_address(b, e);
1248
1249         e = secure_getenv("XDG_RUNTIME_DIR");
1250         if (e) {
1251                 _cleanup_free_ char *ee = NULL;
1252
1253                 ee = bus_address_escape(e);
1254                 if (!ee)
1255                         return -ENOMEM;
1256
1257                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee);
1258         } else
1259                 (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());
1260
1261         if (!b->address)
1262                 return -ENOMEM;
1263
1264         return 0;
1265 }
1266
1267 _public_ int sd_bus_open_user(sd_bus **ret) {
1268         sd_bus *b;
1269         int r;
1270
1271         assert_return(ret, -EINVAL);
1272
1273         r = sd_bus_new(&b);
1274         if (r < 0)
1275                 return r;
1276
1277         r = bus_set_address_user(b);
1278         if (r < 0)
1279                 return r;
1280
1281         b->bus_client = true;
1282         b->is_user = true;
1283
1284         /* We don't do any per-method access control on the user
1285          * bus. */
1286         b->trusted = true;
1287
1288         r = sd_bus_start(b);
1289         if (r < 0)
1290                 goto fail;
1291
1292         *ret = b;
1293         return 0;
1294
1295 fail:
1296         bus_free(b);
1297         return r;
1298 }
1299
1300 int bus_set_address_system_remote(sd_bus *b, const char *host) {
1301         _cleanup_free_ char *e = NULL;
1302         char *m = NULL, *c = NULL;
1303
1304         assert(b);
1305         assert(host);
1306
1307         /* Let's see if we shall enter some container */
1308         m = strchr(host, ':');
1309         if (m) {
1310                 m++;
1311
1312                 /* Let's make sure this is not a port of some kind,
1313                  * and is a valid machine name. */
1314                 if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) {
1315                         char *t;
1316
1317                         /* Cut out the host part */
1318                         t = strndupa(host, m - host - 1);
1319                         e = bus_address_escape(t);
1320                         if (!e)
1321                                 return -ENOMEM;
1322
1323                         c = strjoina(",argv4=--machine=", m);
1324                 }
1325         }
1326
1327         if (!e) {
1328                 e = bus_address_escape(host);
1329                 if (!e)
1330                         return -ENOMEM;
1331         }
1332
1333         b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
1334         if (!b->address)
1335                 return -ENOMEM;
1336
1337         return 0;
1338  }
1339
1340 _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) {
1341         sd_bus *bus;
1342         int r;
1343
1344         assert_return(host, -EINVAL);
1345         assert_return(ret, -EINVAL);
1346
1347         r = sd_bus_new(&bus);
1348         if (r < 0)
1349                 return r;
1350
1351         r = bus_set_address_system_remote(bus, host);
1352         if (r < 0)
1353                 goto fail;
1354
1355         bus->bus_client = true;
1356         bus->trusted = false;
1357         bus->is_system = true;
1358
1359         r = sd_bus_start(bus);
1360         if (r < 0)
1361                 goto fail;
1362
1363         *ret = bus;
1364         return 0;
1365
1366 fail:
1367         bus_free(bus);
1368         return r;
1369 }
1370
1371 int bus_set_address_system_machine(sd_bus *b, const char *machine) {
1372         _cleanup_free_ char *e = NULL;
1373
1374         assert(b);
1375         assert(machine);
1376
1377         e = bus_address_escape(machine);
1378         if (!e)
1379                 return -ENOMEM;
1380
1381         b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
1382         if (!b->address)
1383                 return -ENOMEM;
1384
1385         return 0;
1386 }
1387
1388 _public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) {
1389         sd_bus *bus;
1390         int r;
1391
1392         assert_return(machine, -EINVAL);
1393         assert_return(ret, -EINVAL);
1394         assert_return(machine_name_is_valid(machine), -EINVAL);
1395
1396         r = sd_bus_new(&bus);
1397         if (r < 0)
1398                 return r;
1399
1400         r = bus_set_address_system_machine(bus, machine);
1401         if (r < 0)
1402                 goto fail;
1403
1404         bus->bus_client = true;
1405         bus->trusted = false;
1406         bus->is_system = true;
1407
1408         r = sd_bus_start(bus);
1409         if (r < 0)
1410                 goto fail;
1411
1412         *ret = bus;
1413         return 0;
1414
1415 fail:
1416         bus_free(bus);
1417         return r;
1418 }
1419
1420 _public_ void sd_bus_close(sd_bus *bus) {
1421
1422         if (!bus)
1423                 return;
1424         if (bus->state == BUS_CLOSED)
1425                 return;
1426         if (bus_pid_changed(bus))
1427                 return;
1428
1429         bus->state = BUS_CLOSED;
1430
1431         sd_bus_detach_event(bus);
1432
1433         /* Drop all queued messages so that they drop references to
1434          * the bus object and the bus may be freed */
1435         bus_reset_queues(bus);
1436
1437         if (!bus->is_kernel)
1438                 bus_close_fds(bus);
1439
1440         /* We'll leave the fd open in case this is a kernel bus, since
1441          * there might still be memblocks around that reference this
1442          * bus, and they might need to invoke the KDBUS_CMD_FREE
1443          * ioctl on the fd when they are freed. */
1444 }
1445
1446 _public_ sd_bus* sd_bus_flush_close_unref(sd_bus *bus) {
1447
1448         if (!bus)
1449                 return NULL;
1450
1451         sd_bus_flush(bus);
1452         sd_bus_close(bus);
1453
1454         return sd_bus_unref(bus);
1455 }
1456
1457 static void bus_enter_closing(sd_bus *bus) {
1458         assert(bus);
1459
1460         if (bus->state != BUS_OPENING &&
1461             bus->state != BUS_AUTHENTICATING &&
1462             bus->state != BUS_HELLO &&
1463             bus->state != BUS_RUNNING)
1464                 return;
1465
1466         bus->state = BUS_CLOSING;
1467 }
1468
1469 _public_ sd_bus *sd_bus_ref(sd_bus *bus) {
1470         assert_return(bus, NULL);
1471
1472         assert_se(REFCNT_INC(bus->n_ref) >= 2);
1473
1474         return bus;
1475 }
1476
1477 _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
1478         unsigned i;
1479
1480         if (!bus)
1481                 return NULL;
1482
1483         i = REFCNT_DEC(bus->n_ref);
1484         if (i > 0)
1485                 return NULL;
1486
1487         bus_free(bus);
1488         return NULL;
1489 }
1490
1491 /// UNNEEDED by elogind
1492 #if 0
1493 _public_ int sd_bus_is_open(sd_bus *bus) {
1494
1495         assert_return(bus, -EINVAL);
1496         assert_return(!bus_pid_changed(bus), -ECHILD);
1497
1498         return BUS_IS_OPEN(bus->state);
1499 }
1500 #endif // 0
1501
1502 _public_ int sd_bus_can_send(sd_bus *bus, char type) {
1503         int r;
1504
1505         assert_return(bus, -EINVAL);
1506         assert_return(bus->state != BUS_UNSET, -ENOTCONN);
1507         assert_return(!bus_pid_changed(bus), -ECHILD);
1508
1509         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
1510                 return 0;
1511
1512         if (type == SD_BUS_TYPE_UNIX_FD) {
1513                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
1514                         return 0;
1515
1516                 r = bus_ensure_running(bus);
1517                 if (r < 0)
1518                         return r;
1519
1520                 return bus->can_fds;
1521         }
1522
1523         return bus_type_is_valid(type);
1524 }
1525
1526 /// UNNEEDED by elogind
1527 #if 0
1528 _public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) {
1529         int r;
1530
1531         assert_return(bus, -EINVAL);
1532         assert_return(id, -EINVAL);
1533         assert_return(!bus_pid_changed(bus), -ECHILD);
1534
1535         r = bus_ensure_running(bus);
1536         if (r < 0)
1537                 return r;
1538
1539         *id = bus->server_id;
1540         return 0;
1541 }
1542 #endif // 0
1543
1544 static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) {
1545         assert(b);
1546         assert(m);
1547
1548         if (m->sealed) {
1549                 /* If we copy the same message to multiple
1550                  * destinations, avoid using the same cookie
1551                  * numbers. */
1552                 b->cookie = MAX(b->cookie, BUS_MESSAGE_COOKIE(m));
1553                 return 0;
1554         }
1555
1556         if (timeout == 0)
1557                 timeout = BUS_DEFAULT_TIMEOUT;
1558
1559         return bus_message_seal(m, ++b->cookie, timeout);
1560 }
1561
1562 static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) {
1563         bool remarshal = false;
1564
1565         assert(b);
1566
1567         /* wrong packet version */
1568         if (b->message_version != 0 && b->message_version != (*m)->header->version)
1569                 remarshal = true;
1570
1571         /* wrong packet endianness */
1572         if (b->message_endian != 0 && b->message_endian != (*m)->header->endian)
1573                 remarshal = true;
1574
1575         /* TODO: kdbus-messages received from the kernel contain data which is
1576          * not allowed to be passed to KDBUS_CMD_SEND. Therefore, we have to
1577          * force remarshaling of the message. Technically, we could just
1578          * recreate the kdbus message, but that is non-trivial as other parts of
1579          * the message refer to m->kdbus already. This should be fixed! */
1580         if ((*m)->kdbus && (*m)->release_kdbus)
1581                 remarshal = true;
1582
1583         return remarshal ? bus_message_remarshal(b, m) : 0;
1584 }
1585
1586 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
1587         assert(b);
1588         assert(m);
1589
1590         /* Fake some timestamps, if they were requested, and not
1591          * already initialized */
1592         if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) {
1593                 if (m->realtime <= 0)
1594                         m->realtime = now(CLOCK_REALTIME);
1595
1596                 if (m->monotonic <= 0)
1597                         m->monotonic = now(CLOCK_MONOTONIC);
1598         }
1599
1600         /* The bus specification says the serial number cannot be 0,
1601          * hence let's fill something in for synthetic messages. Since
1602          * synthetic messages might have a fake sender and we don't
1603          * want to interfere with the real sender's serial numbers we
1604          * pick a fixed, artificial one. We use (uint32_t) -1 rather
1605          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
1606          * even though kdbus can do 64bit. */
1607         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
1608 }
1609
1610 static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call, size_t *idx) {
1611         int r;
1612
1613         assert(bus);
1614         assert(m);
1615
1616         if (bus->is_kernel)
1617                 r = bus_kernel_write_message(bus, m, hint_sync_call);
1618         else
1619                 r = bus_socket_write_message(bus, m, idx);
1620
1621         if (r <= 0)
1622                 return r;
1623
1624         if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m))
1625                 log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s",
1626                           bus_message_type_to_string(m->header->type),
1627                           strna(sd_bus_message_get_sender(m)),
1628                           strna(sd_bus_message_get_destination(m)),
1629                           strna(sd_bus_message_get_path(m)),
1630                           strna(sd_bus_message_get_interface(m)),
1631                           strna(sd_bus_message_get_member(m)),
1632                           BUS_MESSAGE_COOKIE(m),
1633                           m->reply_cookie,
1634                           strna(m->error.message));
1635
1636         return r;
1637 }
1638
1639 static int dispatch_wqueue(sd_bus *bus) {
1640         int r, ret = 0;
1641
1642         assert(bus);
1643         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1644
1645         while (bus->wqueue_size > 0) {
1646
1647                 r = bus_write_message(bus, bus->wqueue[0], false, &bus->windex);
1648                 if (r < 0)
1649                         return r;
1650                 else if (r == 0)
1651                         /* Didn't do anything this time */
1652                         return ret;
1653                 else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
1654                         /* Fully written. Let's drop the entry from
1655                          * the queue.
1656                          *
1657                          * This isn't particularly optimized, but
1658                          * well, this is supposed to be our worst-case
1659                          * buffer only, and the socket buffer is
1660                          * supposed to be our primary buffer, and if
1661                          * it got full, then all bets are off
1662                          * anyway. */
1663
1664                         bus->wqueue_size --;
1665                         sd_bus_message_unref(bus->wqueue[0]);
1666                         memmove(bus->wqueue, bus->wqueue + 1, sizeof(sd_bus_message*) * bus->wqueue_size);
1667                         bus->windex = 0;
1668
1669                         ret = 1;
1670                 }
1671         }
1672
1673         return ret;
1674 }
1675
1676 static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1677         assert(bus);
1678
1679         if (bus->is_kernel)
1680                 return bus_kernel_read_message(bus, hint_priority, priority);
1681         else
1682                 return bus_socket_read_message(bus);
1683 }
1684
1685 int bus_rqueue_make_room(sd_bus *bus) {
1686         assert(bus);
1687
1688         if (bus->rqueue_size >= BUS_RQUEUE_MAX)
1689                 return -ENOBUFS;
1690
1691         if (!GREEDY_REALLOC(bus->rqueue, bus->rqueue_allocated, bus->rqueue_size + 1))
1692                 return -ENOMEM;
1693
1694         return 0;
1695 }
1696
1697 static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) {
1698         int r, ret = 0;
1699
1700         assert(bus);
1701         assert(m);
1702         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
1703
1704         /* Note that the priority logic is only available on kdbus,
1705          * where the rqueue is unused. We check the rqueue here
1706          * anyway, because it's simple... */
1707
1708         for (;;) {
1709                 if (bus->rqueue_size > 0) {
1710                         /* Dispatch a queued message */
1711
1712                         *m = bus->rqueue[0];
1713                         bus->rqueue_size --;
1714                         memmove(bus->rqueue, bus->rqueue + 1, sizeof(sd_bus_message*) * bus->rqueue_size);
1715                         return 1;
1716                 }
1717
1718                 /* Try to read a new message */
1719                 r = bus_read_message(bus, hint_priority, priority);
1720                 if (r < 0)
1721                         return r;
1722                 if (r == 0)
1723                         return ret;
1724
1725                 ret = 1;
1726         }
1727 }
1728
1729 static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, bool hint_sync_call) {
1730         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1731         int r;
1732
1733         assert_return(m, -EINVAL);
1734
1735         if (!bus)
1736                 bus = m->bus;
1737
1738         assert_return(!bus_pid_changed(bus), -ECHILD);
1739         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1740
1741         if (!BUS_IS_OPEN(bus->state))
1742                 return -ENOTCONN;
1743
1744         if (m->n_fds > 0) {
1745                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
1746                 if (r < 0)
1747                         return r;
1748                 if (r == 0)
1749                         return -EOPNOTSUPP;
1750         }
1751
1752         /* If the cookie number isn't kept, then we know that no reply
1753          * is expected */
1754         if (!cookie && !m->sealed)
1755                 m->header->flags |= BUS_MESSAGE_NO_REPLY_EXPECTED;
1756
1757         r = bus_seal_message(bus, m, 0);
1758         if (r < 0)
1759                 return r;
1760
1761         /* Remarshall if we have to. This will possibly unref the
1762          * message and place a replacement in m */
1763         r = bus_remarshal_message(bus, &m);
1764         if (r < 0)
1765                 return r;
1766
1767         /* If this is a reply and no reply was requested, then let's
1768          * suppress this, if we can */
1769         if (m->dont_send)
1770                 goto finish;
1771
1772         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
1773                 size_t idx = 0;
1774
1775                 r = bus_write_message(bus, m, hint_sync_call, &idx);
1776                 if (r < 0) {
1777                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
1778                                 bus_enter_closing(bus);
1779                                 return -ECONNRESET;
1780                         }
1781
1782                         return r;
1783                 }
1784
1785                 if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
1786                         /* Wasn't fully written. So let's remember how
1787                          * much was written. Note that the first entry
1788                          * of the wqueue array is always allocated so
1789                          * that we always can remember how much was
1790                          * written. */
1791                         bus->wqueue[0] = sd_bus_message_ref(m);
1792                         bus->wqueue_size = 1;
1793                         bus->windex = idx;
1794                 }
1795
1796         } else {
1797                 /* Just append it to the queue. */
1798
1799                 if (bus->wqueue_size >= BUS_WQUEUE_MAX)
1800                         return -ENOBUFS;
1801
1802                 if (!GREEDY_REALLOC(bus->wqueue, bus->wqueue_allocated, bus->wqueue_size + 1))
1803                         return -ENOMEM;
1804
1805                 bus->wqueue[bus->wqueue_size ++] = sd_bus_message_ref(m);
1806         }
1807
1808 finish:
1809         if (cookie)
1810                 *cookie = BUS_MESSAGE_COOKIE(m);
1811
1812         return 1;
1813 }
1814
1815 _public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie) {
1816         return bus_send_internal(bus, m, cookie, false);
1817 }
1818
1819 _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie) {
1820         int r;
1821
1822         assert_return(m, -EINVAL);
1823
1824         if (!bus)
1825                 bus = m->bus;
1826
1827         assert_return(!bus_pid_changed(bus), -ECHILD);
1828
1829         if (!BUS_IS_OPEN(bus->state))
1830                 return -ENOTCONN;
1831
1832         if (!streq_ptr(m->destination, destination)) {
1833
1834                 if (!destination)
1835                         return -EEXIST;
1836
1837                 r = sd_bus_message_set_destination(m, destination);
1838                 if (r < 0)
1839                         return r;
1840         }
1841
1842         return sd_bus_send(bus, m, cookie);
1843 }
1844
1845 static usec_t calc_elapse(uint64_t usec) {
1846         if (usec == (uint64_t) -1)
1847                 return 0;
1848
1849         return now(CLOCK_MONOTONIC) + usec;
1850 }
1851
1852 static int timeout_compare(const void *a, const void *b) {
1853         const struct reply_callback *x = a, *y = b;
1854
1855         if (x->timeout != 0 && y->timeout == 0)
1856                 return -1;
1857
1858         if (x->timeout == 0 && y->timeout != 0)
1859                 return 1;
1860
1861         if (x->timeout < y->timeout)
1862                 return -1;
1863
1864         if (x->timeout > y->timeout)
1865                 return 1;
1866
1867         return 0;
1868 }
1869
1870 _public_ int sd_bus_call_async(
1871                 sd_bus *bus,
1872                 sd_bus_slot **slot,
1873                 sd_bus_message *_m,
1874                 sd_bus_message_handler_t callback,
1875                 void *userdata,
1876                 uint64_t usec) {
1877
1878         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1879         _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL;
1880         int r;
1881
1882         assert_return(m, -EINVAL);
1883         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
1884         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
1885         assert_return(callback, -EINVAL);
1886
1887         if (!bus)
1888                 bus = m->bus;
1889
1890         assert_return(!bus_pid_changed(bus), -ECHILD);
1891         assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
1892
1893         if (!BUS_IS_OPEN(bus->state))
1894                 return -ENOTCONN;
1895
1896         r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops);
1897         if (r < 0)
1898                 return r;
1899
1900         r = prioq_ensure_allocated(&bus->reply_callbacks_prioq, timeout_compare);
1901         if (r < 0)
1902                 return r;
1903
1904         r = bus_seal_message(bus, m, usec);
1905         if (r < 0)
1906                 return r;
1907
1908         r = bus_remarshal_message(bus, &m);
1909         if (r < 0)
1910                 return r;
1911
1912         s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata);
1913         if (!s)
1914                 return -ENOMEM;
1915
1916         s->reply_callback.callback = callback;
1917
1918         s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m);
1919         r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback);
1920         if (r < 0) {
1921                 s->reply_callback.cookie = 0;
1922                 return r;
1923         }
1924
1925         s->reply_callback.timeout = calc_elapse(m->timeout);
1926         if (s->reply_callback.timeout != 0) {
1927                 r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx);
1928                 if (r < 0) {
1929                         s->reply_callback.timeout = 0;
1930                         return r;
1931                 }
1932         }
1933
1934         r = sd_bus_send(bus, m, &s->reply_callback.cookie);
1935         if (r < 0)
1936                 return r;
1937
1938         if (slot)
1939                 *slot = s;
1940         s = NULL;
1941
1942         return r;
1943 }
1944
1945 int bus_ensure_running(sd_bus *bus) {
1946         int r;
1947
1948         assert(bus);
1949
1950         if (bus->state == BUS_UNSET || bus->state == BUS_CLOSED || bus->state == BUS_CLOSING)
1951                 return -ENOTCONN;
1952         if (bus->state == BUS_RUNNING)
1953                 return 1;
1954
1955         for (;;) {
1956                 r = sd_bus_process(bus, NULL);
1957                 if (r < 0)
1958                         return r;
1959                 if (bus->state == BUS_RUNNING)
1960                         return 1;
1961                 if (r > 0)
1962                         continue;
1963
1964                 r = sd_bus_wait(bus, (uint64_t) -1);
1965                 if (r < 0)
1966                         return r;
1967         }
1968 }
1969
1970 _public_ int sd_bus_call(
1971                 sd_bus *bus,
1972                 sd_bus_message *_m,
1973                 uint64_t usec,
1974                 sd_bus_error *error,
1975                 sd_bus_message **reply) {
1976
1977         _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m);
1978         usec_t timeout;
1979         uint64_t cookie;
1980         unsigned i;
1981         int r;
1982
1983         bus_assert_return(m, -EINVAL, error);
1984         bus_assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL, error);
1985         bus_assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL, error);
1986         bus_assert_return(!bus_error_is_dirty(error), -EINVAL, error);
1987
1988         if (!bus)
1989                 bus = m->bus;
1990
1991         bus_assert_return(!bus_pid_changed(bus), -ECHILD, error);
1992         bus_assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS, error);
1993
1994         if (!BUS_IS_OPEN(bus->state)) {
1995                 r = -ENOTCONN;
1996                 goto fail;
1997         }
1998
1999         r = bus_ensure_running(bus);
2000         if (r < 0)
2001                 goto fail;
2002
2003         i = bus->rqueue_size;
2004
2005         r = bus_seal_message(bus, m, usec);
2006         if (r < 0)
2007                 goto fail;
2008
2009         r = bus_remarshal_message(bus, &m);
2010         if (r < 0)
2011                 goto fail;
2012
2013         r = bus_send_internal(bus, m, &cookie, true);
2014         if (r < 0)
2015                 goto fail;
2016
2017         timeout = calc_elapse(m->timeout);
2018
2019         for (;;) {
2020                 usec_t left;
2021
2022                 while (i < bus->rqueue_size) {
2023                         sd_bus_message *incoming = NULL;
2024
2025                         incoming = bus->rqueue[i];
2026
2027                         if (incoming->reply_cookie == cookie) {
2028                                 /* Found a match! */
2029
2030                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2031                                 bus->rqueue_size--;
2032                                 log_debug_bus_message(incoming);
2033
2034                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
2035
2036                                         if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2037                                                 if (reply)
2038                                                         *reply = incoming;
2039                                                 else
2040                                                         sd_bus_message_unref(incoming);
2041
2042                                                 return 1;
2043                                         }
2044
2045                                         r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry.");
2046                                         sd_bus_message_unref(incoming);
2047                                         return r;
2048
2049                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) {
2050                                         r = sd_bus_error_copy(error, &incoming->error);
2051                                 sd_bus_message_unref(incoming);
2052                                 return r;
2053                                 } else {
2054                                         r = -EIO;
2055                                         goto fail;
2056                                 }
2057
2058                         } else if (BUS_MESSAGE_COOKIE(incoming) == cookie &&
2059                                    bus->unique_name &&
2060                                    incoming->sender &&
2061                                    streq(bus->unique_name, incoming->sender)) {
2062
2063                                 memmove(bus->rqueue + i, bus->rqueue + i + 1, sizeof(sd_bus_message*) * (bus->rqueue_size - i - 1));
2064                                 bus->rqueue_size--;
2065
2066                                 /* Our own message? Somebody is trying
2067                                  * to send its own client a message,
2068                                  * let's not dead-lock, let's fail
2069                                  * immediately. */
2070
2071                                 sd_bus_message_unref(incoming);
2072                                 r = -ELOOP;
2073                                 goto fail;
2074                         }
2075
2076                         /* Try to read more, right-away */
2077                         i++;
2078                 }
2079
2080                 r = bus_read_message(bus, false, 0);
2081                 if (r < 0) {
2082                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2083                                 bus_enter_closing(bus);
2084                                 r = -ECONNRESET;
2085                         }
2086
2087                         goto fail;
2088                 }
2089                 if (r > 0)
2090                         continue;
2091
2092                 if (timeout > 0) {
2093                         usec_t n;
2094
2095                         n = now(CLOCK_MONOTONIC);
2096                         if (n >= timeout) {
2097                                 r = -ETIMEDOUT;
2098                                 goto fail;
2099                         }
2100
2101                         left = timeout - n;
2102                 } else
2103                         left = (uint64_t) -1;
2104
2105                 r = bus_poll(bus, true, left);
2106                 if (r < 0)
2107                         goto fail;
2108                 if (r == 0) {
2109                         r = -ETIMEDOUT;
2110                         goto fail;
2111                 }
2112
2113                 r = dispatch_wqueue(bus);
2114                 if (r < 0) {
2115                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2116                                 bus_enter_closing(bus);
2117                                 r = -ECONNRESET;
2118                         }
2119
2120                         goto fail;
2121                 }
2122         }
2123
2124 fail:
2125         return sd_bus_error_set_errno(error, r);
2126 }
2127
2128 _public_ int sd_bus_get_fd(sd_bus *bus) {
2129
2130         assert_return(bus, -EINVAL);
2131         assert_return(bus->input_fd == bus->output_fd, -EPERM);
2132         assert_return(!bus_pid_changed(bus), -ECHILD);
2133
2134         return bus->input_fd;
2135 }
2136
2137 _public_ int sd_bus_get_events(sd_bus *bus) {
2138         int flags = 0;
2139
2140         assert_return(bus, -EINVAL);
2141         assert_return(!bus_pid_changed(bus), -ECHILD);
2142
2143         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2144                 return -ENOTCONN;
2145
2146         if (bus->state == BUS_OPENING)
2147                 flags |= POLLOUT;
2148         else if (bus->state == BUS_AUTHENTICATING) {
2149
2150                 if (bus_socket_auth_needs_write(bus))
2151                         flags |= POLLOUT;
2152
2153                 flags |= POLLIN;
2154
2155         } else if (bus->state == BUS_RUNNING || bus->state == BUS_HELLO) {
2156                 if (bus->rqueue_size <= 0)
2157                         flags |= POLLIN;
2158                 if (bus->wqueue_size > 0)
2159                         flags |= POLLOUT;
2160         }
2161
2162         return flags;
2163 }
2164
2165 _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
2166         struct reply_callback *c;
2167
2168         assert_return(bus, -EINVAL);
2169         assert_return(timeout_usec, -EINVAL);
2170         assert_return(!bus_pid_changed(bus), -ECHILD);
2171
2172         if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
2173                 return -ENOTCONN;
2174
2175         if (bus->track_queue) {
2176                 *timeout_usec = 0;
2177                 return 1;
2178         }
2179
2180         if (bus->state == BUS_CLOSING) {
2181                 *timeout_usec = 0;
2182                 return 1;
2183         }
2184
2185         if (bus->state == BUS_AUTHENTICATING) {
2186                 *timeout_usec = bus->auth_timeout;
2187                 return 1;
2188         }
2189
2190         if (bus->state != BUS_RUNNING && bus->state != BUS_HELLO) {
2191                 *timeout_usec = (uint64_t) -1;
2192                 return 0;
2193         }
2194
2195         if (bus->rqueue_size > 0) {
2196                 *timeout_usec = 0;
2197                 return 1;
2198         }
2199
2200         c = prioq_peek(bus->reply_callbacks_prioq);
2201         if (!c) {
2202                 *timeout_usec = (uint64_t) -1;
2203                 return 0;
2204         }
2205
2206         if (c->timeout == 0) {
2207                 *timeout_usec = (uint64_t) -1;
2208                 return 0;
2209         }
2210
2211         *timeout_usec = c->timeout;
2212         return 1;
2213 }
2214
2215 static int process_timeout(sd_bus *bus) {
2216         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2217         _cleanup_bus_message_unref_ sd_bus_message* m = NULL;
2218         struct reply_callback *c;
2219         sd_bus_slot *slot;
2220         usec_t n;
2221         int r;
2222
2223         assert(bus);
2224
2225         c = prioq_peek(bus->reply_callbacks_prioq);
2226         if (!c)
2227                 return 0;
2228
2229         n = now(CLOCK_MONOTONIC);
2230         if (c->timeout > n)
2231                 return 0;
2232
2233         r = bus_message_new_synthetic_error(
2234                         bus,
2235                         c->cookie,
2236                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out"),
2237                         &m);
2238         if (r < 0)
2239                 return r;
2240
2241         r = bus_seal_synthetic_message(bus, m);
2242         if (r < 0)
2243                 return r;
2244
2245         assert_se(prioq_pop(bus->reply_callbacks_prioq) == c);
2246         c->timeout = 0;
2247
2248         ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2249         c->cookie = 0;
2250
2251         slot = container_of(c, sd_bus_slot, reply_callback);
2252
2253         bus->iteration_counter ++;
2254
2255         bus->current_message = m;
2256         bus->current_slot = sd_bus_slot_ref(slot);
2257         bus->current_handler = c->callback;
2258         bus->current_userdata = slot->userdata;
2259         r = c->callback(m, slot->userdata, &error_buffer);
2260         bus->current_userdata = NULL;
2261         bus->current_handler = NULL;
2262         bus->current_slot = NULL;
2263         bus->current_message = NULL;
2264
2265         if (slot->floating) {
2266                 bus_slot_disconnect(slot);
2267                 sd_bus_slot_unref(slot);
2268         }
2269
2270         sd_bus_slot_unref(slot);
2271
2272         return bus_maybe_reply_error(m, r, &error_buffer);
2273 }
2274
2275 static int process_hello(sd_bus *bus, sd_bus_message *m) {
2276         assert(bus);
2277         assert(m);
2278
2279         if (bus->state != BUS_HELLO)
2280                 return 0;
2281
2282         /* Let's make sure the first message on the bus is the HELLO
2283          * reply. But note that we don't actually parse the message
2284          * here (we leave that to the usual handling), we just verify
2285          * we don't let any earlier msg through. */
2286
2287         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2288             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2289                 return -EIO;
2290
2291         if (m->reply_cookie != 1)
2292                 return -EIO;
2293
2294         return 0;
2295 }
2296
2297 static int process_reply(sd_bus *bus, sd_bus_message *m) {
2298         _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL;
2299         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2300         struct reply_callback *c;
2301         sd_bus_slot *slot;
2302         int r;
2303
2304         assert(bus);
2305         assert(m);
2306
2307         if (m->header->type != SD_BUS_MESSAGE_METHOD_RETURN &&
2308             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
2309                 return 0;
2310
2311         if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR))
2312                 return 0;
2313
2314         if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name))
2315                 return 0;
2316
2317         c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
2318         if (!c)
2319                 return 0;
2320
2321         c->cookie = 0;
2322
2323         slot = container_of(c, sd_bus_slot, reply_callback);
2324
2325         if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) {
2326
2327                 /* If the reply contained a file descriptor which we
2328                  * didn't want we pass an error instead. */
2329
2330                 r = bus_message_new_synthetic_error(
2331                                 bus,
2332                                 m->reply_cookie,
2333                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"),
2334                                 &synthetic_reply);
2335                 if (r < 0)
2336                         return r;
2337
2338                 /* Copy over original timestamp */
2339                 synthetic_reply->realtime = m->realtime;
2340                 synthetic_reply->monotonic = m->monotonic;
2341                 synthetic_reply->seqnum = m->seqnum;
2342
2343                 r = bus_seal_synthetic_message(bus, synthetic_reply);
2344                 if (r < 0)
2345                         return r;
2346
2347                 m = synthetic_reply;
2348         } else {
2349                 r = sd_bus_message_rewind(m, true);
2350                 if (r < 0)
2351                         return r;
2352         }
2353
2354         if (c->timeout != 0) {
2355                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2356                 c->timeout = 0;
2357         }
2358
2359         bus->current_slot = sd_bus_slot_ref(slot);
2360         bus->current_handler = c->callback;
2361         bus->current_userdata = slot->userdata;
2362         r = c->callback(m, slot->userdata, &error_buffer);
2363         bus->current_userdata = NULL;
2364         bus->current_handler = NULL;
2365         bus->current_slot = NULL;
2366
2367         if (slot->floating) {
2368                 bus_slot_disconnect(slot);
2369                 sd_bus_slot_unref(slot);
2370         }
2371
2372         sd_bus_slot_unref(slot);
2373
2374         return bus_maybe_reply_error(m, r, &error_buffer);
2375 }
2376
2377 static int process_filter(sd_bus *bus, sd_bus_message *m) {
2378         _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2379         struct filter_callback *l;
2380         int r;
2381
2382         assert(bus);
2383         assert(m);
2384
2385         do {
2386                 bus->filter_callbacks_modified = false;
2387
2388                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {
2389                         sd_bus_slot *slot;
2390
2391                         if (bus->filter_callbacks_modified)
2392                                 break;
2393
2394                         /* Don't run this more than once per iteration */
2395                         if (l->last_iteration == bus->iteration_counter)
2396                                 continue;
2397
2398                         l->last_iteration = bus->iteration_counter;
2399
2400                         r = sd_bus_message_rewind(m, true);
2401                         if (r < 0)
2402                                 return r;
2403
2404                         slot = container_of(l, sd_bus_slot, filter_callback);
2405
2406                         bus->current_slot = sd_bus_slot_ref(slot);
2407                         bus->current_handler = l->callback;
2408                         bus->current_userdata = slot->userdata;
2409                         r = l->callback(m, slot->userdata, &error_buffer);
2410                         bus->current_userdata = NULL;
2411                         bus->current_handler = NULL;
2412                         bus->current_slot = sd_bus_slot_unref(slot);
2413
2414                         r = bus_maybe_reply_error(m, r, &error_buffer);
2415                         if (r != 0)
2416                                 return r;
2417
2418                 }
2419
2420         } while (bus->filter_callbacks_modified);
2421
2422         return 0;
2423 }
2424
2425 static int process_match(sd_bus *bus, sd_bus_message *m) {
2426         int r;
2427
2428         assert(bus);
2429         assert(m);
2430
2431         do {
2432                 bus->match_callbacks_modified = false;
2433
2434                 r = bus_match_run(bus, &bus->match_callbacks, m);
2435                 if (r != 0)
2436                         return r;
2437
2438         } while (bus->match_callbacks_modified);
2439
2440         return 0;
2441 }
2442
2443 static int process_builtin(sd_bus *bus, sd_bus_message *m) {
2444         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2445         int r;
2446
2447         assert(bus);
2448         assert(m);
2449
2450         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2451                 return 0;
2452
2453         if (bus->manual_peer_interface)
2454                 return 0;
2455
2456         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2457                 return 0;
2458
2459         if (!streq_ptr(m->interface, "org.freedesktop.DBus.Peer"))
2460                 return 0;
2461
2462         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
2463                 return 1;
2464
2465         if (streq_ptr(m->member, "Ping"))
2466                 r = sd_bus_message_new_method_return(m, &reply);
2467         else if (streq_ptr(m->member, "GetMachineId")) {
2468                 sd_id128_t id;
2469                 char sid[33];
2470
2471                 r = sd_id128_get_machine(&id);
2472                 if (r < 0)
2473                         return r;
2474
2475                 r = sd_bus_message_new_method_return(m, &reply);
2476                 if (r < 0)
2477                         return r;
2478
2479                 r = sd_bus_message_append(reply, "s", sd_id128_to_string(id, sid));
2480         } else {
2481                 r = sd_bus_message_new_method_errorf(
2482                                 m, &reply,
2483                                 SD_BUS_ERROR_UNKNOWN_METHOD,
2484                                  "Unknown method '%s' on interface '%s'.", m->member, m->interface);
2485         }
2486
2487         if (r < 0)
2488                 return r;
2489
2490         r = sd_bus_send(bus, reply, NULL);
2491         if (r < 0)
2492                 return r;
2493
2494         return 1;
2495 }
2496
2497 static int process_fd_check(sd_bus *bus, sd_bus_message *m) {
2498         assert(bus);
2499         assert(m);
2500
2501         /* If we got a message with a file descriptor which we didn't
2502          * want to accept, then let's drop it. How can this even
2503          * happen? For example, when the kernel queues a message into
2504          * an activatable names's queue which allows fds, and then is
2505          * delivered to us later even though we ourselves did not
2506          * negotiate it. */
2507
2508         if (bus->hello_flags & KDBUS_HELLO_MONITOR)
2509                 return 0;
2510
2511         if (m->n_fds <= 0)
2512                 return 0;
2513
2514         if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)
2515                 return 0;
2516
2517         if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL)
2518                 return 1; /* just eat it up */
2519
2520         return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry.");
2521 }
2522
2523 static int process_message(sd_bus *bus, sd_bus_message *m) {
2524         int r;
2525
2526         assert(bus);
2527         assert(m);
2528
2529         bus->current_message = m;
2530         bus->iteration_counter++;
2531
2532         log_debug_bus_message(m);
2533
2534         r = process_hello(bus, m);
2535         if (r != 0)
2536                 goto finish;
2537
2538         r = process_reply(bus, m);
2539         if (r != 0)
2540                 goto finish;
2541
2542         r = process_fd_check(bus, m);
2543         if (r != 0)
2544                 goto finish;
2545
2546         r = process_filter(bus, m);
2547         if (r != 0)
2548                 goto finish;
2549
2550         r = process_match(bus, m);
2551         if (r != 0)
2552                 goto finish;
2553
2554         r = process_builtin(bus, m);
2555         if (r != 0)
2556                 goto finish;
2557
2558         r = bus_process_object(bus, m);
2559
2560 finish:
2561         bus->current_message = NULL;
2562         return r;
2563 }
2564
2565 static int dispatch_track(sd_bus *bus) {
2566         assert(bus);
2567
2568         if (!bus->track_queue)
2569                 return 0;
2570
2571         bus_track_dispatch(bus->track_queue);
2572         return 1;
2573 }
2574
2575 static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2576         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2577         int r;
2578
2579         assert(bus);
2580         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
2581
2582         r = process_timeout(bus);
2583         if (r != 0)
2584                 goto null_message;
2585
2586         r = dispatch_wqueue(bus);
2587         if (r != 0)
2588                 goto null_message;
2589
2590         r = dispatch_track(bus);
2591         if (r != 0)
2592                 goto null_message;
2593
2594         r = dispatch_rqueue(bus, hint_priority, priority, &m);
2595         if (r < 0)
2596                 return r;
2597         if (!m)
2598                 goto null_message;
2599
2600         r = process_message(bus, m);
2601         if (r != 0)
2602                 goto null_message;
2603
2604         if (ret) {
2605                 r = sd_bus_message_rewind(m, true);
2606                 if (r < 0)
2607                         return r;
2608
2609                 *ret = m;
2610                 m = NULL;
2611                 return 1;
2612         }
2613
2614         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL) {
2615
2616                 log_debug("Unprocessed message call sender=%s object=%s interface=%s member=%s",
2617                           strna(sd_bus_message_get_sender(m)),
2618                           strna(sd_bus_message_get_path(m)),
2619                           strna(sd_bus_message_get_interface(m)),
2620                           strna(sd_bus_message_get_member(m)));
2621
2622                 r = sd_bus_reply_method_errorf(
2623                                 m,
2624                                 SD_BUS_ERROR_UNKNOWN_OBJECT,
2625                                 "Unknown object '%s'.", m->path);
2626                 if (r < 0)
2627                         return r;
2628         }
2629
2630         return 1;
2631
2632 null_message:
2633         if (r >= 0 && ret)
2634                 *ret = NULL;
2635
2636         return r;
2637 }
2638
2639 static int process_closing(sd_bus *bus, sd_bus_message **ret) {
2640         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2641         struct reply_callback *c;
2642         int r;
2643
2644         assert(bus);
2645         assert(bus->state == BUS_CLOSING);
2646
2647         c = ordered_hashmap_first(bus->reply_callbacks);
2648         if (c) {
2649                 _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
2650                 sd_bus_slot *slot;
2651
2652                 /* First, fail all outstanding method calls */
2653                 r = bus_message_new_synthetic_error(
2654                                 bus,
2655                                 c->cookie,
2656                                 &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Connection terminated"),
2657                                 &m);
2658                 if (r < 0)
2659                         return r;
2660
2661                 r = bus_seal_synthetic_message(bus, m);
2662                 if (r < 0)
2663                         return r;
2664
2665                 if (c->timeout != 0) {
2666                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
2667                         c->timeout = 0;
2668                 }
2669
2670                 ordered_hashmap_remove(bus->reply_callbacks, &c->cookie);
2671                 c->cookie = 0;
2672
2673                 slot = container_of(c, sd_bus_slot, reply_callback);
2674
2675                 bus->iteration_counter++;
2676
2677                 bus->current_message = m;
2678                 bus->current_slot = sd_bus_slot_ref(slot);
2679                 bus->current_handler = c->callback;
2680                 bus->current_userdata = slot->userdata;
2681                 r = c->callback(m, slot->userdata, &error_buffer);
2682                 bus->current_userdata = NULL;
2683                 bus->current_handler = NULL;
2684                 bus->current_slot = NULL;
2685                 bus->current_message = NULL;
2686
2687                 if (slot->floating) {
2688                         bus_slot_disconnect(slot);
2689                         sd_bus_slot_unref(slot);
2690                 }
2691
2692                 sd_bus_slot_unref(slot);
2693
2694                 return bus_maybe_reply_error(m, r, &error_buffer);
2695         }
2696
2697         /* Then, synthesize a Disconnected message */
2698         r = sd_bus_message_new_signal(
2699                         bus,
2700                         &m,
2701                         "/org/freedesktop/DBus/Local",
2702                         "org.freedesktop.DBus.Local",
2703                         "Disconnected");
2704         if (r < 0)
2705                 return r;
2706
2707         bus_message_set_sender_local(bus, m);
2708
2709         r = bus_seal_synthetic_message(bus, m);
2710         if (r < 0)
2711                 return r;
2712
2713         sd_bus_close(bus);
2714
2715         bus->current_message = m;
2716         bus->iteration_counter++;
2717
2718         r = process_filter(bus, m);
2719         if (r != 0)
2720                 goto finish;
2721
2722         r = process_match(bus, m);
2723         if (r != 0)
2724                 goto finish;
2725
2726         if (ret) {
2727                 *ret = m;
2728                 m = NULL;
2729         }
2730
2731         r = 1;
2732
2733 finish:
2734         bus->current_message = NULL;
2735
2736         return r;
2737 }
2738
2739 static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) {
2740         BUS_DONT_DESTROY(bus);
2741         int r;
2742
2743         /* Returns 0 when we didn't do anything. This should cause the
2744          * caller to invoke sd_bus_wait() before returning the next
2745          * time. Returns > 0 when we did something, which possibly
2746          * means *ret is filled in with an unprocessed message. */
2747
2748         assert_return(bus, -EINVAL);
2749         assert_return(!bus_pid_changed(bus), -ECHILD);
2750
2751         /* We don't allow recursively invoking sd_bus_process(). */
2752         assert_return(!bus->current_message, -EBUSY);
2753         assert(!bus->current_slot);
2754
2755         switch (bus->state) {
2756
2757         case BUS_UNSET:
2758                 return -ENOTCONN;
2759
2760         case BUS_CLOSED:
2761                 return -ECONNRESET;
2762
2763         case BUS_OPENING:
2764                 r = bus_socket_process_opening(bus);
2765                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2766                         bus_enter_closing(bus);
2767                         r = 1;
2768                 } else if (r < 0)
2769                         return r;
2770                 if (ret)
2771                         *ret = NULL;
2772                 return r;
2773
2774         case BUS_AUTHENTICATING:
2775                 r = bus_socket_process_authenticating(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
2782                 if (ret)
2783                         *ret = NULL;
2784
2785                 return r;
2786
2787         case BUS_RUNNING:
2788         case BUS_HELLO:
2789                 r = process_running(bus, hint_priority, priority, ret);
2790                 if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2791                         bus_enter_closing(bus);
2792                         r = 1;
2793
2794                         if (ret)
2795                                 *ret = NULL;
2796                 }
2797
2798                 return r;
2799
2800         case BUS_CLOSING:
2801                 return process_closing(bus, ret);
2802         }
2803
2804         assert_not_reached("Unknown state");
2805 }
2806
2807 _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
2808         return bus_process_internal(bus, false, 0, ret);
2809 }
2810
2811 /// UNNEEDED by elogind
2812 #if 0
2813 _public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) {
2814         return bus_process_internal(bus, true, priority, ret);
2815 }
2816 #endif // 0
2817
2818 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
2819         struct pollfd p[2] = {};
2820         int r, e, n;
2821         struct timespec ts;
2822         usec_t m = USEC_INFINITY;
2823
2824         assert(bus);
2825
2826         if (bus->state == BUS_CLOSING)
2827                 return 1;
2828
2829         if (!BUS_IS_OPEN(bus->state))
2830                 return -ENOTCONN;
2831
2832         e = sd_bus_get_events(bus);
2833         if (e < 0)
2834                 return e;
2835
2836         if (need_more)
2837                 /* The caller really needs some more data, he doesn't
2838                  * care about what's already read, or any timeouts
2839                  * except its own. */
2840                 e |= POLLIN;
2841         else {
2842                 usec_t until;
2843                 /* The caller wants to process if there's something to
2844                  * process, but doesn't care otherwise */
2845
2846                 r = sd_bus_get_timeout(bus, &until);
2847                 if (r < 0)
2848                         return r;
2849                 if (r > 0) {
2850                         usec_t nw;
2851                         nw = now(CLOCK_MONOTONIC);
2852                         m = until > nw ? until - nw : 0;
2853                 }
2854         }
2855
2856         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
2857                 m = timeout_usec;
2858
2859         p[0].fd = bus->input_fd;
2860         if (bus->output_fd == bus->input_fd) {
2861                 p[0].events = e;
2862                 n = 1;
2863         } else {
2864                 p[0].events = e & POLLIN;
2865                 p[1].fd = bus->output_fd;
2866                 p[1].events = e & POLLOUT;
2867                 n = 2;
2868         }
2869
2870         r = ppoll(p, n, m == (uint64_t) -1 ? NULL : timespec_store(&ts, m), NULL);
2871         if (r < 0)
2872                 return -errno;
2873
2874         return r > 0 ? 1 : 0;
2875 }
2876
2877 _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
2878
2879         assert_return(bus, -EINVAL);
2880         assert_return(!bus_pid_changed(bus), -ECHILD);
2881
2882         if (bus->state == BUS_CLOSING)
2883                 return 0;
2884
2885         if (!BUS_IS_OPEN(bus->state))
2886                 return -ENOTCONN;
2887
2888         if (bus->rqueue_size > 0)
2889                 return 0;
2890
2891         return bus_poll(bus, false, timeout_usec);
2892 }
2893
2894 _public_ int sd_bus_flush(sd_bus *bus) {
2895         int r;
2896
2897         assert_return(bus, -EINVAL);
2898         assert_return(!bus_pid_changed(bus), -ECHILD);
2899
2900         if (bus->state == BUS_CLOSING)
2901                 return 0;
2902
2903         if (!BUS_IS_OPEN(bus->state))
2904                 return -ENOTCONN;
2905
2906         r = bus_ensure_running(bus);
2907         if (r < 0)
2908                 return r;
2909
2910         if (bus->wqueue_size <= 0)
2911                 return 0;
2912
2913         for (;;) {
2914                 r = dispatch_wqueue(bus);
2915                 if (r < 0) {
2916                         if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) {
2917                                 bus_enter_closing(bus);
2918                                 return -ECONNRESET;
2919                         }
2920
2921                         return r;
2922                 }
2923
2924                 if (bus->wqueue_size <= 0)
2925                         return 0;
2926
2927                 r = bus_poll(bus, false, (uint64_t) -1);
2928                 if (r < 0)
2929                         return r;
2930         }
2931 }
2932
2933 _public_ int sd_bus_add_filter(
2934                 sd_bus *bus,
2935                 sd_bus_slot **slot,
2936                 sd_bus_message_handler_t callback,
2937                 void *userdata) {
2938
2939         sd_bus_slot *s;
2940
2941         assert_return(bus, -EINVAL);
2942         assert_return(callback, -EINVAL);
2943         assert_return(!bus_pid_changed(bus), -ECHILD);
2944
2945         s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata);
2946         if (!s)
2947                 return -ENOMEM;
2948
2949         s->filter_callback.callback = callback;
2950
2951         bus->filter_callbacks_modified = true;
2952         LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);
2953
2954         if (slot)
2955                 *slot = s;
2956
2957         return 0;
2958 }
2959
2960 _public_ int sd_bus_add_match(
2961                 sd_bus *bus,
2962                 sd_bus_slot **slot,
2963                 const char *match,
2964                 sd_bus_message_handler_t callback,
2965                 void *userdata) {
2966
2967         struct bus_match_component *components = NULL;
2968         unsigned n_components = 0;
2969         sd_bus_slot *s = NULL;
2970         int r = 0;
2971
2972         assert_return(bus, -EINVAL);
2973         assert_return(match, -EINVAL);
2974         assert_return(!bus_pid_changed(bus), -ECHILD);
2975
2976         r = bus_match_parse(match, &components, &n_components);
2977         if (r < 0)
2978                 goto finish;
2979
2980         s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata);
2981         if (!s) {
2982                 r = -ENOMEM;
2983                 goto finish;
2984         }
2985
2986         s->match_callback.callback = callback;
2987         s->match_callback.cookie = ++bus->match_cookie;
2988
2989         if (bus->bus_client) {
2990                 enum bus_match_scope scope;
2991
2992                 scope = bus_match_get_scope(components, n_components);
2993
2994                 /* Do not install server-side matches for matches
2995                  * against the local service, interface or bus
2996                  * path. */
2997                 if (scope != BUS_MATCH_LOCAL) {
2998
2999                         if (!bus->is_kernel) {
3000                                 /* When this is not a kernel transport, we
3001                                  * store the original match string, so that we
3002                                  * can use it to remove the match again */
3003
3004                                 s->match_callback.match_string = strdup(match);
3005                                 if (!s->match_callback.match_string) {
3006                                         r = -ENOMEM;
3007                                         goto finish;
3008                                 }
3009                         }
3010
3011                         r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie);
3012                         if (r < 0)
3013                                 goto finish;
3014
3015                         s->match_added = true;
3016                 }
3017         }
3018
3019         bus->match_callbacks_modified = true;
3020         r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback);
3021         if (r < 0)
3022                 goto finish;
3023
3024         if (slot)
3025                 *slot = s;
3026         s = NULL;
3027
3028 finish:
3029         bus_match_parse_free(components, n_components);
3030         sd_bus_slot_unref(s);
3031
3032         return r;
3033 }
3034
3035 /// UNNEEDED by elogind
3036 #if 0
3037 int bus_remove_match_by_string(
3038                 sd_bus *bus,
3039                 const char *match,
3040                 sd_bus_message_handler_t callback,
3041                 void *userdata) {
3042
3043         struct bus_match_component *components = NULL;
3044         unsigned n_components = 0;
3045         struct match_callback *c;
3046         int r = 0;
3047
3048         assert_return(bus, -EINVAL);
3049         assert_return(match, -EINVAL);
3050         assert_return(!bus_pid_changed(bus), -ECHILD);
3051
3052         r = bus_match_parse(match, &components, &n_components);
3053         if (r < 0)
3054                 goto finish;
3055
3056         r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c);
3057         if (r <= 0)
3058                 goto finish;
3059
3060         sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback));
3061
3062 finish:
3063         bus_match_parse_free(components, n_components);
3064
3065         return r;
3066 }
3067 #endif // 0
3068
3069 bool bus_pid_changed(sd_bus *bus) {
3070         assert(bus);
3071
3072         /* We don't support people creating a bus connection and
3073          * keeping it around over a fork(). Let's complain. */
3074
3075         return bus->original_pid != getpid();
3076 }
3077
3078 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
3079         sd_bus *bus = userdata;
3080         int r;
3081
3082         assert(bus);
3083
3084         r = sd_bus_process(bus, NULL);
3085         if (r < 0)
3086                 return r;
3087
3088         return 1;
3089 }
3090
3091 static int time_callback(sd_event_source *s, uint64_t usec, void *userdata) {
3092         sd_bus *bus = userdata;
3093         int r;
3094
3095         assert(bus);
3096
3097         r = sd_bus_process(bus, NULL);
3098         if (r < 0)
3099                 return r;
3100
3101         return 1;
3102 }
3103
3104 static int prepare_callback(sd_event_source *s, void *userdata) {
3105         sd_bus *bus = userdata;
3106         int r, e;
3107         usec_t until;
3108
3109         assert(s);
3110         assert(bus);
3111
3112         e = sd_bus_get_events(bus);
3113         if (e < 0)
3114                 return e;
3115
3116         if (bus->output_fd != bus->input_fd) {
3117
3118                 r = sd_event_source_set_io_events(bus->input_io_event_source, e & POLLIN);
3119                 if (r < 0)
3120                         return r;
3121
3122                 r = sd_event_source_set_io_events(bus->output_io_event_source, e & POLLOUT);
3123                 if (r < 0)
3124                         return r;
3125         } else {
3126                 r = sd_event_source_set_io_events(bus->input_io_event_source, e);
3127                 if (r < 0)
3128                         return r;
3129         }
3130
3131         r = sd_bus_get_timeout(bus, &until);
3132         if (r < 0)
3133                 return r;
3134         if (r > 0) {
3135                 int j;
3136
3137                 j = sd_event_source_set_time(bus->time_event_source, until);
3138                 if (j < 0)
3139                         return j;
3140         }
3141
3142         r = sd_event_source_set_enabled(bus->time_event_source, r > 0);
3143         if (r < 0)
3144                 return r;
3145
3146         return 1;
3147 }
3148
3149 static int quit_callback(sd_event_source *event, void *userdata) {
3150         sd_bus *bus = userdata;
3151
3152         assert(event);
3153
3154         sd_bus_flush(bus);
3155         sd_bus_close(bus);
3156
3157         return 1;
3158 }
3159
3160 static int attach_io_events(sd_bus *bus) {
3161         int r;
3162
3163         assert(bus);
3164
3165         if (bus->input_fd < 0)
3166                 return 0;
3167
3168         if (!bus->event)
3169                 return 0;
3170
3171         if (!bus->input_io_event_source) {
3172                 r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus);
3173                 if (r < 0)
3174                         return r;
3175
3176                 r = sd_event_source_set_prepare(bus->input_io_event_source, prepare_callback);
3177                 if (r < 0)
3178                         return r;
3179
3180                 r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority);
3181                 if (r < 0)
3182                         return r;
3183
3184                 r = sd_event_source_set_description(bus->input_io_event_source, "bus-input");
3185         } else
3186                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
3187
3188         if (r < 0)
3189                 return r;
3190
3191         if (bus->output_fd != bus->input_fd) {
3192                 assert(bus->output_fd >= 0);
3193
3194                 if (!bus->output_io_event_source) {
3195                         r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus);
3196                         if (r < 0)
3197                                 return r;
3198
3199                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
3200                         if (r < 0)
3201                                 return r;
3202
3203                         r = sd_event_source_set_description(bus->input_io_event_source, "bus-output");
3204                 } else
3205                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
3206
3207                 if (r < 0)
3208                         return r;
3209         }
3210
3211         return 0;
3212 }
3213
3214 static void detach_io_events(sd_bus *bus) {
3215         assert(bus);
3216
3217         if (bus->input_io_event_source) {
3218                 sd_event_source_set_enabled(bus->input_io_event_source, SD_EVENT_OFF);
3219                 bus->input_io_event_source = sd_event_source_unref(bus->input_io_event_source);
3220         }
3221
3222         if (bus->output_io_event_source) {
3223                 sd_event_source_set_enabled(bus->output_io_event_source, SD_EVENT_OFF);
3224                 bus->output_io_event_source = sd_event_source_unref(bus->output_io_event_source);
3225         }
3226 }
3227
3228 _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
3229         int r;
3230
3231         assert_return(bus, -EINVAL);
3232         assert_return(!bus->event, -EBUSY);
3233
3234         assert(!bus->input_io_event_source);
3235         assert(!bus->output_io_event_source);
3236         assert(!bus->time_event_source);
3237
3238         if (event)
3239                 bus->event = sd_event_ref(event);
3240         else  {
3241                 r = sd_event_default(&bus->event);
3242                 if (r < 0)
3243                         return r;
3244         }
3245
3246         bus->event_priority = priority;
3247
3248         r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);
3249         if (r < 0)
3250                 goto fail;
3251
3252         r = sd_event_source_set_priority(bus->time_event_source, priority);
3253         if (r < 0)
3254                 goto fail;
3255
3256         r = sd_event_source_set_description(bus->time_event_source, "bus-time");
3257         if (r < 0)
3258                 goto fail;
3259
3260         r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus);
3261         if (r < 0)
3262                 goto fail;
3263
3264         r = sd_event_source_set_description(bus->quit_event_source, "bus-exit");
3265         if (r < 0)
3266                 goto fail;
3267
3268         r = attach_io_events(bus);
3269         if (r < 0)
3270                 goto fail;
3271
3272         return 0;
3273
3274 fail:
3275         sd_bus_detach_event(bus);
3276         return r;
3277 }
3278
3279 _public_ int sd_bus_detach_event(sd_bus *bus) {
3280         assert_return(bus, -EINVAL);
3281
3282         if (!bus->event)
3283                 return 0;
3284
3285         detach_io_events(bus);
3286
3287         if (bus->time_event_source) {
3288                 sd_event_source_set_enabled(bus->time_event_source, SD_EVENT_OFF);
3289                 bus->time_event_source = sd_event_source_unref(bus->time_event_source);
3290         }
3291
3292         if (bus->quit_event_source) {
3293                 sd_event_source_set_enabled(bus->quit_event_source, SD_EVENT_OFF);
3294                 bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
3295         }
3296
3297         bus->event = sd_event_unref(bus->event);
3298         return 1;
3299 }
3300
3301 _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
3302         assert_return(bus, NULL);
3303
3304         return bus->event;
3305 }
3306
3307 _public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) {
3308         assert_return(bus, NULL);
3309
3310         return bus->current_message;
3311 }
3312
3313 /// UNNEEDED by elogind
3314 #if 0
3315 _public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) {
3316         assert_return(bus, NULL);
3317
3318         return bus->current_slot;
3319 }
3320 #endif // 0
3321
3322 _public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) {
3323         assert_return(bus, NULL);
3324
3325         return bus->current_handler;
3326 }
3327
3328 _public_ void* sd_bus_get_current_userdata(sd_bus *bus) {
3329         assert_return(bus, NULL);
3330
3331         return bus->current_userdata;
3332 }
3333
3334 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {
3335         sd_bus *b = NULL;
3336         int r;
3337
3338         assert(bus_open);
3339         assert(default_bus);
3340
3341         if (!ret)
3342                 return !!*default_bus;
3343
3344         if (*default_bus) {
3345                 *ret = sd_bus_ref(*default_bus);
3346                 return 0;
3347         }
3348
3349         r = bus_open(&b);
3350         if (r < 0)
3351                 return r;
3352
3353         b->default_bus_ptr = default_bus;
3354         b->tid = gettid();
3355         *default_bus = b;
3356
3357         *ret = b;
3358         return 1;
3359 }
3360
3361 _public_ int sd_bus_default_system(sd_bus **ret) {
3362         static thread_local sd_bus *default_system_bus = NULL;
3363
3364         return bus_default(sd_bus_open_system, &default_system_bus, ret);
3365 }
3366
3367 _public_ int sd_bus_default_user(sd_bus **ret) {
3368         static thread_local sd_bus *default_user_bus = NULL;
3369
3370         return bus_default(sd_bus_open_user, &default_user_bus, ret);
3371 }
3372
3373 _public_ int sd_bus_default(sd_bus **ret) {
3374
3375         const char *e;
3376
3377         /* Let's try our best to reuse another cached connection. If
3378          * the starter bus type is set, connect via our normal
3379          * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that
3380          * we can share the connection with the user/system default
3381          * bus. */
3382
3383         e = secure_getenv("DBUS_STARTER_BUS_TYPE");
3384         if (e) {
3385                 if (streq(e, "system"))
3386                         return sd_bus_default_system(ret);
3387                 else if (STR_IN_SET(e, "user", "session"))
3388                         return sd_bus_default_user(ret);
3389         }
3390
3391         /* No type is specified, so we have not other option than to
3392          * use the starter address if it is set. */
3393
3394         e = secure_getenv("DBUS_STARTER_ADDRESS");
3395         if (e) {
3396                 static thread_local sd_bus *default_starter_bus = NULL;
3397
3398                 return bus_default(sd_bus_open, &default_starter_bus, ret);
3399         }
3400
3401         /* Finally, if nothing is set use the cached connection for
3402          * the right scope */
3403
3404         if (cg_pid_get_owner_uid(0, NULL) >= 0)
3405                 return sd_bus_default_user(ret);
3406         else
3407         return sd_bus_default_system(ret);
3408 }
3409
3410 /// UNNEEDED by elogind
3411 #if 0
3412 _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
3413         assert_return(b, -EINVAL);
3414         assert_return(tid, -EINVAL);
3415         assert_return(!bus_pid_changed(b), -ECHILD);
3416
3417         if (b->tid != 0) {
3418                 *tid = b->tid;
3419                 return 0;
3420         }
3421
3422         if (b->event)
3423                 return sd_event_get_tid(b->event, tid);
3424
3425         return -ENXIO;
3426 }
3427
3428 _public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
3429         _cleanup_free_ char *e = NULL;
3430         char *ret;
3431
3432         assert_return(object_path_is_valid(prefix), -EINVAL);
3433         assert_return(external_id, -EINVAL);
3434         assert_return(ret_path, -EINVAL);
3435
3436         e = bus_label_escape(external_id);
3437         if (!e)
3438                 return -ENOMEM;
3439
3440         ret = strjoin(prefix, "/", e, NULL);
3441         if (!ret)
3442                 return -ENOMEM;
3443
3444         *ret_path = ret;
3445         return 0;
3446 }
3447
3448 _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
3449         const char *e;
3450         char *ret;
3451
3452         assert_return(object_path_is_valid(path), -EINVAL);
3453         assert_return(object_path_is_valid(prefix), -EINVAL);
3454         assert_return(external_id, -EINVAL);
3455
3456         e = object_path_startswith(path, prefix);
3457         if (!e) {
3458                 *external_id = NULL;
3459                 return 0;
3460         }
3461
3462         ret = bus_label_unescape(e);
3463         if (!ret)
3464                 return -ENOMEM;
3465
3466         *external_id = ret;
3467         return 1;
3468 }
3469 #endif // 0
3470
3471 _public_ int sd_bus_try_close(sd_bus *bus) {
3472         int r;
3473
3474         assert_return(bus, -EINVAL);
3475         assert_return(!bus_pid_changed(bus), -ECHILD);
3476
3477         if (!bus->is_kernel)
3478                 return -EOPNOTSUPP;
3479
3480         if (!BUS_IS_OPEN(bus->state))
3481                 return -ENOTCONN;
3482
3483         if (bus->rqueue_size > 0)
3484                 return -EBUSY;
3485
3486         if (bus->wqueue_size > 0)
3487                 return -EBUSY;
3488
3489         r = bus_kernel_try_close(bus);
3490         if (r < 0)
3491                 return r;
3492
3493         sd_bus_close(bus);
3494         return 0;
3495 }
3496
3497 /// UNNEEDED by elogind
3498 #if 0
3499 _public_ int sd_bus_get_description(sd_bus *bus, const char **description) {
3500         assert_return(bus, -EINVAL);
3501         assert_return(description, -EINVAL);
3502         assert_return(bus->description, -ENXIO);
3503         assert_return(!bus_pid_changed(bus), -ECHILD);
3504
3505         *description = bus->description;
3506         return 0;
3507 }
3508 #endif // 0
3509
3510 int bus_get_root_path(sd_bus *bus) {
3511         int r;
3512
3513         if (bus->cgroup_root)
3514                 return 0;
3515
3516         r = cg_get_root_path(&bus->cgroup_root);
3517         if (r == -ENOENT) {
3518                 bus->cgroup_root = strdup("/");
3519                 if (!bus->cgroup_root)
3520                         return -ENOMEM;
3521
3522                 r = 0;
3523         }
3524
3525         return r;
3526 }
3527
3528 /// UNNEEDED by elogind
3529 #if 0
3530 _public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) {
3531         int r;
3532
3533         assert_return(bus, -EINVAL);
3534         assert_return(scope, -EINVAL);
3535         assert_return(!bus_pid_changed(bus), -ECHILD);
3536
3537         if (bus->is_kernel) {
3538                 _cleanup_free_ char *n = NULL;
3539                 const char *dash;
3540
3541                 r = bus_kernel_get_bus_name(bus, &n);
3542                 if (r < 0)
3543                         return r;
3544
3545                 if (streq(n, "0-system")) {
3546                         *scope = "system";
3547                         return 0;
3548                 }
3549
3550                 dash = strchr(n, '-');
3551                 if (streq_ptr(dash, "-user")) {
3552                         *scope = "user";
3553                         return 0;
3554                 }
3555         }
3556
3557         if (bus->is_user) {
3558                 *scope = "user";
3559                 return 0;
3560         }
3561
3562         if (bus->is_system) {
3563                 *scope = "system";
3564                 return 0;
3565         }
3566
3567         return -ENODATA;
3568 }
3569
3570 _public_ int sd_bus_get_address(sd_bus *bus, const char **address) {
3571
3572         assert_return(bus, -EINVAL);
3573         assert_return(address, -EINVAL);
3574         assert_return(!bus_pid_changed(bus), -ECHILD);
3575
3576         if (bus->address) {
3577                 *address = bus->address;
3578                 return 0;
3579         }
3580
3581         return -ENODATA;
3582 }
3583
3584 _public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
3585         assert_return(bus, -EINVAL);
3586         assert_return(mask, -EINVAL);
3587         assert_return(!bus_pid_changed(bus), -ECHILD);
3588
3589         *mask = bus->creds_mask;
3590         return 0;
3591 }
3592
3593 _public_ int sd_bus_is_bus_client(sd_bus *bus) {
3594         assert_return(bus, -EINVAL);
3595         assert_return(!bus_pid_changed(bus), -ECHILD);
3596
3597         return bus->bus_client;
3598 }
3599
3600 _public_ int sd_bus_is_server(sd_bus *bus) {
3601         assert_return(bus, -EINVAL);
3602         assert_return(!bus_pid_changed(bus), -ECHILD);
3603
3604         return bus->is_server;
3605 }
3606
3607 _public_ int sd_bus_is_anonymous(sd_bus *bus) {
3608         assert_return(bus, -EINVAL);
3609         assert_return(!bus_pid_changed(bus), -ECHILD);
3610
3611         return bus->anonymous_auth;
3612 }
3613
3614 _public_ int sd_bus_is_trusted(sd_bus *bus) {
3615         assert_return(bus, -EINVAL);
3616         assert_return(!bus_pid_changed(bus), -ECHILD);
3617
3618         return bus->trusted;
3619 }
3620
3621 _public_ int sd_bus_is_monitor(sd_bus *bus) {
3622         assert_return(bus, -EINVAL);
3623         assert_return(!bus_pid_changed(bus), -ECHILD);
3624
3625         return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);
3626 }
3627 #endif // 0