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