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