src/libsystemd-bus/bus-kernel.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 #ifdef HAVE_VALGRIND_MEMCHECK_H
  23 #include <valgrind/memcheck.h>
  24 #endif
  25
  26 #include <fcntl.h>
  27 #include <malloc.h>
  28 #include <sys/mman.h>
  29
  30 #include "util.h"
  31 #include "strv.h"
  32
  33 #include "bus-internal.h"
  34 #include "bus-message.h"
  35 #include "bus-kernel.h"
  36 #include "bus-bloom.h"
  37 #include "bus-util.h"
  38
  39 #define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
  40
  41 int bus_kernel_parse_unique_name(const char *s, uint64_t *id) {
  42         int r;
  43
  44         assert(s);
  45         assert(id);
  46
  47         if (!startswith(s, ":1."))
  48                 return 0;
  49
  50         r = safe_atou64(s + 3, id);
  51         if (r < 0)
  52                 return r;
  53
  54         return 1;
  55 }
  56
  57 static void append_payload_vec(struct kdbus_item **d, const void *p, size_t sz) {
  58         assert(d);
  59         assert(sz > 0);
  60
  61         *d = ALIGN8_PTR(*d);
  62
  63         /* Note that p can be NULL, which encodes a region full of
  64          * zeroes, which is useful to optimize certain padding
  65          * conditions */
  66
  67         (*d)->size = offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec);
  68         (*d)->type = KDBUS_ITEM_PAYLOAD_VEC;
  69         (*d)->vec.address = PTR_TO_UINT64(p);
  70         (*d)->vec.size = sz;
  71
  72         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
  73 }
  74
  75 static void append_payload_memfd(struct kdbus_item **d, int memfd, size_t sz) {
  76         assert(d);
  77         assert(memfd >= 0);
  78         assert(sz > 0);
  79
  80         *d = ALIGN8_PTR(*d);
  81         (*d)->size = offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd);
  82         (*d)->type = KDBUS_ITEM_PAYLOAD_MEMFD;
  83         (*d)->memfd.fd = memfd;
  84         (*d)->memfd.size = sz;
  85
  86         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
  87 }
  88
  89 static void append_destination(struct kdbus_item **d, const char *s, size_t length) {
  90         assert(d);
  91         assert(s);
  92
  93         *d = ALIGN8_PTR(*d);
  94
  95         (*d)->size = offsetof(struct kdbus_item, str) + length + 1;
  96         (*d)->type = KDBUS_ITEM_DST_NAME;
  97         memcpy((*d)->str, s, length + 1);
  98
  99         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
 100 }
 101
 102 static void* append_bloom(struct kdbus_item **d, size_t length) {
 103         void *r;
 104
 105         assert(d);
 106
 107         *d = ALIGN8_PTR(*d);
 108
 109         (*d)->size = offsetof(struct kdbus_item, data) + length;
 110         (*d)->type = KDBUS_ITEM_BLOOM;
 111         r = (*d)->data;
 112
 113         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
 114
 115         return r;
 116 }
 117
 118 static void append_fds(struct kdbus_item **d, const int fds[], unsigned n_fds) {
 119         assert(d);
 120         assert(fds);
 121         assert(n_fds > 0);
 122
 123         *d = ALIGN8_PTR(*d);
 124         (*d)->size = offsetof(struct kdbus_item, fds) + sizeof(int) * n_fds;
 125         (*d)->type = KDBUS_ITEM_FDS;
 126         memcpy((*d)->fds, fds, sizeof(int) * n_fds);
 127
 128         *d = (struct kdbus_item *) ((uint8_t*) *d + (*d)->size);
 129 }
 130
 131 static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) {
 132         unsigned i;
 133         int r;
 134
 135         assert(m);
 136         assert(bloom);
 137
 138         memset(bloom, 0, BLOOM_SIZE);
 139
 140         bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type));
 141
 142         if (m->interface)
 143                 bloom_add_pair(bloom, "interface", m->interface);
 144         if (m->member)
 145                 bloom_add_pair(bloom, "member", m->member);
 146         if (m->path) {
 147                 bloom_add_pair(bloom, "path", m->path);
 148                 bloom_add_pair(bloom, "path-slash-prefix", m->path);
 149                 bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/');
 150         }
 151
 152         r = sd_bus_message_rewind(m, true);
 153         if (r < 0)
 154                 return r;
 155
 156         for (i = 0; i < 64; i++) {
 157                 char type;
 158                 const char *t;
 159                 char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
 160                 char *e;
 161
 162                 r = sd_bus_message_peek_type(m, &type, NULL);
 163                 if (r < 0)
 164                         return r;
 165
 166                 if (type != SD_BUS_TYPE_STRING &&
 167                     type != SD_BUS_TYPE_OBJECT_PATH &&
 168                     type != SD_BUS_TYPE_SIGNATURE)
 169                         break;
 170
 171                 r = sd_bus_message_read_basic(m, type, &t);
 172                 if (r < 0)
 173                         return r;
 174
 175                 e = stpcpy(buf, "arg");
 176                 if (i < 10)
 177                         *(e++) = '0' + i;
 178                 else {
 179                         *(e++) = '0' + (i / 10);
 180                         *(e++) = '0' + (i % 10);
 181                 }
 182
 183                 *e = 0;
 184                 bloom_add_pair(bloom, buf, t);
 185
 186                 strcpy(e, "-dot-prefix");
 187                 bloom_add_prefixes(bloom, buf, t, '.');
 188                 strcpy(e, "-slash-prefix");
 189                 bloom_add_prefixes(bloom, buf, t, '/');
 190         }
 191
 192         return 0;
 193 }
 194
 195 static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
 196         struct bus_body_part *part;
 197         struct kdbus_item *d;
 198         bool well_known;
 199         uint64_t unique;
 200         size_t sz, dl;
 201         unsigned i;
 202         int r;
 203
 204         assert(b);
 205         assert(m);
 206         assert(m->sealed);
 207
 208         if (m->kdbus)
 209                 return 0;
 210
 211         if (m->destination) {
 212                 r = bus_kernel_parse_unique_name(m->destination, &unique);
 213                 if (r < 0)
 214                         return r;
 215
 216                 well_known = r == 0;
 217         } else
 218                 well_known = false;
 219
 220         sz = offsetof(struct kdbus_msg, items);
 221
 222         assert_cc(ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec)) ==
 223                   ALIGN8(offsetof(struct kdbus_item, memfd) + sizeof(struct kdbus_memfd)));
 224
 225         /* Add in fixed header, fields header and payload */
 226         sz += (1 + m->n_body_parts) *
 227                 ALIGN8(offsetof(struct kdbus_item, vec) + sizeof(struct kdbus_vec));
 228
 229         /* Add space for bloom filter */
 230         sz += ALIGN8(offsetof(struct kdbus_item, data) + BLOOM_SIZE);
 231
 232         /* Add in well-known destination header */
 233         if (well_known) {
 234                 dl = strlen(m->destination);
 235                 sz += ALIGN8(offsetof(struct kdbus_item, str) + dl + 1);
 236         }
 237
 238         /* Add space for unix fds */
 239         if (m->n_fds > 0)
 240                 sz += ALIGN8(offsetof(struct kdbus_item, fds) + sizeof(int)*m->n_fds);
 241
 242         m->kdbus = memalign(8, sz);
 243         if (!m->kdbus) {
 244                 r = -ENOMEM;
 245                 goto fail;
 246         }
 247
 248         m->free_kdbus = true;
 249         memset(m->kdbus, 0, sz);
 250
 251         m->kdbus->flags =
 252                 ((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
 253                 ((m->header->flags & BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
 254         m->kdbus->dst_id =
 255                 well_known ? 0 :
 256                 m->destination ? unique : KDBUS_DST_ID_BROADCAST;
 257         m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS;
 258         m->kdbus->cookie = m->header->serial;
 259
 260         m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
 261
 262         d = m->kdbus->items;
 263
 264         if (well_known)
 265                 append_destination(&d, m->destination, dl);
 266
 267         append_payload_vec(&d, m->header, BUS_MESSAGE_BODY_BEGIN(m));
 268
 269         MESSAGE_FOREACH_PART(part, i, m) {
 270                 if (part->is_zero) {
 271                         /* If this is padding then simply send a
 272                          * vector with a NULL data pointer which the
 273                          * kernel will just pass through. This is the
 274                          * most efficient way to encode zeroes */
 275
 276                         append_payload_vec(&d, NULL, part->size);
 277                         continue;
 278                 }
 279
 280                 if (part->memfd >= 0 && part->sealed && m->destination) {
 281                         /* Try to send a memfd, if the part is
 282                          * sealed and this is not a broadcast. Since we can only  */
 283
 284                         append_payload_memfd(&d, part->memfd, part->size);
 285                         continue;
 286                 }
 287
 288                 /* Otherwise let's send a vector to the actual data,
 289                  * for that we need to map it first. */
 290                 r = bus_body_part_map(part);
 291                 if (r < 0)
 292                         goto fail;
 293
 294                 append_payload_vec(&d, part->data, part->size);
 295         }
 296
 297         if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
 298                 void *p;
 299
 300                 p = append_bloom(&d, BLOOM_SIZE);
 301                 r = bus_message_setup_bloom(m, p);
 302                 if (r < 0)
 303                         goto fail;
 304         }
 305
 306         if (m->n_fds > 0)
 307                 append_fds(&d, m->fds, m->n_fds);
 308
 309         m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
 310         assert(m->kdbus->size <= sz);
 311
 312         return 0;
 313
 314 fail:
 315         m->poisoned = true;
 316         return r;
 317 }
 318
 319 int bus_kernel_take_fd(sd_bus *b) {
 320         struct kdbus_cmd_hello hello;
 321         int r;
 322
 323         assert(b);
 324
 325         if (b->is_server)
 326                 return -EINVAL;
 327
 328         b->use_memfd = 1;
 329
 330         zero(hello);
 331         hello.size = sizeof(hello);
 332         hello.conn_flags = b->hello_flags;
 333         hello.attach_flags = b->attach_flags;
 334         hello.pool_size = KDBUS_POOL_SIZE;
 335
 336         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, &hello);
 337         if (r < 0)
 338                 return -errno;
 339
 340         if (!b->kdbus_buffer) {
 341                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 342                 if (b->kdbus_buffer == MAP_FAILED) {
 343                         b->kdbus_buffer = NULL;
 344                         return -errno;
 345                 }
 346         }
 347
 348         /* The higher 32bit of both flags fields are considered
 349          * 'incompatible flags'. Refuse them all for now. */
 350         if (hello.bus_flags > 0xFFFFFFFFULL ||
 351             hello.conn_flags > 0xFFFFFFFFULL)
 352                 return -ENOTSUP;
 353
 354         if (hello.bloom_size != BLOOM_SIZE)
 355                 return -ENOTSUP;
 356
 357         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello.id) < 0)
 358                 return -ENOMEM;
 359
 360         b->unique_id = hello.id;
 361
 362         b->is_kernel = true;
 363         b->bus_client = true;
 364         b->can_fds = !!(hello.conn_flags & KDBUS_HELLO_ACCEPT_FD);
 365         b->message_version = 2;
 366
 367         /* the kernel told us the UUID of the underlying bus */
 368         memcpy(b->server_id.bytes, hello.id128, sizeof(b->server_id.bytes));
 369
 370         return bus_start_running(b);
 371 }
 372
 373 int bus_kernel_connect(sd_bus *b) {
 374         assert(b);
 375         assert(b->input_fd < 0);
 376         assert(b->output_fd < 0);
 377         assert(b->kernel);
 378
 379         if (b->is_server)
 380                 return -EINVAL;
 381
 382         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
 383         if (b->input_fd < 0)
 384                 return -errno;
 385
 386         b->output_fd = b->input_fd;
 387
 388         return bus_kernel_take_fd(b);
 389 }
 390
 391 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
 392         int r;
 393
 394         assert(bus);
 395         assert(m);
 396         assert(bus->state == BUS_RUNNING);
 397
 398         /* If we can't deliver, we want room for the error message */
 399         r = bus_rqueue_make_room(bus);
 400         if (r < 0)
 401                 return r;
 402
 403         r = bus_message_setup_kmsg(bus, m);
 404         if (r < 0)
 405                 return r;
 406
 407         r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
 408         if (r < 0) {
 409                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 410                 sd_bus_message *reply;
 411
 412                 if (errno == EAGAIN || errno == EINTR)
 413                         return 0;
 414                 else if (errno == ENXIO || errno == ESRCH) {
 415
 416                         /* ENXIO: unique name not known
 417                          * ESRCH: well-known name not known */
 418
 419                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
 420                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
 421                         else {
 422                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
 423                                 return 0;
 424                         }
 425
 426                 } else if (errno == EADDRNOTAVAIL) {
 427
 428                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
 429
 430                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
 431                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
 432                         else {
 433                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
 434                                 return 0;
 435                         }
 436                 } else
 437                         return -errno;
 438
 439                 r = bus_message_new_synthetic_error(
 440                                 bus,
 441                                 BUS_MESSAGE_SERIAL(m),
 442                                 &error,
 443                                 &reply);
 444
 445                 if (r < 0)
 446                         return r;
 447
 448                 r = bus_seal_synthetic_message(bus, reply);
 449                 if (r < 0)
 450                         return r;
 451
 452                 bus->rqueue[bus->rqueue_size++] = reply;
 453
 454                 return 0;
 455         }
 456
 457         return 1;
 458 }
 459
 460 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
 461         uint64_t off;
 462         struct kdbus_item *d;
 463
 464         assert(bus);
 465         assert(k);
 466
 467         off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
 468         ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
 469
 470         KDBUS_ITEM_FOREACH(d, k, items) {
 471
 472                 if (d->type == KDBUS_ITEM_FDS)
 473                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
 474                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
 475                         close_nointr_nofail(d->memfd.fd);
 476         }
 477 }
 478
 479 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
 480         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 481         int r;
 482
 483         assert(bus);
 484
 485         r = sd_bus_message_new_signal(
 486                         bus,
 487                         "/org/freedesktop/DBus",
 488                         "org.freedesktop.DBus",
 489                         "NameOwnerChanged",
 490                         &m);
 491         if (r < 0)
 492                 return r;
 493
 494         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
 495         if (r < 0)
 496                 return r;
 497
 498         m->sender = "org.freedesktop.DBus";
 499
 500         r = bus_seal_synthetic_message(bus, m);
 501         if (r < 0)
 502                 return r;
 503
 504         bus->rqueue[bus->rqueue_size++] = m;
 505         m = NULL;
 506
 507         return 1;
 508 }
 509
 510 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 511         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
 512
 513         assert(bus);
 514         assert(k);
 515         assert(d);
 516
 517         if (d->name_change.flags != 0)
 518                 return 0;
 519
 520         if (d->type == KDBUS_ITEM_NAME_ADD)
 521                 old_owner[0] = 0;
 522         else
 523                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id);
 524
 525         if (d->type == KDBUS_ITEM_NAME_REMOVE)
 526                 new_owner[0] = 0;
 527         else
 528                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id);
 529
 530         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
 531 }
 532
 533 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 534         char owner[UNIQUE_NAME_MAX];
 535
 536         assert(bus);
 537         assert(k);
 538         assert(d);
 539
 540         sprintf(owner, ":1.%llu", d->id_change.id);
 541
 542         return push_name_owner_changed(
 543                         bus, owner,
 544                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
 545                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
 546 }
 547
 548 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 549         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 550         int r;
 551
 552         assert(bus);
 553         assert(k);
 554         assert(d);
 555
 556         r = bus_message_new_synthetic_error(
 557                         bus,
 558                         k->cookie_reply,
 559                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
 560                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
 561                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
 562                         &m);
 563         if (r < 0)
 564                 return r;
 565
 566         m->sender = "org.freedesktop.DBus";
 567
 568         r = bus_seal_synthetic_message(bus, m);
 569         if (r < 0)
 570                 return r;
 571
 572         bus->rqueue[bus->rqueue_size++] = m;
 573         m = NULL;
 574
 575         return 1;
 576 }
 577
 578 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
 579         struct kdbus_item *d, *found = NULL;
 580
 581         static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
 582                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
 583                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
 584                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
 585
 586                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
 587                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
 588
 589                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
 590                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
 591         };
 592
 593         assert(bus);
 594         assert(k);
 595         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
 596
 597         KDBUS_ITEM_FOREACH(d, k, items) {
 598                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
 599                         if (found)
 600                                 return -EBADMSG;
 601                         found = d;
 602                 } else
 603                         log_debug("Got unknown field from kernel %llu", d->type);
 604         }
 605
 606         if (!found) {
 607                 log_debug("Didn't find a kernel message to translate.");
 608                 return 0;
 609         }
 610
 611         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
 612 }
 613
 614 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
 615         sd_bus_message *m = NULL;
 616         struct kdbus_item *d;
 617         unsigned n_fds = 0;
 618         _cleanup_free_ int *fds = NULL;
 619         struct bus_header *h = NULL;
 620         size_t total, n_bytes = 0, idx = 0;
 621         const char *destination = NULL, *seclabel = NULL;
 622         int r;
 623
 624         assert(bus);
 625         assert(k);
 626         assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
 627
 628         KDBUS_ITEM_FOREACH(d, k, items) {
 629                 size_t l;
 630
 631                 l = d->size - offsetof(struct kdbus_item, data);
 632
 633                 switch (d->type) {
 634
 635                 case KDBUS_ITEM_PAYLOAD_OFF:
 636                         if (!h) {
 637                                 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
 638
 639                                 if (!bus_header_is_complete(h, d->vec.size))
 640                                         return -EBADMSG;
 641                         }
 642
 643                         n_bytes += d->vec.size;
 644                         break;
 645
 646                 case KDBUS_ITEM_PAYLOAD_MEMFD:
 647                         if (!h)
 648                                 return -EBADMSG;
 649
 650                         n_bytes += d->memfd.size;
 651                         break;
 652
 653                 case KDBUS_ITEM_FDS: {
 654                         int *f;
 655                         unsigned j;
 656
 657                         j = l / sizeof(int);
 658                         f = realloc(fds, sizeof(int) * (n_fds + j));
 659                         if (!f)
 660                                 return -ENOMEM;
 661
 662                         fds = f;
 663                         memcpy(fds + n_fds, d->fds, sizeof(int) * j);
 664                         n_fds += j;
 665                         break;
 666                 }
 667
 668                 case KDBUS_ITEM_SECLABEL:
 669                         seclabel = d->str;
 670                         break;
 671                 }
 672         }
 673
 674         if (!h)
 675                 return -EBADMSG;
 676
 677         r = bus_header_message_size(h, &total);
 678         if (r < 0)
 679                 return r;
 680
 681         if (n_bytes != total)
 682                 return -EBADMSG;
 683
 684         /* on kdbus we only speak native endian gvariant, never dbus1
 685          * marshalling or reverse endian */
 686         if (h->version != 2 ||
 687             h->endian != BUS_NATIVE_ENDIAN)
 688                 return -EPROTOTYPE;
 689
 690         r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
 691         if (r < 0)
 692                 return r;
 693
 694         KDBUS_ITEM_FOREACH(d, k, items) {
 695                 size_t l;
 696
 697                 l = d->size - offsetof(struct kdbus_item, data);
 698
 699                 switch (d->type) {
 700
 701                 case KDBUS_ITEM_PAYLOAD_OFF: {
 702                         size_t begin_body;
 703
 704                         begin_body = BUS_MESSAGE_BODY_BEGIN(m);
 705
 706                         if (idx + d->vec.size > begin_body) {
 707                                 struct bus_body_part *part;
 708
 709                                 /* Contains body material */
 710
 711                                 part = message_append_part(m);
 712                                 if (!part) {
 713                                         r = -ENOMEM;
 714                                         goto fail;
 715                                 }
 716
 717                                 /* A -1 offset is NUL padding. */
 718                                 part->is_zero = d->vec.offset == ~0ULL;
 719
 720                                 if (idx >= begin_body) {
 721                                         if (!part->is_zero)
 722                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
 723                                         part->size = d->vec.size;
 724                                 } else {
 725                                         if (!part->is_zero)
 726                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
 727                                         part->size = d->vec.size - (begin_body - idx);
 728                                 }
 729
 730                                 part->sealed = true;
 731                         }
 732
 733                         idx += d->vec.size;
 734                         break;
 735                 }
 736
 737                 case KDBUS_ITEM_PAYLOAD_MEMFD: {
 738                         struct bus_body_part *part;
 739
 740                         if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
 741                                 r = -EBADMSG;
 742                                 goto fail;
 743                         }
 744
 745                         part = message_append_part(m);
 746                         if (!part) {
 747                                 r = -ENOMEM;
 748                                 goto fail;
 749                         }
 750
 751                         part->memfd = d->memfd.fd;
 752                         part->size = d->memfd.size;
 753                         part->sealed = true;
 754
 755                         idx += d->memfd.size;
 756                         break;
 757                 }
 758
 759                 case KDBUS_ITEM_CREDS:
 760                         m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
 761                         m->creds.uid = d->creds.uid;
 762                         m->creds.gid = d->creds.gid;
 763                         m->creds.pid = d->creds.pid;
 764                         m->creds.tid = d->creds.tid;
 765                         m->creds.mask |= (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID) & bus->creds_mask;
 766                         break;
 767
 768                 case KDBUS_ITEM_TIMESTAMP:
 769                         m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
 770                         m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
 771                         break;
 772
 773                 case KDBUS_ITEM_PID_COMM:
 774                         m->creds.comm = d->str;
 775                         m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
 776                         break;
 777
 778                 case KDBUS_ITEM_TID_COMM:
 779                         m->creds.tid_comm = d->str;
 780                         m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
 781                         break;
 782
 783                 case KDBUS_ITEM_EXE:
 784                         m->creds.exe = d->str;
 785                         m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
 786                         break;
 787
 788                 case KDBUS_ITEM_CMDLINE:
 789                         m->creds.cmdline = d->str;
 790                         m->creds.cmdline_size = l;
 791                         m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
 792                         break;
 793
 794                 case KDBUS_ITEM_CGROUP:
 795                         m->creds.cgroup = d->str;
 796                         m->creds.mask |= (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID) & bus->creds_mask;
 797                         break;
 798
 799                 case KDBUS_ITEM_AUDIT:
 800                         m->creds.audit_session_id = d->audit.sessionid;
 801                         m->creds.audit_login_uid = d->audit.loginuid;
 802                         m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
 803                         break;
 804
 805                 case KDBUS_ITEM_CAPS:
 806                         m->creds.capability = d->data;
 807                         m->creds.capability_size = l;
 808                         m->creds.mask |= (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS) & bus->creds_mask;
 809                         break;
 810
 811                 case KDBUS_ITEM_DST_NAME:
 812                         destination = d->str;
 813                         break;
 814
 815                 case KDBUS_ITEM_NAME:
 816                         r = strv_extend(&m->creds.well_known_names, d->name.name);
 817                         if (r < 0)
 818                                 goto fail;
 819                         m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES & bus->creds_mask;
 820                         break;
 821
 822                 case KDBUS_ITEM_FDS:
 823                 case KDBUS_ITEM_SECLABEL:
 824                         break;
 825
 826                 default:
 827                         log_debug("Got unknown field from kernel %llu", d->type);
 828                 }
 829         }
 830
 831         r = bus_message_parse_fields(m);
 832         if (r < 0)
 833                 goto fail;
 834
 835         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 836                 m->sender = "org.freedesktop.DBus";
 837         else {
 838                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 839                 m->sender = m->creds.unique_name = m->sender_buffer;
 840                 m->creds.mask |= SD_BUS_CREDS_UNIQUE_NAME & bus->creds_mask;
 841         }
 842
 843         if (!m->destination) {
 844                 if (destination)
 845                         m->destination = destination;
 846                 else if (k->dst_id != KDBUS_DST_ID_NAME &&
 847                          k->dst_id != KDBUS_DST_ID_BROADCAST) {
 848                         snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 849                         m->destination = m->destination_buffer;
 850                 }
 851         }
 852
 853         /* We take possession of the kmsg struct now */
 854         m->kdbus = k;
 855         m->release_kdbus = true;
 856         m->free_fds = true;
 857         fds = NULL;
 858
 859         bus->rqueue[bus->rqueue_size++] = m;
 860
 861         return 1;
 862
 863 fail:
 864         if (m) {
 865                 struct bus_body_part *part;
 866                 unsigned i;
 867
 868                 /* Make sure the memfds are not freed twice */
 869                 MESSAGE_FOREACH_PART(part, i, m)
 870                         if (part->memfd >= 0)
 871                                 part->memfd = -1;
 872
 873                 sd_bus_message_unref(m);
 874         }
 875
 876         return r;
 877 }
 878
 879 int bus_kernel_read_message(sd_bus *bus) {
 880         struct kdbus_msg *k;
 881         uint64_t off;
 882         int r;
 883
 884         assert(bus);
 885
 886         r = bus_rqueue_make_room(bus);
 887         if (r < 0)
 888                 return r;
 889
 890         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
 891         if (r < 0) {
 892                 if (errno == EAGAIN)
 893                         return 0;
 894
 895                 return -errno;
 896         }
 897         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
 898
 899         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
 900                 r = bus_kernel_make_message(bus, k);
 901
 902                 /* Anybody can send us invalid messages, let's just drop them. */
 903                 if (r == -EBADMSG || r == -EPROTOTYPE) {
 904                         log_debug("Ignoring invalid message: %s", strerror(-r));
 905                         r = 0;
 906                 }
 907
 908         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
 909                 r = bus_kernel_translate_message(bus, k);
 910         else
 911                 r = 0;
 912
 913         if (r <= 0)
 914                 close_kdbus_msg(bus, k);
 915
 916         return r < 0 ? r : 1;
 917 }
 918
 919 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *size) {
 920         struct memfd_cache *c;
 921         int fd;
 922
 923         assert(address);
 924         assert(size);
 925
 926         if (!bus || !bus->is_kernel)
 927                 return -ENOTSUP;
 928
 929         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
 930
 931         if (bus->n_memfd_cache <= 0) {
 932                 int r;
 933
 934                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 935
 936                 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
 937                 if (r < 0)
 938                         return -errno;
 939
 940                 *address = NULL;
 941                 *size = 0;
 942                 return fd;
 943         }
 944
 945         c = &bus->memfd_cache[--bus->n_memfd_cache];
 946
 947         assert(c->fd >= 0);
 948         assert(c->size == 0 || c->address);
 949
 950         *address = c->address;
 951         *size = c->size;
 952         fd = c->fd;
 953
 954         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 955
 956         return fd;
 957 }
 958
 959 static void close_and_munmap(int fd, void *address, size_t size) {
 960         if (size > 0)
 961                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
 962
 963         close_nointr_nofail(fd);
 964 }
 965
 966 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t size) {
 967         struct memfd_cache *c;
 968         uint64_t max_sz = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
 969
 970         assert(fd >= 0);
 971         assert(size == 0 || address);
 972
 973         if (!bus || !bus->is_kernel) {
 974                 close_and_munmap(fd, address, size);
 975                 return;
 976         }
 977
 978         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
 979
 980         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
 981                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 982
 983                 close_and_munmap(fd, address, size);
 984                 return;
 985         }
 986
 987         c = &bus->memfd_cache[bus->n_memfd_cache++];
 988         c->fd = fd;
 989         c->address = address;
 990
 991         /* If overly long, let's return a bit to the OS */
 992         if (size > max_sz) {
 993                 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_sz) >= 0);
 994                 assert_se(munmap((uint8_t*) address + max_sz, PAGE_ALIGN(size - max_sz)) >= 0);
 995                 c->size = max_sz;
 996         } else
 997                 c->size = size;
 998
 999         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1000 }
