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

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