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