src/libsystemd/sd-bus/bus-kernel.c

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