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