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                                 return 0;
 423
 424                 } else if (errno == EADDRNOTAVAIL) {
 425
 426                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
 427
 428                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
 429                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
 430                         else
 431                                 return 0;
 432                 } else
 433                         return -errno;
 434
 435                 r = bus_message_new_synthetic_error(
 436                                 bus,
 437                                 BUS_MESSAGE_SERIAL(m),
 438                                 &error,
 439                                 &reply);
 440
 441                 if (r < 0)
 442                         return r;
 443
 444                 r = bus_seal_synthetic_message(bus, reply);
 445                 if (r < 0)
 446                         return r;
 447
 448                 bus->rqueue[bus->rqueue_size++] = reply;
 449
 450                 return 0;
 451         }
 452
 453         return 1;
 454 }
 455
 456 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
 457         uint64_t off;
 458         struct kdbus_item *d;
 459
 460         assert(bus);
 461         assert(k);
 462
 463         off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
 464         ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
 465
 466         KDBUS_ITEM_FOREACH(d, k, items) {
 467
 468                 if (d->type == KDBUS_ITEM_FDS)
 469                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
 470                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
 471                         close_nointr_nofail(d->memfd.fd);
 472         }
 473 }
 474
 475 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
 476         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 477         int r;
 478
 479         assert(bus);
 480
 481         r = sd_bus_message_new_signal(
 482                         bus,
 483                         "/org/freedesktop/DBus",
 484                         "org.freedesktop.DBus",
 485                         "NameOwnerChanged",
 486                         &m);
 487         if (r < 0)
 488                 return r;
 489
 490         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
 491         if (r < 0)
 492                 return r;
 493
 494         m->sender = "org.freedesktop.DBus";
 495
 496         r = bus_seal_synthetic_message(bus, m);
 497         if (r < 0)
 498                 return r;
 499
 500         bus->rqueue[bus->rqueue_size++] = m;
 501         m = NULL;
 502
 503         return 1;
 504 }
 505
 506 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 507         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
 508
 509         assert(bus);
 510         assert(k);
 511         assert(d);
 512
 513         if (d->name_change.flags != 0)
 514                 return 0;
 515
 516         if (d->type == KDBUS_ITEM_NAME_ADD)
 517                 old_owner[0] = 0;
 518         else
 519                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old_id);
 520
 521         if (d->type == KDBUS_ITEM_NAME_REMOVE)
 522                 new_owner[0] = 0;
 523         else
 524                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new_id);
 525
 526         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
 527 }
 528
 529 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 530         char owner[UNIQUE_NAME_MAX];
 531
 532         assert(bus);
 533         assert(k);
 534         assert(d);
 535
 536         sprintf(owner, ":1.%llu", d->id_change.id);
 537
 538         return push_name_owner_changed(
 539                         bus, owner,
 540                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
 541                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
 542 }
 543
 544 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 545         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 546         int r;
 547
 548         assert(bus);
 549         assert(k);
 550         assert(d);
 551
 552         r = bus_message_new_synthetic_error(
 553                         bus,
 554                         k->cookie_reply,
 555                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
 556                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
 557                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
 558                         &m);
 559         if (r < 0)
 560                 return r;
 561
 562         m->sender = "org.freedesktop.DBus";
 563
 564         r = bus_seal_synthetic_message(bus, m);
 565         if (r < 0)
 566                 return r;
 567
 568         bus->rqueue[bus->rqueue_size++] = m;
 569         m = NULL;
 570
 571         return 1;
 572 }
 573
 574 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
 575         struct kdbus_item *d, *found = NULL;
 576
 577         static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
 578                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
 579                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
 580                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
 581
 582                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
 583                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
 584
 585                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
 586                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
 587         };
 588
 589         assert(bus);
 590         assert(k);
 591         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
 592
 593         KDBUS_ITEM_FOREACH(d, k, items) {
 594                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
 595                         if (found)
 596                                 return -EBADMSG;
 597                         found = d;
 598                 } else
 599                         log_debug("Got unknown field from kernel %llu", d->type);
 600         }
 601
 602         if (!found) {
 603                 log_debug("Didn't find a kernel message to translate.");
 604                 return 0;
 605         }
 606
 607         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
 608 }
 609
 610 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
 611         sd_bus_message *m = NULL;
 612         struct kdbus_item *d;
 613         unsigned n_fds = 0;
 614         _cleanup_free_ int *fds = NULL;
 615         struct bus_header *h = NULL;
 616         size_t total, n_bytes = 0, idx = 0;
 617         const char *destination = NULL, *seclabel = NULL;
 618         int r;
 619
 620         assert(bus);
 621         assert(k);
 622         assert(k->payload_type == KDBUS_PAYLOAD_DBUS);
 623
 624         KDBUS_ITEM_FOREACH(d, k, items) {
 625                 size_t l;
 626
 627                 l = d->size - offsetof(struct kdbus_item, data);
 628
 629                 switch (d->type) {
 630
 631                 case KDBUS_ITEM_PAYLOAD_OFF:
 632                         if (!h) {
 633                                 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
 634
 635                                 if (!bus_header_is_complete(h, d->vec.size))
 636                                         return -EBADMSG;
 637                         }
 638
 639                         n_bytes += d->vec.size;
 640                         break;
 641
 642                 case KDBUS_ITEM_PAYLOAD_MEMFD:
 643                         if (!h)
 644                                 return -EBADMSG;
 645
 646                         n_bytes += d->memfd.size;
 647                         break;
 648
 649                 case KDBUS_ITEM_FDS: {
 650                         int *f;
 651                         unsigned j;
 652
 653                         j = l / sizeof(int);
 654                         f = realloc(fds, sizeof(int) * (n_fds + j));
 655                         if (!f)
 656                                 return -ENOMEM;
 657
 658                         fds = f;
 659                         memcpy(fds + n_fds, d->fds, sizeof(int) * j);
 660                         n_fds += j;
 661                         break;
 662                 }
 663
 664                 case KDBUS_ITEM_SECLABEL:
 665                         seclabel = d->str;
 666                         break;
 667                 }
 668         }
 669
 670         if (!h)
 671                 return -EBADMSG;
 672
 673         r = bus_header_message_size(h, &total);
 674         if (r < 0)
 675                 return r;
 676
 677         if (n_bytes != total)
 678                 return -EBADMSG;
 679
 680         /* on kdbus we only speak native endian gvariant, never dbus1
 681          * marshalling or reverse endian */
 682         if (h->version != 2 ||
 683             h->endian != BUS_NATIVE_ENDIAN)
 684                 return -EPROTOTYPE;
 685
 686         r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
 687         if (r < 0)
 688                 return r;
 689
 690         KDBUS_ITEM_FOREACH(d, k, items) {
 691                 size_t l;
 692
 693                 l = d->size - offsetof(struct kdbus_item, data);
 694
 695                 switch (d->type) {
 696
 697                 case KDBUS_ITEM_PAYLOAD_OFF: {
 698                         size_t begin_body;
 699
 700                         begin_body = BUS_MESSAGE_BODY_BEGIN(m);
 701
 702                         if (idx + d->vec.size > begin_body) {
 703                                 struct bus_body_part *part;
 704
 705                                 /* Contains body material */
 706
 707                                 part = message_append_part(m);
 708                                 if (!part) {
 709                                         r = -ENOMEM;
 710                                         goto fail;
 711                                 }
 712
 713                                 /* A -1 offset is NUL padding. */
 714                                 part->is_zero = d->vec.offset == ~0ULL;
 715
 716                                 if (idx >= begin_body) {
 717                                         if (!part->is_zero)
 718                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
 719                                         part->size = d->vec.size;
 720                                 } else {
 721                                         if (!part->is_zero)
 722                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
 723                                         part->size = d->vec.size - (begin_body - idx);
 724                                 }
 725
 726                                 part->sealed = true;
 727                         }
 728
 729                         idx += d->vec.size;
 730                         break;
 731                 }
 732
 733                 case KDBUS_ITEM_PAYLOAD_MEMFD: {
 734                         struct bus_body_part *part;
 735
 736                         if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
 737                                 r = -EBADMSG;
 738                                 goto fail;
 739                         }
 740
 741                         part = message_append_part(m);
 742                         if (!part) {
 743                                 r = -ENOMEM;
 744                                 goto fail;
 745                         }
 746
 747                         part->memfd = d->memfd.fd;
 748                         part->size = d->memfd.size;
 749                         part->sealed = true;
 750
 751                         idx += d->memfd.size;
 752                         break;
 753                 }
 754
 755                 case KDBUS_ITEM_CREDS:
 756                         m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
 757                         m->creds.uid = d->creds.uid;
 758                         m->creds.gid = d->creds.gid;
 759                         m->creds.pid = d->creds.pid;
 760                         m->creds.tid = d->creds.tid;
 761                         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;
 762                         break;
 763
 764                 case KDBUS_ITEM_TIMESTAMP:
 765                         m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
 766                         m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
 767                         break;
 768
 769                 case KDBUS_ITEM_PID_COMM:
 770                         m->creds.comm = d->str;
 771                         m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
 772                         break;
 773
 774                 case KDBUS_ITEM_TID_COMM:
 775                         m->creds.tid_comm = d->str;
 776                         m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
 777                         break;
 778
 779                 case KDBUS_ITEM_EXE:
 780                         m->creds.exe = d->str;
 781                         m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
 782                         break;
 783
 784                 case KDBUS_ITEM_CMDLINE:
 785                         m->creds.cmdline = d->str;
 786                         m->creds.cmdline_size = l;
 787                         m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
 788                         break;
 789
 790                 case KDBUS_ITEM_CGROUP:
 791                         m->creds.cgroup = d->str;
 792                         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;
 793                         break;
 794
 795                 case KDBUS_ITEM_AUDIT:
 796                         m->creds.audit_session_id = d->audit.sessionid;
 797                         m->creds.audit_login_uid = d->audit.loginuid;
 798                         m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
 799                         break;
 800
 801                 case KDBUS_ITEM_CAPS:
 802                         m->creds.capability = d->data;
 803                         m->creds.capability_size = l;
 804                         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;
 805                         break;
 806
 807                 case KDBUS_ITEM_DST_NAME:
 808                         destination = d->str;
 809                         break;
 810
 811                 case KDBUS_ITEM_NAME:
 812                         r = strv_extend(&m->creds.well_known_names, d->name.name);
 813                         if (r < 0)
 814                                 goto fail;
 815                         m->creds.mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES & bus->creds_mask;
 816                         break;
 817
 818                 case KDBUS_ITEM_FDS:
 819                 case KDBUS_ITEM_SECLABEL:
 820                         break;
 821
 822                 default:
 823                         log_debug("Got unknown field from kernel %llu", d->type);
 824                 }
 825         }
 826
 827         r = bus_message_parse_fields(m);
 828         if (r < 0)
 829                 goto fail;
 830
 831         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 832                 m->sender = "org.freedesktop.DBus";
 833         else {
 834                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 835                 m->sender = m->creds.unique_name = m->sender_buffer;
 836                 m->creds.mask |= SD_BUS_CREDS_UNIQUE_NAME & bus->creds_mask;
 837         }
 838
 839         if (!m->destination) {
 840                 if (destination)
 841                         m->destination = destination;
 842                 else if (k->dst_id != KDBUS_DST_ID_NAME &&
 843                          k->dst_id != KDBUS_DST_ID_BROADCAST) {
 844                         snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 845                         m->destination = m->destination_buffer;
 846                 }
 847         }
 848
 849         /* We take possession of the kmsg struct now */
 850         m->kdbus = k;
 851         m->release_kdbus = true;
 852         m->free_fds = true;
 853         fds = NULL;
 854
 855         bus->rqueue[bus->rqueue_size++] = m;
 856
 857         return 1;
 858
 859 fail:
 860         if (m) {
 861                 struct bus_body_part *part;
 862                 unsigned i;
 863
 864                 /* Make sure the memfds are not freed twice */
 865                 MESSAGE_FOREACH_PART(part, i, m)
 866                         if (part->memfd >= 0)
 867                                 part->memfd = -1;
 868
 869                 sd_bus_message_unref(m);
 870         }
 871
 872         return r;
 873 }
 874
 875 int bus_kernel_read_message(sd_bus *bus) {
 876         struct kdbus_msg *k;
 877         uint64_t off;
 878         int r;
 879
 880         assert(bus);
 881
 882         r = bus_rqueue_make_room(bus);
 883         if (r < 0)
 884                 return r;
 885
 886         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
 887         if (r < 0) {
 888                 if (errno == EAGAIN)
 889                         return 0;
 890
 891                 return -errno;
 892         }
 893         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
 894
 895         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
 896                 r = bus_kernel_make_message(bus, k);
 897
 898                 /* Anybody can send us invalid messages, let's just drop them. */
 899                 if (r == -EBADMSG || r == -EPROTOTYPE) {
 900                         log_error("Ignoring invalid message: %s", strerror(-r));
 901                         r = 0;
 902                 }
 903
 904         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
 905                 r = bus_kernel_translate_message(bus, k);
 906         else
 907                 r = 0;
 908
 909         if (r <= 0)
 910                 close_kdbus_msg(bus, k);
 911
 912         return r < 0 ? r : 1;
 913 }
 914
 915 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *size) {
 916         struct memfd_cache *c;
 917         int fd;
 918
 919         assert(address);
 920         assert(size);
 921
 922         if (!bus || !bus->is_kernel)
 923                 return -ENOTSUP;
 924
 925         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
 926
 927         if (bus->n_memfd_cache <= 0) {
 928                 int r;
 929
 930                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 931
 932                 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
 933                 if (r < 0)
 934                         return -errno;
 935
 936                 *address = NULL;
 937                 *size = 0;
 938                 return fd;
 939         }
 940
 941         c = &bus->memfd_cache[--bus->n_memfd_cache];
 942
 943         assert(c->fd >= 0);
 944         assert(c->size == 0 || c->address);
 945
 946         *address = c->address;
 947         *size = c->size;
 948         fd = c->fd;
 949
 950         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 951
 952         return fd;
 953 }
 954
 955 static void close_and_munmap(int fd, void *address, size_t size) {
 956         if (size > 0)
 957                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
 958
 959         close_nointr_nofail(fd);
 960 }
 961
 962 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t size) {
 963         struct memfd_cache *c;
 964         uint64_t max_sz = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
 965
 966         assert(fd >= 0);
 967         assert(size == 0 || address);
 968
 969         if (!bus || !bus->is_kernel) {
 970                 close_and_munmap(fd, address, size);
 971                 return;
 972         }
 973
 974         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
 975
 976         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
 977                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 978
 979                 close_and_munmap(fd, address, size);
 980                 return;
 981         }
 982
 983         c = &bus->memfd_cache[bus->n_memfd_cache++];
 984         c->fd = fd;
 985         c->address = address;
 986
 987         /* If overly long, let's return a bit to the OS */
 988         if (size > max_sz) {
 989                 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_sz) >= 0);
 990                 assert_se(munmap((uint8_t*) address + max_sz, PAGE_ALIGN(size - max_sz)) >= 0);
 991                 c->size = max_sz;
 992         } else
 993                 c->size = size;
 994
 995         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 996 }
 997
 998 void bus_kernel_flush_memfd(sd_bus *b) {
 999         unsigned i;
1000
1001         assert(b);
1002
1003         for (i = 0; i < b->n_memfd_cache; i++)
1004                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].size);
1005 }
1006
1007 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1008         uint64_t f = 0;
1009
1010         assert(kdbus_flags);
1011
1012         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1013                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1014
1015         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1016                 f |= KDBUS_NAME_REPLACE_EXISTING;
1017
1018         if (!(flags & SD_BUS_NAME_DO_NOT_QUEUE))
1019                 f |= KDBUS_NAME_QUEUE;
1020
1021         *kdbus_flags = f;
1022         return 0;
1023 }
1024
1025 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1026         uint64_t m = 0;
1027
1028         assert(kdbus_mask);
1029
1030         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1031                 m |= KDBUS_ATTACH_CREDS;
1032
1033         if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1034                 m |= KDBUS_ATTACH_COMM;
1035
1036         if (mask & SD_BUS_CREDS_EXE)
1037                 m |= KDBUS_ATTACH_EXE;
1038
1039         if (mask & SD_BUS_CREDS_CMDLINE)
1040                 m |= KDBUS_ATTACH_CMDLINE;
1041
1042         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))
1043                 m |= KDBUS_ATTACH_CGROUP;
1044
1045         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1046                 m |= KDBUS_ATTACH_CAPS;
1047
1048         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1049                 m |= KDBUS_ATTACH_SECLABEL;
1050
1051         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1052                 m |= KDBUS_ATTACH_AUDIT;
1053
1054         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1055                 m |= KDBUS_ATTACH_NAMES;
1056
1057         *kdbus_mask = m;
1058         return 0;
1059 }
1060
1061 int bus_kernel_create_bus(const char *name, char **s) {
1062         struct kdbus_cmd_bus_make *make;
1063         struct kdbus_item *n;
1064         int fd;
1065
1066         assert(name);
1067         assert(s);
1068
1069         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1070         if (fd < 0)
1071                 return -errno;
1072
1073         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_bus_make, items) +
1074                               offsetof(struct kdbus_item, str) +
1075                               DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1076
1077         n = make->items;
1078         sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1079         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1080         n->type = KDBUS_ITEM_MAKE_NAME;
1081
1082         make->size = ALIGN8(offsetof(struct kdbus_cmd_bus_make, items) + n->size);
1083         make->flags = KDBUS_MAKE_POLICY_OPEN;
1084         make->bloom_size = BLOOM_SIZE;
1085         assert_cc(BLOOM_SIZE % 8 == 0);
1086
1087         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1088                 close_nointr_nofail(fd);
1089                 return -errno;
1090         }
1091
1092         /* The higher 32bit of the flags field are considered
1093          * 'incompatible flags'. Refuse them all for now. */
1094         if (make->flags > 0xFFFFFFFFULL) {
1095                 close_nointr_nofail(fd);
1096                 return -ENOTSUP;
1097         }
1098
1099         if (s) {
1100                 char *p;
1101
1102                 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1103                 if (!p) {
1104                         close_nointr_nofail(fd);
1105                         return -ENOMEM;
1106                 }
1107
1108                 *s = p;
1109         }
1110
1111         return fd;
1112 }
1113
1114 int bus_kernel_create_starter(const char *bus, const char *name) {
1115         struct kdbus_cmd_hello *hello;
1116         struct kdbus_item *n;
1117         char *p;
1118         int fd;
1119
1120         assert(bus);
1121         assert(name);
1122
1123         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1124         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1125
1126         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1127         if (fd < 0)
1128                 return -errno;
1129
1130         hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1131                                offsetof(struct kdbus_item, str) +
1132                                strlen(name) + 1));
1133
1134         n = hello->items;
1135         strcpy(n->str, name);
1136         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1137         n->type = KDBUS_ITEM_STARTER_NAME;
1138
1139         hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1140         hello->conn_flags = KDBUS_HELLO_STARTER;
1141         hello->pool_size = KDBUS_POOL_SIZE;
1142
1143         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1144                 close_nointr_nofail(fd);
1145                 return -errno;
1146         }
1147
1148         /* The higher 32bit of both flags fields are considered
1149          * 'incompatible flags'. Refuse them all for now. */
1150         if (hello->bus_flags > 0xFFFFFFFFULL ||
1151             hello->conn_flags > 0xFFFFFFFFULL) {
1152                 close_nointr_nofail(fd);
1153                 return -ENOTSUP;
1154         }
1155
1156         if (hello->bloom_size != BLOOM_SIZE) {
1157                 close_nointr_nofail(fd);
1158                 return -ENOTSUP;
1159         }
1160
1161         return fd;
1162 }
1163
1164 int bus_kernel_create_namespace(const char *name, char **s) {
1165         struct kdbus_cmd_ns_make *make;
1166         struct kdbus_item *n;
1167         int fd;
1168
1169         assert(name);
1170         assert(s);
1171
1172         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1173         if (fd < 0)
1174                 return -errno;
1175
1176         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_ns_make, items) +
1177                               offsetof(struct kdbus_item, str) +
1178                               strlen(name) + 1));
1179
1180         n = make->items;
1181         strcpy(n->str, name);
1182         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1183         n->type = KDBUS_ITEM_MAKE_NAME;
1184
1185         make->size = ALIGN8(offsetof(struct kdbus_cmd_ns_make, items) + n->size);
1186         make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1187
1188         if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1189                 close_nointr_nofail(fd);
1190                 return -errno;
1191         }
1192
1193         /* The higher 32bit of the flags field are considered
1194          * 'incompatible flags'. Refuse them all for now. */
1195         if (make->flags > 0xFFFFFFFFULL) {
1196                 close_nointr_nofail(fd);
1197                 return -ENOTSUP;
1198         }
1199
1200         if (s) {
1201                 char *p;
1202
1203                 p = strappend("/dev/kdbus/ns/", name);
1204                 if (!p) {
1205                         close_nointr_nofail(fd);
1206                         return -ENOMEM;
1207                 }
1208
1209                 *s = p;
1210         }
1211
1212         return fd;
1213 }