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