1001
1002 void bus_kernel_flush_memfd(sd_bus *b) {
1003         unsigned i;
1004
1005         assert(b);
1006
1007         for (i = 0; i < b->n_memfd_cache; i++)
1008                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].size);
1009 }
1010
1011 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1012         uint64_t f = 0;
1013
1014         assert(kdbus_flags);
1015
1016         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1017                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1018
1019         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1020                 f |= KDBUS_NAME_REPLACE_EXISTING;
1021
1022         if (!(flags & SD_BUS_NAME_DO_NOT_QUEUE))
1023                 f |= KDBUS_NAME_QUEUE;
1024
1025         *kdbus_flags = f;
1026         return 0;
1027 }
1028
1029 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1030         uint64_t m = 0;
1031
1032         assert(kdbus_mask);
1033
1034         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1035                 m |= KDBUS_ATTACH_CREDS;
1036
1037         if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1038                 m |= KDBUS_ATTACH_COMM;
1039
1040         if (mask & SD_BUS_CREDS_EXE)
1041                 m |= KDBUS_ATTACH_EXE;
1042
1043         if (mask & SD_BUS_CREDS_CMDLINE)
1044                 m |= KDBUS_ATTACH_CMDLINE;
1045
1046         if (mask & (SD_BUS_CREDS_CGROUP|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_USER_UNIT|SD_BUS_CREDS_SLICE|SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID))
1047                 m |= KDBUS_ATTACH_CGROUP;
1048
1049         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1050                 m |= KDBUS_ATTACH_CAPS;
1051
1052         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1053                 m |= KDBUS_ATTACH_SECLABEL;
1054
1055         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1056                 m |= KDBUS_ATTACH_AUDIT;
1057
1058         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1059                 m |= KDBUS_ATTACH_NAMES;
1060
1061         *kdbus_mask = m;
1062         return 0;
1063 }
1064
1065 int bus_kernel_create_bus(const char *name, char **s) {
1066         struct kdbus_cmd_bus_make *make;
1067         struct kdbus_item *n;
1068         int fd;
1069
1070         assert(name);
1071         assert(s);
1072
1073         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1074         if (fd < 0)
1075                 return -errno;
1076
1077         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_bus_make, items) +
1078                               offsetof(struct kdbus_item, str) +
1079                               DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1080
1081         n = make->items;
1082         sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1083         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1084         n->type = KDBUS_ITEM_MAKE_NAME;
1085
1086         make->size = ALIGN8(offsetof(struct kdbus_cmd_bus_make, items) + n->size);
1087         make->flags = KDBUS_MAKE_POLICY_OPEN;
1088         make->bloom_size = BLOOM_SIZE;
1089         assert_cc(BLOOM_SIZE % 8 == 0);
1090
1091         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1092                 close_nointr_nofail(fd);
1093                 return -errno;
1094         }
1095
1096         /* The higher 32bit of the flags field are considered
1097          * 'incompatible flags'. Refuse them all for now. */
1098         if (make->flags > 0xFFFFFFFFULL) {
1099                 close_nointr_nofail(fd);
1100                 return -ENOTSUP;
1101         }
1102
1103         if (s) {
1104                 char *p;
1105
1106                 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1107                 if (!p) {
1108                         close_nointr_nofail(fd);
1109                         return -ENOMEM;
1110                 }
1111
1112                 *s = p;
1113         }
1114
1115         return fd;
1116 }
1117
1118 int bus_kernel_create_starter(const char *bus, const char *name) {
1119         struct kdbus_cmd_hello *hello;
1120         struct kdbus_item *n;
1121         char *p;
1122         int fd;
1123
1124         assert(bus);
1125         assert(name);
1126
1127         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1128         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1129
1130         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1131         if (fd < 0)
1132                 return -errno;
1133
1134         hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1135                                offsetof(struct kdbus_item, str) +
1136                                strlen(name) + 1));
1137
1138         n = hello->items;
1139         strcpy(n->str, name);
1140         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1141         n->type = KDBUS_ITEM_STARTER_NAME;
1142
1143         hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1144         hello->conn_flags = KDBUS_HELLO_STARTER;
1145         hello->pool_size = KDBUS_POOL_SIZE;
1146
1147         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1148                 close_nointr_nofail(fd);
1149                 return -errno;
1150         }
1151
1152         /* The higher 32bit of both flags fields are considered
1153          * 'incompatible flags'. Refuse them all for now. */
1154         if (hello->bus_flags > 0xFFFFFFFFULL ||
1155             hello->conn_flags > 0xFFFFFFFFULL) {
1156                 close_nointr_nofail(fd);
1157                 return -ENOTSUP;
1158         }
1159
1160         if (hello->bloom_size != BLOOM_SIZE) {
1161                 close_nointr_nofail(fd);
1162                 return -ENOTSUP;
1163         }
1164
1165         return fd;
1166 }
1167
1168 int bus_kernel_create_namespace(const char *name, char **s) {
1169         struct kdbus_cmd_ns_make *make;
1170         struct kdbus_item *n;
1171         int fd;
1172
1173         assert(name);
1174         assert(s);
1175
1176         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1177         if (fd < 0)
1178                 return -errno;
1179
1180         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_ns_make, items) +
1181                               offsetof(struct kdbus_item, str) +
1182                               strlen(name) + 1));
1183
1184         n = make->items;
1185         strcpy(n->str, name);
1186         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1187         n->type = KDBUS_ITEM_MAKE_NAME;
1188
1189         make->size = ALIGN8(offsetof(struct kdbus_cmd_ns_make, items) + n->size);
1190         make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1191
1192         if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1193                 close_nointr_nofail(fd);
1194                 return -errno;
1195         }
1196
1197         /* The higher 32bit of the flags field are considered
1198          * 'incompatible flags'. Refuse them all for now. */
1199         if (make->flags > 0xFFFFFFFFULL) {
1200                 close_nointr_nofail(fd);
1201                 return -ENOTSUP;
1202         }
1203
1204         if (s) {
1205                 char *p;
1206
1207                 p = strappend("/dev/kdbus/ns/", name);
1208                 if (!p) {
1209                         close_nointr_nofail(fd);
1210                         return -ENOMEM;
1211                 }
1212
1213                 *s = p;
1214         }
1215
1216         return fd;
1217 }
1218
1219 int bus_kernel_monitor(sd_bus *bus) {
1220         struct kdbus_cmd_monitor cmd_monitor;
1221         int r;
1222
1223         assert(bus);
1224
1225         cmd_monitor.id = 0;
1226         cmd_monitor.flags = KDBUS_MONITOR_ENABLE;
1227
1228         r = ioctl(bus->input_fd, KDBUS_CMD_MONITOR, &cmd_monitor);
1229         if (r < 0)
1230                 return -errno;
1231
1232         return 1;
1233 }