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