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_MSG_RELEASE, &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 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
 609
 610         uint64_t m = 0;
 611
 612         SET_FLAG(m, KDBUS_ATTACH_CREDS,
 613                  !!(mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID)));
 614
 615         SET_FLAG(m, KDBUS_ATTACH_COMM,
 616                  !!(mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM)));
 617
 618         SET_FLAG(m, KDBUS_ATTACH_EXE,
 619                  !!(mask & SD_BUS_CREDS_EXE));
 620
 621         SET_FLAG(m, KDBUS_ATTACH_CMDLINE,
 622                  !!(mask & SD_BUS_CREDS_CMDLINE));
 623
 624         SET_FLAG(m, KDBUS_ATTACH_CGROUP,
 625                  !!(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)));
 626
 627         SET_FLAG(m, KDBUS_ATTACH_CAPS,
 628                  !!(mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS)));
 629
 630         SET_FLAG(m, KDBUS_ATTACH_SECLABEL,
 631                  !!(mask & SD_BUS_CREDS_SELINUX_CONTEXT));
 632
 633         SET_FLAG(m, KDBUS_ATTACH_AUDIT,
 634                  !!(mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID)));
 635
 636         *kdbus_mask = m;
 637
 638         return 0;
 639 }
 640
 641 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k) {
 642         sd_bus_message *m = NULL;
 643         struct kdbus_item *d;
 644         unsigned n_fds = 0;
 645         _cleanup_free_ int *fds = NULL;
 646         struct bus_header *h = NULL;
 647         size_t total, n_bytes = 0, idx = 0;
 648         const char *destination = NULL, *seclabel = NULL;
 649         int r;
 650
 651         assert(bus);
 652         assert(k);
 653         assert(k->payload_type == KDBUS_PAYLOAD_DBUS1);
 654
 655         KDBUS_PART_FOREACH(d, k, items) {
 656                 size_t l;
 657
 658                 l = d->size - offsetof(struct kdbus_item, data);
 659
 660                 switch (d->type) {
 661
 662                 case KDBUS_ITEM_PAYLOAD_OFF:
 663                         if (!h) {
 664                                 h = (struct bus_header *)((uint8_t *)bus->kdbus_buffer + d->vec.offset);
 665
 666                                 if (!bus_header_is_complete(h, d->vec.size))
 667                                         return -EBADMSG;
 668                         }
 669
 670                         n_bytes += d->vec.size;
 671                         break;
 672
 673                 case KDBUS_ITEM_PAYLOAD_MEMFD:
 674                         if (!h)
 675                                 return -EBADMSG;
 676
 677                         n_bytes += d->memfd.size;
 678                         break;
 679
 680                 case KDBUS_ITEM_FDS: {
 681                         int *f;
 682                         unsigned j;
 683
 684                         j = l / sizeof(int);
 685                         f = realloc(fds, sizeof(int) * (n_fds + j));
 686                         if (!f)
 687                                 return -ENOMEM;
 688
 689                         fds = f;
 690                         memcpy(fds + n_fds, d->fds, sizeof(int) * j);
 691                         n_fds += j;
 692                         break;
 693                 }
 694
 695                 case KDBUS_ITEM_SECLABEL:
 696                         seclabel = d->str;
 697                         break;
 698                 }
 699         }
 700
 701         if (!h)
 702                 return -EBADMSG;
 703
 704         r = bus_header_message_size(h, &total);
 705         if (r < 0)
 706                 return r;
 707
 708         if (n_bytes != total)
 709                 return -EBADMSG;
 710
 711         r = bus_message_from_header(bus, h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
 712         if (r < 0)
 713                 return r;
 714
 715         KDBUS_PART_FOREACH(d, k, items) {
 716                 size_t l;
 717
 718                 l = d->size - offsetof(struct kdbus_item, data);
 719
 720                 switch (d->type) {
 721
 722                 case KDBUS_ITEM_PAYLOAD_OFF: {
 723                         size_t begin_body;
 724
 725                         begin_body = BUS_MESSAGE_BODY_BEGIN(m);
 726
 727                         if (idx + d->vec.size > begin_body) {
 728                                 struct bus_body_part *part;
 729
 730                                 /* Contains body material */
 731
 732                                 part = message_append_part(m);
 733                                 if (!part) {
 734                                         r = -ENOMEM;
 735                                         goto fail;
 736                                 }
 737
 738                                 /* A -1 offset is NUL padding. */
 739                                 part->is_zero = d->vec.offset == ~0ULL;
 740
 741                                 if (idx >= begin_body) {
 742                                         if (!part->is_zero)
 743                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset;
 744                                         part->size = d->vec.size;
 745                                 } else {
 746                                         if (!part->is_zero)
 747                                                 part->data = (uint8_t *)bus->kdbus_buffer + d->vec.offset + (begin_body - idx);
 748                                         part->size = d->vec.size - (begin_body - idx);
 749                                 }
 750
 751                                 part->sealed = true;
 752                         }
 753
 754                         idx += d->vec.size;
 755                         break;
 756                 }
 757
 758                 case KDBUS_ITEM_PAYLOAD_MEMFD: {
 759                         struct bus_body_part *part;
 760
 761                         if (idx < BUS_MESSAGE_BODY_BEGIN(m)) {
 762                                 r = -EBADMSG;
 763                                 goto fail;
 764                         }
 765
 766                         part = message_append_part(m);
 767                         if (!part) {
 768                                 r = -ENOMEM;
 769                                 goto fail;
 770                         }
 771
 772                         part->memfd = d->memfd.fd;
 773                         part->size = d->memfd.size;
 774                         part->sealed = true;
 775
 776                         idx += d->memfd.size;
 777                         break;
 778                 }
 779
 780                 case KDBUS_ITEM_CREDS:
 781                         m->creds.pid_starttime = d->creds.starttime / NSEC_PER_USEC;
 782                         m->creds.uid = d->creds.uid;
 783                         m->creds.gid = d->creds.gid;
 784                         m->creds.pid = d->creds.pid;
 785                         m->creds.tid = d->creds.tid;
 786                         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;
 787                         break;
 788
 789                 case KDBUS_ITEM_TIMESTAMP:
 790                         m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
 791                         m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
 792                         break;
 793
 794                 case KDBUS_ITEM_PID_COMM:
 795                         m->creds.comm = d->str;
 796                         m->creds.mask |= SD_BUS_CREDS_COMM & bus->creds_mask;
 797                         break;
 798
 799                 case KDBUS_ITEM_TID_COMM:
 800                         m->creds.tid_comm = d->str;
 801                         m->creds.mask |= SD_BUS_CREDS_TID_COMM & bus->creds_mask;
 802                         break;
 803
 804                 case KDBUS_ITEM_EXE:
 805                         m->creds.exe = d->str;
 806                         m->creds.mask |= SD_BUS_CREDS_EXE & bus->creds_mask;
 807                         break;
 808
 809                 case KDBUS_ITEM_CMDLINE:
 810                         m->creds.cmdline = d->str;
 811                         m->creds.cmdline_length = l;
 812                         m->creds.mask |= SD_BUS_CREDS_CMDLINE & bus->creds_mask;
 813                         break;
 814
 815                 case KDBUS_ITEM_CGROUP:
 816                         m->creds.cgroup = d->str;
 817                         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;
 818                         break;
 819
 820                 case KDBUS_ITEM_AUDIT:
 821                         m->creds.audit_session_id = d->audit.sessionid;
 822                         m->creds.audit_login_uid = d->audit.loginuid;
 823                         m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
 824                         break;
 825
 826                 case KDBUS_ITEM_CAPS:
 827                         m->creds.capability = d->data;
 828                         m->creds.capability_size = l;
 829                         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;
 830                         break;
 831
 832                 case KDBUS_ITEM_DST_NAME:
 833                         destination = d->str;
 834                         break;
 835
 836                 case KDBUS_ITEM_FDS:
 837                 case KDBUS_ITEM_SECLABEL:
 838                 case KDBUS_ITEM_NAMES:
 839                         break;
 840
 841                 default:
 842                         log_debug("Got unknown field from kernel %llu", d->type);
 843                 }
 844         }
 845
 846         r = bus_message_parse_fields(m);
 847         if (r < 0)
 848                 goto fail;
 849
 850         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 851                 m->sender = "org.freedesktop.DBus";
 852         else {
 853                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 854                 m->sender = m->sender_buffer;
 855         }
 856
 857         if (!m->destination) {
 858                 if (destination)
 859                         m->destination = destination;
 860                 else if (k->dst_id != KDBUS_DST_ID_WELL_KNOWN_NAME &&
 861                          k->dst_id != KDBUS_DST_ID_BROADCAST) {
 862                         snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 863                         m->destination = m->destination_buffer;
 864                 }
 865         }
 866
 867         /* We take possession of the kmsg struct now */
 868         m->kdbus = k;
 869         m->release_kdbus = true;
 870         m->free_fds = true;
 871         fds = NULL;
 872
 873         bus->rqueue[bus->rqueue_size++] = m;
 874
 875         return 1;
 876
 877 fail:
 878         if (m) {
 879                 struct bus_body_part *part;
 880                 unsigned i;
 881
 882                 /* Make sure the memfds are not freed twice */
 883                 MESSAGE_FOREACH_PART(part, i, m)
 884                         if (part->memfd >= 0)
 885                                 part->memfd = -1;
 886
 887                 sd_bus_message_unref(m);
 888         }
 889
 890         return r;
 891 }
 892
 893 int bus_kernel_read_message(sd_bus *bus) {
 894         struct kdbus_msg *k;
 895         uint64_t off;
 896         int r;
 897
 898         assert(bus);
 899
 900         r = bus_rqueue_make_room(bus);
 901         if (r < 0)
 902                 return r;
 903
 904         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
 905         if (r < 0) {
 906                 if (errno == EAGAIN)
 907                         return 0;
 908
 909                 return -errno;
 910         }
 911         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
 912
 913         if (k->payload_type == KDBUS_PAYLOAD_DBUS1)
 914                 r = bus_kernel_make_message(bus, k);
 915         else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
 916                 r = bus_kernel_translate_message(bus, k);
 917         else
 918                 r = 0;
 919
 920         if (r <= 0)
 921                 close_kdbus_msg(bus, k);
 922
 923         return r < 0 ? r : 1;
 924 }
 925
 926 int bus_kernel_create(const char *name, char **s) {
 927         struct kdbus_cmd_bus_make *make;
 928         struct kdbus_item *n;
 929         size_t l;
 930         int fd;
 931         char *p;
 932
 933         assert(name);
 934         assert(s);
 935
 936         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
 937         if (fd < 0)
 938                 return -errno;
 939
 940         l = strlen(name);
 941         make = alloca0(offsetof(struct kdbus_cmd_bus_make, items) +
 942                        KDBUS_PART_HEADER_SIZE + sizeof(uint64_t) +
 943                        KDBUS_PART_HEADER_SIZE + DECIMAL_STR_MAX(uid_t) + 1 + l + 1);
 944
 945         n = make->items;
 946         n->type = KDBUS_MAKE_NAME;
 947         sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
 948         n->size = KDBUS_PART_HEADER_SIZE + strlen(n->str) + 1;
 949
 950         make->size = offsetof(struct kdbus_cmd_bus_make, items) + n->size;
 951         make->flags = KDBUS_MAKE_POLICY_OPEN;
 952         make->bus_flags = 0;
 953         make->bloom_size = BLOOM_SIZE;
 954         assert_cc(BLOOM_SIZE % 8 == 0);
 955
 956         p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
 957         if (!p)
 958                 return -ENOMEM;
 959
 960         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
 961                 close_nointr_nofail(fd);
 962                 free(p);
 963                 return -errno;
 964         }
 965
 966         if (s)
 967                 *s = p;
 968
 969         return fd;
 970 }
 971
 972 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *size) {
 973         struct memfd_cache *c;
 974         int fd;
 975
 976         assert(address);
 977         assert(size);
 978
 979         if (!bus || !bus->is_kernel)
 980                 return -ENOTSUP;
 981
 982         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
 983
 984         if (bus->n_memfd_cache <= 0) {
 985                 int r;
 986
 987                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
 988
 989                 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
 990                 if (r < 0)
 991                         return -errno;
 992
 993                 *address = NULL;
 994                 *size = 0;
 995                 return fd;
 996         }
 997
 998         c = &bus->memfd_cache[--bus->n_memfd_cache];
 999
1000         assert(c->fd >= 0);
1001         assert(c->size == 0 || c->address);
1002
1003         *address = c->address;
1004         *size = c->size;
1005         fd = c->fd;
1006
1007         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1008
1009         return fd;
1010 }
1011
1012 static void close_and_munmap(int fd, void *address, size_t size) {
1013         if (size > 0)
1014                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1015
1016         close_nointr_nofail(fd);
1017 }
1018
1019 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t size) {
1020         struct memfd_cache *c;
1021         uint64_t max_sz = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1022
1023         assert(fd >= 0);
1024         assert(size == 0 || address);
1025
1026         if (!bus || !bus->is_kernel) {
1027                 close_and_munmap(fd, address, size);
1028                 return;
1029         }
1030
1031         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1032
1033         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1034                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1035
1036                 close_and_munmap(fd, address, size);
1037                 return;
1038         }
1039
1040         c = &bus->memfd_cache[bus->n_memfd_cache++];
1041         c->fd = fd;
1042         c->address = address;
1043
1044         /* If overly long, let's return a bit to the OS */
1045         if (size > max_sz) {
1046                 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_sz) >= 0);
1047                 assert_se(munmap((uint8_t*) address + max_sz, PAGE_ALIGN(size - max_sz)) >= 0);
1048                 c->size = max_sz;
1049         } else
1050                 c->size = size;
1051
1052         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1053 }
1054
1055 void bus_kernel_flush_memfd(sd_bus *b) {
1056         unsigned i;
1057
1058         assert(b);
1059
1060         for (i = 0; i < b->n_memfd_cache; i++)
1061                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].size);
1062 }
1063
1064 int kdbus_translate_request_name_flags(uint64_t sd_bus_flags, uint64_t *kdbus_flags) {
1065
1066         assert_return(kdbus_flags != NULL, -EINVAL);
1067
1068         *kdbus_flags = 0;
1069
1070         if (sd_bus_flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1071                 *kdbus_flags |= KDBUS_NAME_ALLOW_REPLACEMENT;
1072
1073         if (sd_bus_flags & SD_BUS_NAME_REPLACE_EXISTING)
1074                 *kdbus_flags |= KDBUS_NAME_REPLACE_EXISTING;
1075
1076         if (!(sd_bus_flags & SD_BUS_NAME_DO_NOT_QUEUE))
1077                 *kdbus_flags |= KDBUS_NAME_QUEUE;
1078
1079         return 0;
1080 }