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

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