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

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