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