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         if (m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
 262                 m->kdbus->cookie_reply = m->reply_serial;
 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_SERIAL(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 = d->creds.uid;
 802                         m->creds.gid = d->creds.gid;
 803                         m->creds.pid = 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 = 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 = d->audit.sessionid;
 865                         m->creds.audit_login_uid = 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                         destination = d->str;
 877                         break;
 878
 879                 case KDBUS_ITEM_NAME:
 880                         r = strv_extend(&m->creds.well_known_names, d->name.name);
 881                         if (r < 0)
 882                                 goto fail;
 883                         break;
 884
 885                 case KDBUS_ITEM_FDS:
 886                 case KDBUS_ITEM_SECLABEL:
 887                         break;
 888
 889                 default:
 890                         log_debug("Got unknown field from kernel %llu", d->type);
 891                 }
 892         }
 893
 894         r = bus_message_parse_fields(m);
 895         if (r < 0)
 896                 goto fail;
 897
 898         /* Override information from the user header with data from the kernel */
 899         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 900                 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
 901         else {
 902                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 903                 m->sender = m->creds.unique_name = m->sender_buffer;
 904         }
 905
 906         if (destination)
 907                 m->destination = destination;
 908         else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
 909                 m->destination = NULL;
 910         else if (k->dst_id == KDBUS_DST_ID_NAME)
 911                 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
 912         else {
 913                 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 914                 m->destination = m->destination_buffer;
 915         }
 916
 917         /* We take possession of the kmsg struct now */
 918         m->kdbus = k;
 919         m->release_kdbus = true;
 920         m->free_fds = true;
 921         fds = NULL;
 922
 923         bus->rqueue[bus->rqueue_size++] = m;
 924
 925         return 1;
 926
 927 fail:
 928         if (m) {
 929                 struct bus_body_part *part;
 930                 unsigned i;
 931
 932                 /* Make sure the memfds are not freed twice */
 933                 MESSAGE_FOREACH_PART(part, i, m)
 934                         if (part->memfd >= 0)
 935                                 part->memfd = -1;
 936
 937                 sd_bus_message_unref(m);
 938         }
 939
 940         return r;
 941 }
 942
 943 int bus_kernel_read_message(sd_bus *bus) {
 944         struct kdbus_msg *k;
 945         uint64_t off;
 946         int r;
 947
 948         assert(bus);
 949
 950         r = bus_rqueue_make_room(bus);
 951         if (r < 0)
 952                 return r;
 953
 954         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &off);
 955         if (r < 0) {
 956                 if (errno == EAGAIN)
 957                         return 0;
 958
 959                 return -errno;
 960         }
 961         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + off);
 962
 963         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
 964                 r = bus_kernel_make_message(bus, k);
 965
 966                 /* Anybody can send us invalid messages, let's just drop them. */
 967                 if (r == -EBADMSG || r == -EPROTOTYPE) {
 968                         log_debug("Ignoring invalid message: %s", strerror(-r));
 969                         r = 0;
 970                 }
 971
 972         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
 973                 r = bus_kernel_translate_message(bus, k);
 974         else
 975                 r = 0;
 976
 977         if (r <= 0)
 978                 close_kdbus_msg(bus, k);
 979
 980         return r < 0 ? r : 1;
 981 }
 982
 983 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
 984         struct memfd_cache *c;
 985         int fd;
 986
 987         assert(address);
 988         assert(mapped);
 989         assert(allocated);
 990
 991         if (!bus || !bus->is_kernel)
 992                 return -ENOTSUP;
 993
 994         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
 995
 996         if (bus->n_memfd_cache <= 0) {
 997                 int r;
 998
 999                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1000
1001                 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, &fd);
1002                 if (r < 0)
1003                         return -errno;
1004
1005                 *address = NULL;
1006                 *mapped = 0;
1007                 *allocated = 0;
1008                 return fd;
1009         }
1010
1011         c = &bus->memfd_cache[--bus->n_memfd_cache];
1012
1013         assert(c->fd >= 0);
1014         assert(c->mapped == 0 || c->address);
1015
1016         *address = c->address;
1017         *mapped = c->mapped;
1018         *allocated = c->allocated;
1019         fd = c->fd;
1020
1021         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1022
1023         return fd;
1024 }
1025
1026 static void close_and_munmap(int fd, void *address, size_t size) {
1027         if (size > 0)
1028                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1029
1030         close_nointr_nofail(fd);
1031 }
1032
1033 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1034         struct memfd_cache *c;
1035         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1036
1037         assert(fd >= 0);
1038         assert(mapped == 0 || address);
1039
1040         if (!bus || !bus->is_kernel) {
1041                 close_and_munmap(fd, address, mapped);
1042                 return;
1043         }
1044
1045         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1046
1047         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1048                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1049
1050                 close_and_munmap(fd, address, mapped);
1051                 return;
1052         }
1053
1054         c = &bus->memfd_cache[bus->n_memfd_cache++];
1055         c->fd = fd;
1056         c->address = address;
1057
1058         /* If overly long, let's return a bit to the OS */
1059         if (mapped > max_mapped) {
1060                 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1061                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1062                 c->mapped = c->allocated = max_mapped;
1063         } else {
1064                 c->mapped = mapped;
1065                 c->allocated = allocated;
1066         }
1067
1068         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1069 }
1070
1071 void bus_kernel_flush_memfd(sd_bus *b) {
1072         unsigned i;
1073
1074         assert(b);
1075
1076         for (i = 0; i < b->n_memfd_cache; i++)
1077                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1078 }
1079
1080 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1081         uint64_t f = 0;
1082
1083         assert(kdbus_flags);
1084
1085         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1086                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1087
1088         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1089                 f |= KDBUS_NAME_REPLACE_EXISTING;
1090
1091         if (flags & SD_BUS_NAME_QUEUE)
1092                 f |= KDBUS_NAME_QUEUE;
1093
1094         *kdbus_flags = f;
1095         return 0;
1096 }
1097
1098 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1099         uint64_t m = 0;
1100
1101         assert(kdbus_mask);
1102
1103         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1104                 m |= KDBUS_ATTACH_CREDS;
1105
1106         if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1107                 m |= KDBUS_ATTACH_COMM;
1108
1109         if (mask & SD_BUS_CREDS_EXE)
1110                 m |= KDBUS_ATTACH_EXE;
1111
1112         if (mask & SD_BUS_CREDS_CMDLINE)
1113                 m |= KDBUS_ATTACH_CMDLINE;
1114
1115         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))
1116                 m |= KDBUS_ATTACH_CGROUP;
1117
1118         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1119                 m |= KDBUS_ATTACH_CAPS;
1120
1121         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1122                 m |= KDBUS_ATTACH_SECLABEL;
1123
1124         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1125                 m |= KDBUS_ATTACH_AUDIT;
1126
1127         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1128                 m |= KDBUS_ATTACH_NAMES;
1129
1130         *kdbus_mask = m;
1131         return 0;
1132 }
1133
1134 int bus_kernel_create_bus(const char *name, char **s) {
1135         struct kdbus_cmd_make *make;
1136         struct kdbus_item *n;
1137         int fd;
1138
1139         assert(name);
1140         assert(s);
1141
1142         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1143         if (fd < 0)
1144                 return -errno;
1145
1146         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1147                               offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1148                               offsetof(struct kdbus_item, str) +
1149                               DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1150
1151         make->size = offsetof(struct kdbus_cmd_make, items);
1152
1153         n = make->items;
1154         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1155         n->type = KDBUS_ITEM_BLOOM_SIZE;
1156         n->data64[0] = BLOOM_SIZE;
1157         assert_cc(BLOOM_SIZE % 8 == 0);
1158         make->size += ALIGN8(n->size);
1159
1160         n = KDBUS_ITEM_NEXT(n);
1161         sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1162         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1163         n->type = KDBUS_ITEM_MAKE_NAME;
1164         make->size += ALIGN8(n->size);
1165
1166         make->flags = KDBUS_MAKE_POLICY_OPEN;
1167
1168         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1169                 close_nointr_nofail(fd);
1170                 return -errno;
1171         }
1172
1173         /* The higher 32bit of the flags field are considered
1174          * 'incompatible flags'. Refuse them all for now. */
1175         if (make->flags > 0xFFFFFFFFULL) {
1176                 close_nointr_nofail(fd);
1177                 return -ENOTSUP;
1178         }
1179
1180         if (s) {
1181                 char *p;
1182
1183                 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1184                 if (!p) {
1185                         close_nointr_nofail(fd);
1186                         return -ENOMEM;
1187                 }
1188
1189                 *s = p;
1190         }
1191
1192         return fd;
1193 }
1194
1195 int bus_kernel_create_starter(const char *bus, const char *name) {
1196         struct kdbus_cmd_hello *hello;
1197         struct kdbus_item *n;
1198         char *p;
1199         int fd;
1200
1201         assert(bus);
1202         assert(name);
1203
1204         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1205         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1206
1207         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1208         if (fd < 0)
1209                 return -errno;
1210
1211         hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1212                                offsetof(struct kdbus_item, str) +
1213                                strlen(name) + 1));
1214
1215         n = hello->items;
1216         strcpy(n->str, name);
1217         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1218         n->type = KDBUS_ITEM_NAME;
1219
1220         hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1221         hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1222         hello->pool_size = KDBUS_POOL_SIZE;
1223
1224         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1225                 close_nointr_nofail(fd);
1226                 return -errno;
1227         }
1228
1229         /* The higher 32bit of both flags fields are considered
1230          * 'incompatible flags'. Refuse them all for now. */
1231         if (hello->bus_flags > 0xFFFFFFFFULL ||
1232             hello->conn_flags > 0xFFFFFFFFULL) {
1233                 close_nointr_nofail(fd);
1234                 return -ENOTSUP;
1235         }
1236
1237         if (hello->bloom_size != BLOOM_SIZE) {
1238                 close_nointr_nofail(fd);
1239                 return -ENOTSUP;
1240         }
1241
1242         return fd;
1243 }
1244
1245 int bus_kernel_create_namespace(const char *name, char **s) {
1246         struct kdbus_cmd_make *make;
1247         struct kdbus_item *n;
1248         int fd;
1249
1250         assert(name);
1251         assert(s);
1252
1253         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1254         if (fd < 0)
1255                 return -errno;
1256
1257         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1258                               offsetof(struct kdbus_item, str) +
1259                               strlen(name) + 1));
1260
1261         n = make->items;
1262         strcpy(n->str, name);
1263         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1264         n->type = KDBUS_ITEM_MAKE_NAME;
1265
1266         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1267         make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1268
1269         if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1270                 close_nointr_nofail(fd);
1271                 return -errno;
1272         }
1273
1274         /* The higher 32bit of the flags field are considered
1275          * 'incompatible flags'. Refuse them all for now. */
1276         if (make->flags > 0xFFFFFFFFULL) {
1277                 close_nointr_nofail(fd);
1278                 return -ENOTSUP;
1279         }
1280
1281         if (s) {
1282                 char *p;
1283
1284                 p = strappend("/dev/kdbus/ns/", name);
1285                 if (!p) {
1286                         close_nointr_nofail(fd);
1287                         return -ENOMEM;
1288                 }
1289
1290                 *s = p;
1291         }
1292
1293         return fd;
1294 }
1295
1296 int bus_kernel_create_monitor(const char *bus) {
1297         struct kdbus_cmd_hello *hello;
1298         char *p;
1299         int fd;
1300
1301         assert(bus);
1302
1303         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1304         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1305
1306         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1307         if (fd < 0)
1308                 return -errno;
1309
1310         hello = alloca0(sizeof(struct kdbus_cmd_hello));
1311         hello->size = sizeof(struct kdbus_cmd_hello);
1312         hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1313         hello->pool_size = KDBUS_POOL_SIZE;
1314
1315         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1316                 close_nointr_nofail(fd);
1317                 return -errno;
1318         }
1319
1320         /* The higher 32bit of both flags fields are considered
1321          * 'incompatible flags'. Refuse them all for now. */
1322         if (hello->bus_flags > 0xFFFFFFFFULL ||
1323             hello->conn_flags > 0xFFFFFFFFULL) {
1324                 close_nointr_nofail(fd);
1325                 return -ENOTSUP;
1326         }
1327
1328         return fd;
1329 }
1330
1331 int bus_kernel_try_close(sd_bus *bus) {
1332         assert(bus);
1333         assert(bus->is_kernel);
1334
1335         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1336                 return -errno;
1337
1338         return 0;
1339 }