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