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 #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                 int r;
1004
1005                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1006
1007                 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
1008                 if (r < 0)
1009                         return -errno;
1010
1011                 *address = NULL;
1012                 *mapped = 0;
1013                 *allocated = 0;
1014                 return fd;
1015         }
1016
1017         c = &bus->memfd_cache[--bus->n_memfd_cache];
1018
1019         assert(c->fd >= 0);
1020         assert(c->mapped == 0 || c->address);
1021
1022         *address = c->address;
1023         *mapped = c->mapped;
1024         *allocated = c->allocated;
1025         fd = c->fd;
1026
1027         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1028
1029         return fd;
1030 }
1031
1032 static void close_and_munmap(int fd, void *address, size_t size) {
1033         if (size > 0)
1034                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1035
1036         close_nointr_nofail(fd);
1037 }
1038
1039 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1040         struct memfd_cache *c;
1041         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1042
1043         assert(fd >= 0);
1044         assert(mapped == 0 || address);
1045
1046         if (!bus || !bus->is_kernel) {
1047                 close_and_munmap(fd, address, mapped);
1048                 return;
1049         }
1050
1051         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1052
1053         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1054                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1055
1056                 close_and_munmap(fd, address, mapped);
1057                 return;
1058         }
1059
1060         c = &bus->memfd_cache[bus->n_memfd_cache++];
1061         c->fd = fd;
1062         c->address = address;
1063
1064         /* If overly long, let's return a bit to the OS */
1065         if (mapped > max_mapped) {
1066                 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1067                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1068                 c->mapped = c->allocated = max_mapped;
1069         } else {
1070                 c->mapped = mapped;
1071                 c->allocated = allocated;
1072         }
1073
1074         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1075 }
1076
1077 void bus_kernel_flush_memfd(sd_bus *b) {
1078         unsigned i;
1079
1080         assert(b);
1081
1082         for (i = 0; i < b->n_memfd_cache; i++)
1083                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1084 }
1085
1086 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1087         uint64_t f = 0;
1088
1089         assert(kdbus_flags);
1090
1091         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1092                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1093
1094         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1095                 f |= KDBUS_NAME_REPLACE_EXISTING;
1096
1097         if (flags & SD_BUS_NAME_QUEUE)
1098                 f |= KDBUS_NAME_QUEUE;
1099
1100         *kdbus_flags = f;
1101         return 0;
1102 }
1103
1104 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1105         uint64_t m = 0;
1106
1107         assert(kdbus_mask);
1108
1109         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1110                 m |= KDBUS_ATTACH_CREDS;
1111
1112         if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1113                 m |= KDBUS_ATTACH_COMM;
1114
1115         if (mask & SD_BUS_CREDS_EXE)
1116                 m |= KDBUS_ATTACH_EXE;
1117
1118         if (mask & SD_BUS_CREDS_CMDLINE)
1119                 m |= KDBUS_ATTACH_CMDLINE;
1120
1121         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))
1122                 m |= KDBUS_ATTACH_CGROUP;
1123
1124         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1125                 m |= KDBUS_ATTACH_CAPS;
1126
1127         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1128                 m |= KDBUS_ATTACH_SECLABEL;
1129
1130         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1131                 m |= KDBUS_ATTACH_AUDIT;
1132
1133         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1134                 m |= KDBUS_ATTACH_NAMES;
1135
1136         *kdbus_mask = m;
1137         return 0;
1138 }
1139
1140 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1141         struct kdbus_cmd_make *make;
1142         struct kdbus_item *n;
1143         int fd;
1144
1145         assert(name);
1146         assert(s);
1147
1148         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1149         if (fd < 0)
1150                 return -errno;
1151
1152         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1153                               offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1154                               offsetof(struct kdbus_item, str) +
1155                               DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1156
1157         make->size = offsetof(struct kdbus_cmd_make, items);
1158
1159         n = make->items;
1160         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1161         n->type = KDBUS_ITEM_BLOOM_SIZE;
1162         n->data64[0] = BLOOM_SIZE;
1163         assert_cc(BLOOM_SIZE % 8 == 0);
1164         make->size += ALIGN8(n->size);
1165
1166         n = KDBUS_ITEM_NEXT(n);
1167         sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1168         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1169         n->type = KDBUS_ITEM_MAKE_NAME;
1170         make->size += ALIGN8(n->size);
1171
1172         make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
1173
1174         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1175                 close_nointr_nofail(fd);
1176                 return -errno;
1177         }
1178
1179         /* The higher 32bit of the flags field are considered
1180          * 'incompatible flags'. Refuse them all for now. */
1181         if (make->flags > 0xFFFFFFFFULL) {
1182                 close_nointr_nofail(fd);
1183                 return -ENOTSUP;
1184         }
1185
1186         if (s) {
1187                 char *p;
1188
1189                 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1190                 if (!p) {
1191                         close_nointr_nofail(fd);
1192                         return -ENOMEM;
1193                 }
1194
1195                 *s = p;
1196         }
1197
1198         return fd;
1199 }
1200
1201 int bus_kernel_create_starter(const char *bus, const char *name) {
1202         struct kdbus_cmd_hello *hello;
1203         struct kdbus_item *n;
1204         char *p;
1205         int fd;
1206
1207         assert(bus);
1208         assert(name);
1209
1210         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1211         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1212
1213         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1214         if (fd < 0)
1215                 return -errno;
1216
1217         hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1218                                offsetof(struct kdbus_item, str) +
1219                                strlen(name) + 1));
1220
1221         n = hello->items;
1222         strcpy(n->str, name);
1223         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1224         n->type = KDBUS_ITEM_NAME;
1225
1226         hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1227         hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1228         hello->pool_size = KDBUS_POOL_SIZE;
1229
1230         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1231                 close_nointr_nofail(fd);
1232                 return -errno;
1233         }
1234
1235         /* The higher 32bit of both flags fields are considered
1236          * 'incompatible flags'. Refuse them all for now. */
1237         if (hello->bus_flags > 0xFFFFFFFFULL ||
1238             hello->conn_flags > 0xFFFFFFFFULL) {
1239                 close_nointr_nofail(fd);
1240                 return -ENOTSUP;
1241         }
1242
1243         if (hello->bloom_size != BLOOM_SIZE) {
1244                 close_nointr_nofail(fd);
1245                 return -ENOTSUP;
1246         }
1247
1248         return fd;
1249 }
1250
1251 int bus_kernel_create_namespace(const char *name, char **s) {
1252         struct kdbus_cmd_make *make;
1253         struct kdbus_item *n;
1254         int fd;
1255
1256         assert(name);
1257         assert(s);
1258
1259         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1260         if (fd < 0)
1261                 return -errno;
1262
1263         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1264                               offsetof(struct kdbus_item, str) +
1265                               strlen(name) + 1));
1266
1267         n = make->items;
1268         strcpy(n->str, name);
1269         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1270         n->type = KDBUS_ITEM_MAKE_NAME;
1271
1272         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1273         make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1274
1275         if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1276                 close_nointr_nofail(fd);
1277                 return -errno;
1278         }
1279
1280         /* The higher 32bit of the flags field are considered
1281          * 'incompatible flags'. Refuse them all for now. */
1282         if (make->flags > 0xFFFFFFFFULL) {
1283                 close_nointr_nofail(fd);
1284                 return -ENOTSUP;
1285         }
1286
1287         if (s) {
1288                 char *p;
1289
1290                 p = strappend("/dev/kdbus/ns/", name);
1291                 if (!p) {
1292                         close_nointr_nofail(fd);
1293                         return -ENOMEM;
1294                 }
1295
1296                 *s = p;
1297         }
1298
1299         return fd;
1300 }
1301
1302 int bus_kernel_create_monitor(const char *bus) {
1303         struct kdbus_cmd_hello *hello;
1304         char *p;
1305         int fd;
1306
1307         assert(bus);
1308
1309         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1310         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1311
1312         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1313         if (fd < 0)
1314                 return -errno;
1315
1316         hello = alloca0(sizeof(struct kdbus_cmd_hello));
1317         hello->size = sizeof(struct kdbus_cmd_hello);
1318         hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1319         hello->pool_size = KDBUS_POOL_SIZE;
1320
1321         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1322                 close_nointr_nofail(fd);
1323                 return -errno;
1324         }
1325
1326         /* The higher 32bit of both flags fields are considered
1327          * 'incompatible flags'. Refuse them all for now. */
1328         if (hello->bus_flags > 0xFFFFFFFFULL ||
1329             hello->conn_flags > 0xFFFFFFFFULL) {
1330                 close_nointr_nofail(fd);
1331                 return -ENOTSUP;
1332         }
1333
1334         return fd;
1335 }
1336
1337 int bus_kernel_try_close(sd_bus *bus) {
1338         assert(bus);
1339         assert(bus->is_kernel);
1340
1341         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1342                 return -errno;
1343
1344         return 0;
1345 }