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                         r = bus_get_root_path(bus);
 546                         if (r < 0)
 547                                 goto fail;
 548
 549                         m->creds.cgroup_root = bus->cgroup_root;
 550
 551                         break;
 552
 553                 case KDBUS_ITEM_AUDIT:
 554                         m->creds.audit_session_id = (uint32_t) d->audit.sessionid;
 555                         m->creds.audit_login_uid = (uid_t) d->audit.loginuid;
 556                         m->creds.mask |= (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID) & bus->creds_mask;
 557                         break;
 558
 559                 case KDBUS_ITEM_CAPS:
 560                         m->creds.capability = d->data;
 561                         m->creds.capability_size = l;
 562                         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;
 563                         break;
 564
 565                 case KDBUS_ITEM_DST_NAME:
 566                         if (!service_name_is_valid(d->str))
 567                                 return -EBADMSG;
 568
 569                         destination = d->str;
 570                         break;
 571
 572                 case KDBUS_ITEM_NAME:
 573                         if (!service_name_is_valid(d->name.name))
 574                                 return -EBADMSG;
 575
 576                         r = strv_extend(&m->creds.well_known_names, d->name.name);
 577                         if (r < 0)
 578                                 goto fail;
 579                         break;
 580
 581                 case KDBUS_ITEM_CONN_NAME:
 582                         m->creds.conn_name = d->str;
 583                         m->creds.mask |= SD_BUS_CREDS_CONNECTION_NAME & bus->creds_mask;
 584                         break;
 585
 586                 case KDBUS_ITEM_FDS:
 587                 case KDBUS_ITEM_SECLABEL:
 588                         break;
 589
 590                 default:
 591                         log_debug("Got unknown field from kernel %llu", d->type);
 592                 }
 593         }
 594
 595         r = bus_message_parse_fields(m);
 596         if (r < 0)
 597                 goto fail;
 598
 599         /* Override information from the user header with data from the kernel */
 600         if (k->src_id == KDBUS_SRC_ID_KERNEL)
 601                 m->sender = m->creds.unique_name = (char*) "org.freedesktop.DBus";
 602         else {
 603                 snprintf(m->sender_buffer, sizeof(m->sender_buffer), ":1.%llu", (unsigned long long) k->src_id);
 604                 m->sender = m->creds.unique_name = m->sender_buffer;
 605         }
 606
 607         if (destination)
 608                 m->destination = destination;
 609         else if (k->dst_id == KDBUS_DST_ID_BROADCAST)
 610                 m->destination = NULL;
 611         else if (k->dst_id == KDBUS_DST_ID_NAME)
 612                 m->destination = bus->unique_name; /* fill in unique name if the well-known name is missing */
 613         else {
 614                 snprintf(m->destination_buffer, sizeof(m->destination_buffer), ":1.%llu", (unsigned long long) k->dst_id);
 615                 m->destination = m->destination_buffer;
 616         }
 617
 618         /* We take possession of the kmsg struct now */
 619         m->kdbus = k;
 620         m->release_kdbus = true;
 621         m->free_fds = true;
 622         fds = NULL;
 623
 624         bus->rqueue[bus->rqueue_size++] = m;
 625
 626         return 1;
 627
 628 fail:
 629         if (m) {
 630                 struct bus_body_part *part;
 631                 unsigned i;
 632
 633                 /* Make sure the memfds are not freed twice */
 634                 MESSAGE_FOREACH_PART(part, i, m)
 635                         if (part->memfd >= 0)
 636                                 part->memfd = -1;
 637
 638                 sd_bus_message_unref(m);
 639         }
 640
 641         return r;
 642 }
 643
 644 int bus_kernel_take_fd(sd_bus *b) {
 645         struct kdbus_cmd_hello *hello;
 646         struct kdbus_item *item;
 647         _cleanup_free_ char *g = NULL;
 648         const char *name;
 649         size_t l = 0, m = 0, sz;
 650         int r;
 651
 652         assert(b);
 653
 654         if (b->is_server)
 655                 return -EINVAL;
 656
 657         b->use_memfd = 1;
 658
 659         if (b->connection_name) {
 660                 g = bus_label_escape(b->connection_name);
 661                 if (!g)
 662                         return -ENOMEM;
 663
 664                 name = g;
 665         } else {
 666                 char pr[17] = {};
 667
 668                 /* If no name is explicitly set, we'll include a hint
 669                  * indicating the library implementation, a hint which
 670                  * kind of bus this is and the thread name */
 671
 672                 assert_se(prctl(PR_GET_NAME, (unsigned long) pr) >= 0);
 673
 674                 if (isempty(pr)) {
 675                         name = b->is_system ? "sd-system" :
 676                                 b->is_user ? "sd-user" : "sd";
 677                 } else {
 678                         _cleanup_free_ char *e = NULL;
 679
 680                         e = bus_label_escape(pr);
 681                         if (!e)
 682                                 return -ENOMEM;
 683
 684                         g = strappend(b->is_system ? "sd-system-" :
 685                                       b->is_user ? "sd-user-" : "sd-",
 686                                       e);
 687                         if (!g)
 688                                 return -ENOMEM;
 689
 690                         name = g;
 691                 }
 692
 693                 b->connection_name = bus_label_unescape(name);
 694                 if (!b->connection_name)
 695                         return -ENOMEM;
 696         }
 697
 698         m = strlen(name);
 699
 700         sz = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
 701                 ALIGN8(offsetof(struct kdbus_item, str) + m + 1);
 702
 703         if (b->fake_creds_valid)
 704                 sz += ALIGN8(offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds));
 705
 706         if (b->fake_label) {
 707                 l = strlen(b->fake_label);
 708                 sz += ALIGN8(offsetof(struct kdbus_item, str) + l + 1);
 709         }
 710
 711         hello = alloca0(sz);
 712         hello->size = sz;
 713         hello->conn_flags = b->hello_flags;
 714         hello->attach_flags = b->attach_flags;
 715         hello->pool_size = KDBUS_POOL_SIZE;
 716
 717         item = hello->items;
 718
 719         item->size = offsetof(struct kdbus_item, str) + m + 1;
 720         item->type = KDBUS_ITEM_CONN_NAME;
 721         memcpy(item->str, name, m + 1);
 722         item = KDBUS_ITEM_NEXT(item);
 723
 724         if (b->fake_creds_valid) {
 725                 item->size = offsetof(struct kdbus_item, creds) + sizeof(struct kdbus_creds);
 726                 item->type = KDBUS_ITEM_CREDS;
 727                 item->creds = b->fake_creds;
 728
 729                 item = KDBUS_ITEM_NEXT(item);
 730         }
 731
 732         if (b->fake_label) {
 733                 item->size = offsetof(struct kdbus_item, str) + l + 1;
 734                 item->type = KDBUS_ITEM_SECLABEL;
 735                 memcpy(item->str, b->fake_label, l+1);
 736         }
 737
 738         r = ioctl(b->input_fd, KDBUS_CMD_HELLO, hello);
 739         if (r < 0)
 740                 return -errno;
 741
 742         if (!b->kdbus_buffer) {
 743                 b->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, b->input_fd, 0);
 744                 if (b->kdbus_buffer == MAP_FAILED) {
 745                         b->kdbus_buffer = NULL;
 746                         return -errno;
 747                 }
 748         }
 749
 750         /* The higher 32bit of both flags fields are considered
 751          * 'incompatible flags'. Refuse them all for now. */
 752         if (hello->bus_flags > 0xFFFFFFFFULL ||
 753             hello->conn_flags > 0xFFFFFFFFULL)
 754                 return -ENOTSUP;
 755
 756         if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
 757                 return -ENOTSUP;
 758
 759         b->bloom_size = (size_t) hello->bloom.size;
 760         b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
 761
 762         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
 763                 return -ENOMEM;
 764
 765         b->unique_id = hello->id;
 766
 767         b->is_kernel = true;
 768         b->bus_client = true;
 769         b->can_fds = !!(hello->conn_flags & KDBUS_HELLO_ACCEPT_FD);
 770         b->message_version = 2;
 771         b->message_endian = BUS_NATIVE_ENDIAN;
 772
 773         /* the kernel told us the UUID of the underlying bus */
 774         memcpy(b->server_id.bytes, hello->id128, sizeof(b->server_id.bytes));
 775
 776         return bus_start_running(b);
 777 }
 778
 779 int bus_kernel_connect(sd_bus *b) {
 780         assert(b);
 781         assert(b->input_fd < 0);
 782         assert(b->output_fd < 0);
 783         assert(b->kernel);
 784
 785         if (b->is_server)
 786                 return -EINVAL;
 787
 788         b->input_fd = open(b->kernel, O_RDWR|O_NOCTTY|O_CLOEXEC);
 789         if (b->input_fd < 0)
 790                 return -errno;
 791
 792         b->output_fd = b->input_fd;
 793
 794         return bus_kernel_take_fd(b);
 795 }
 796
 797 static void close_kdbus_msg(sd_bus *bus, struct kdbus_msg *k) {
 798         uint64_t off;
 799         struct kdbus_item *d;
 800
 801         assert(bus);
 802         assert(k);
 803
 804         off = (uint8_t *)k - (uint8_t *)bus->kdbus_buffer;
 805         ioctl(bus->input_fd, KDBUS_CMD_FREE, &off);
 806
 807         KDBUS_ITEM_FOREACH(d, k, items) {
 808
 809                 if (d->type == KDBUS_ITEM_FDS)
 810                         close_many(d->fds, (d->size - offsetof(struct kdbus_item, fds)) / sizeof(int));
 811                 else if (d->type == KDBUS_ITEM_PAYLOAD_MEMFD)
 812                         safe_close(d->memfd.fd);
 813         }
 814 }
 815
 816 int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call) {
 817         int r;
 818
 819         assert(bus);
 820         assert(m);
 821         assert(bus->state == BUS_RUNNING);
 822
 823         /* If we can't deliver, we want room for the error message */
 824         r = bus_rqueue_make_room(bus);
 825         if (r < 0)
 826                 return r;
 827
 828         r = bus_message_setup_kmsg(bus, m);
 829         if (r < 0)
 830                 return r;
 831
 832         /* If this is a synchronous method call, then let's tell the
 833          * kernel, so that it can pass CPU time/scheduling to the
 834          * destination for the time, if it wants to. If we
 835          * synchronously wait for the result anyway, we won't need CPU
 836          * anyway. */
 837         if (hint_sync_call)
 838                 m->kdbus->flags |= KDBUS_MSG_FLAGS_EXPECT_REPLY|KDBUS_MSG_FLAGS_SYNC_REPLY;
 839
 840         r = ioctl(bus->output_fd, KDBUS_CMD_MSG_SEND, m->kdbus);
 841         if (r < 0) {
 842                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 843                 sd_bus_message *reply;
 844
 845                 if (errno == EAGAIN || errno == EINTR)
 846                         return 0;
 847                 else if (errno == ENXIO || errno == ESRCH) {
 848
 849                         /* ENXIO: unique name not known
 850                          * ESRCH: well-known name not known */
 851
 852                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
 853                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Destination %s not known", m->destination);
 854                         else {
 855                                 log_debug("Could not deliver message to %s as destination is not known. Ignoring.", m->destination);
 856                                 return 0;
 857                         }
 858
 859                 } else if (errno == EADDRNOTAVAIL) {
 860
 861                         /* EADDRNOTAVAIL: activation is possible, but turned off in request flags */
 862
 863                         if (m->header->type == SD_BUS_MESSAGE_METHOD_CALL)
 864                                 sd_bus_error_setf(&error, SD_BUS_ERROR_SERVICE_UNKNOWN, "Activation of %s not requested", m->destination);
 865                         else {
 866                                 log_debug("Could not deliver message to %s as destination is not activated. Ignoring.", m->destination);
 867                                 return 0;
 868                         }
 869                 } else
 870                         return -errno;
 871
 872                 r = bus_message_new_synthetic_error(
 873                                 bus,
 874                                 BUS_MESSAGE_COOKIE(m),
 875                                 &error,
 876                                 &reply);
 877
 878                 if (r < 0)
 879                         return r;
 880
 881                 r = bus_seal_synthetic_message(bus, reply);
 882                 if (r < 0)
 883                         return r;
 884
 885                 bus->rqueue[bus->rqueue_size++] = reply;
 886
 887         } else if (hint_sync_call) {
 888                 struct kdbus_msg *k;
 889
 890                 k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + m->kdbus->offset_reply);
 891                 assert(k);
 892
 893                 if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
 894
 895                         r = bus_kernel_make_message(bus, k);
 896                         if (r < 0) {
 897                                 close_kdbus_msg(bus, k);
 898
 899                                 /* Anybody can send us invalid messages, let's just drop them. */
 900                                 if (r == -EBADMSG || r == -EPROTOTYPE)
 901                                         log_debug("Ignoring invalid message: %s", strerror(-r));
 902                                 else
 903                                         return r;
 904                         }
 905                 } else {
 906                         log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
 907                         close_kdbus_msg(bus, k);
 908                 }
 909         }
 910
 911         return 1;
 912 }
 913
 914 static int push_name_owner_changed(sd_bus *bus, const char *name, const char *old_owner, const char *new_owner) {
 915         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 916         int r;
 917
 918         assert(bus);
 919
 920         r = sd_bus_message_new_signal(
 921                         bus,
 922                         &m,
 923                         "/org/freedesktop/DBus",
 924                         "org.freedesktop.DBus",
 925                         "NameOwnerChanged");
 926         if (r < 0)
 927                 return r;
 928
 929         r = sd_bus_message_append(m, "sss", name, old_owner, new_owner);
 930         if (r < 0)
 931                 return r;
 932
 933         m->sender = "org.freedesktop.DBus";
 934
 935         r = bus_seal_synthetic_message(bus, m);
 936         if (r < 0)
 937                 return r;
 938
 939         bus->rqueue[bus->rqueue_size++] = m;
 940         m = NULL;
 941
 942         return 1;
 943 }
 944
 945 static int translate_name_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 946         char new_owner[UNIQUE_NAME_MAX], old_owner[UNIQUE_NAME_MAX];
 947
 948         assert(bus);
 949         assert(k);
 950         assert(d);
 951
 952         if (d->type == KDBUS_ITEM_NAME_ADD || (d->name_change.old.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR)))
 953                 old_owner[0] = 0;
 954         else
 955                 sprintf(old_owner, ":1.%llu", (unsigned long long) d->name_change.old.id);
 956
 957         if (d->type == KDBUS_ITEM_NAME_REMOVE || (d->name_change.new.flags & (KDBUS_NAME_IN_QUEUE|KDBUS_NAME_ACTIVATOR))) {
 958
 959                 if (isempty(old_owner))
 960                         return 0;
 961
 962                 new_owner[0] = 0;
 963         } else
 964                 sprintf(new_owner, ":1.%llu", (unsigned long long) d->name_change.new.id);
 965
 966         return push_name_owner_changed(bus, d->name_change.name, old_owner, new_owner);
 967 }
 968
 969 static int translate_id_change(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 970         char owner[UNIQUE_NAME_MAX];
 971
 972         assert(bus);
 973         assert(k);
 974         assert(d);
 975
 976         sprintf(owner, ":1.%llu", d->id_change.id);
 977
 978         return push_name_owner_changed(
 979                         bus, owner,
 980                         d->type == KDBUS_ITEM_ID_ADD ? NULL : owner,
 981                         d->type == KDBUS_ITEM_ID_ADD ? owner : NULL);
 982 }
 983
 984 static int translate_reply(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) {
 985         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 986         int r;
 987
 988         assert(bus);
 989         assert(k);
 990         assert(d);
 991
 992         r = bus_message_new_synthetic_error(
 993                         bus,
 994                         k->cookie_reply,
 995                         d->type == KDBUS_ITEM_REPLY_TIMEOUT ?
 996                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call timed out") :
 997                         &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_REPLY, "Method call peer died"),
 998                         &m);
 999         if (r < 0)
1000                 return r;
1001
1002         m->sender = "org.freedesktop.DBus";
1003
1004         r = bus_seal_synthetic_message(bus, m);
1005         if (r < 0)
1006                 return r;
1007
1008         bus->rqueue[bus->rqueue_size++] = m;
1009         m = NULL;
1010
1011         return 1;
1012 }
1013
1014 static int bus_kernel_translate_message(sd_bus *bus, struct kdbus_msg *k) {
1015         struct kdbus_item *d, *found = NULL;
1016
1017         static int (* const translate[])(sd_bus *bus, struct kdbus_msg *k, struct kdbus_item *d) = {
1018                 [KDBUS_ITEM_NAME_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1019                 [KDBUS_ITEM_NAME_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1020                 [KDBUS_ITEM_NAME_CHANGE - _KDBUS_ITEM_KERNEL_BASE] = translate_name_change,
1021
1022                 [KDBUS_ITEM_ID_ADD - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1023                 [KDBUS_ITEM_ID_REMOVE - _KDBUS_ITEM_KERNEL_BASE] = translate_id_change,
1024
1025                 [KDBUS_ITEM_REPLY_TIMEOUT - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1026                 [KDBUS_ITEM_REPLY_DEAD - _KDBUS_ITEM_KERNEL_BASE] = translate_reply,
1027         };
1028
1029         assert(bus);
1030         assert(k);
1031         assert(k->payload_type == KDBUS_PAYLOAD_KERNEL);
1032
1033         KDBUS_ITEM_FOREACH(d, k, items) {
1034                 if (d->type >= _KDBUS_ITEM_KERNEL_BASE && d->type < _KDBUS_ITEM_KERNEL_BASE + ELEMENTSOF(translate)) {
1035                         if (found)
1036                                 return -EBADMSG;
1037                         found = d;
1038                 } else
1039                         log_debug("Got unknown field from kernel %llu", d->type);
1040         }
1041
1042         if (!found) {
1043                 log_debug("Didn't find a kernel message to translate.");
1044                 return 0;
1045         }
1046
1047         return translate[found->type - _KDBUS_ITEM_KERNEL_BASE](bus, k, found);
1048 }
1049
1050 int bus_kernel_read_message(sd_bus *bus, bool hint_priority, int64_t priority) {
1051         struct kdbus_cmd_recv recv = {};
1052         struct kdbus_msg *k;
1053         int r;
1054
1055         assert(bus);
1056
1057         r = bus_rqueue_make_room(bus);
1058         if (r < 0)
1059                 return r;
1060
1061         if (hint_priority) {
1062                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1063                 recv.priority = priority;
1064         }
1065
1066         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1067         if (r < 0) {
1068                 if (errno == EAGAIN)
1069                         return 0;
1070
1071                 return -errno;
1072         }
1073
1074         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1075         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1076                 r = bus_kernel_make_message(bus, k);
1077
1078                 /* Anybody can send us invalid messages, let's just drop them. */
1079                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1080                         log_debug("Ignoring invalid message: %s", strerror(-r));
1081                         r = 0;
1082                 }
1083
1084         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1085                 r = bus_kernel_translate_message(bus, k);
1086         else {
1087                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1088                 r = 0;
1089         }
1090
1091         if (r <= 0)
1092                 close_kdbus_msg(bus, k);
1093
1094         return r < 0 ? r : 1;
1095 }
1096
1097 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1098         struct memfd_cache *c;
1099         int fd;
1100
1101         assert(address);
1102         assert(mapped);
1103         assert(allocated);
1104
1105         if (!bus || !bus->is_kernel)
1106                 return -ENOTSUP;
1107
1108         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1109
1110         if (bus->n_memfd_cache <= 0) {
1111                 _cleanup_free_ char *g = NULL;
1112                 int r;
1113
1114                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1115
1116                 assert(bus->connection_name);
1117
1118                 g = bus_label_escape(bus->connection_name);
1119                 if (!g)
1120                         return -ENOMEM;
1121
1122                 r = memfd_create(g, MFD_ALLOW_SEALING);
1123                 if (r < 0)
1124                         return -errno;
1125
1126                 *address = NULL;
1127                 *mapped = 0;
1128                 *allocated = 0;
1129                 return r;
1130         }
1131
1132         c = &bus->memfd_cache[--bus->n_memfd_cache];
1133
1134         assert(c->fd >= 0);
1135         assert(c->mapped == 0 || c->address);
1136
1137         *address = c->address;
1138         *mapped = c->mapped;
1139         *allocated = c->allocated;
1140         fd = c->fd;
1141
1142         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1143
1144         return fd;
1145 }
1146
1147 static void close_and_munmap(int fd, void *address, size_t size) {
1148         if (size > 0)
1149                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1150
1151         safe_close(fd);
1152 }
1153
1154 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1155         struct memfd_cache *c;
1156         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1157
1158         assert(fd >= 0);
1159         assert(mapped == 0 || address);
1160
1161         if (!bus || !bus->is_kernel) {
1162                 close_and_munmap(fd, address, mapped);
1163                 return;
1164         }
1165
1166         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1167
1168         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1169                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1170
1171                 close_and_munmap(fd, address, mapped);
1172                 return;
1173         }
1174
1175         c = &bus->memfd_cache[bus->n_memfd_cache++];
1176         c->fd = fd;
1177         c->address = address;
1178
1179         /* If overly long, let's return a bit to the OS */
1180         if (mapped > max_mapped) {
1181                 assert_se(ftruncate(fd, max_mapped) >= 0);
1182                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1183                 c->mapped = c->allocated = max_mapped;
1184         } else {
1185                 c->mapped = mapped;
1186                 c->allocated = allocated;
1187         }
1188
1189         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1190 }
1191
1192 void bus_kernel_flush_memfd(sd_bus *b) {
1193         unsigned i;
1194
1195         assert(b);
1196
1197         for (i = 0; i < b->n_memfd_cache; i++)
1198                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1199 }
1200
1201 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1202         uint64_t f = 0;
1203
1204         assert(kdbus_flags);
1205
1206         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1207                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1208
1209         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1210                 f |= KDBUS_NAME_REPLACE_EXISTING;
1211
1212         if (flags & SD_BUS_NAME_QUEUE)
1213                 f |= KDBUS_NAME_QUEUE;
1214
1215         *kdbus_flags = f;
1216         return 0;
1217 }
1218
1219 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1220         uint64_t m = 0;
1221
1222         assert(kdbus_mask);
1223
1224         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1225                 m |= KDBUS_ATTACH_CREDS;
1226
1227         if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1228                 m |= KDBUS_ATTACH_COMM;
1229
1230         if (mask & SD_BUS_CREDS_EXE)
1231                 m |= KDBUS_ATTACH_EXE;
1232
1233         if (mask & SD_BUS_CREDS_CMDLINE)
1234                 m |= KDBUS_ATTACH_CMDLINE;
1235
1236         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))
1237                 m |= KDBUS_ATTACH_CGROUP;
1238
1239         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1240                 m |= KDBUS_ATTACH_CAPS;
1241
1242         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1243                 m |= KDBUS_ATTACH_SECLABEL;
1244
1245         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1246                 m |= KDBUS_ATTACH_AUDIT;
1247
1248         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1249                 m |= KDBUS_ATTACH_NAMES;
1250
1251         if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1252                 m |= KDBUS_ATTACH_CONN_NAME;
1253
1254         *kdbus_mask = m;
1255         return 0;
1256 }
1257
1258 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1259         struct kdbus_cmd_make *make;
1260         struct kdbus_item *n;
1261         int fd;
1262
1263         assert(name);
1264         assert(s);
1265
1266         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1267         if (fd < 0)
1268                 return -errno;
1269
1270         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1271                               offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1272                               offsetof(struct kdbus_item, str) +
1273                               DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1274
1275         make->size = offsetof(struct kdbus_cmd_make, items);
1276
1277         n = make->items;
1278         n->size = offsetof(struct kdbus_item, bloom_parameter) +
1279                   sizeof(struct kdbus_bloom_parameter);
1280         n->type = KDBUS_ITEM_BLOOM_PARAMETER;
1281
1282         n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
1283         n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
1284
1285         assert_cc(DEFAULT_BLOOM_SIZE > 0);
1286         assert_cc(DEFAULT_BLOOM_N_HASH > 0);
1287
1288         make->size += ALIGN8(n->size);
1289
1290         n = KDBUS_ITEM_NEXT(n);
1291         sprintf(n->str, UID_FMT "-%s", getuid(), name);
1292         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1293         n->type = KDBUS_ITEM_MAKE_NAME;
1294         make->size += ALIGN8(n->size);
1295
1296         make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
1297
1298         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1299                 safe_close(fd);
1300                 return -errno;
1301         }
1302
1303         /* The higher 32bit of the flags field are considered
1304          * 'incompatible flags'. Refuse them all for now. */
1305         if (make->flags > 0xFFFFFFFFULL) {
1306                 safe_close(fd);
1307                 return -ENOTSUP;
1308         }
1309
1310         if (s) {
1311                 char *p;
1312
1313                 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1314                 if (!p) {
1315                         safe_close(fd);
1316                         return -ENOMEM;
1317                 }
1318
1319                 *s = p;
1320         }
1321
1322         return fd;
1323 }
1324
1325 static int bus_kernel_translate_access(BusNamePolicyAccess access) {
1326         assert(access >= 0);
1327         assert(access < _BUSNAME_POLICY_ACCESS_MAX);
1328
1329         switch (access) {
1330
1331         case BUSNAME_POLICY_ACCESS_SEE:
1332                 return KDBUS_POLICY_SEE;
1333
1334         case BUSNAME_POLICY_ACCESS_TALK:
1335                 return KDBUS_POLICY_TALK;
1336
1337         case BUSNAME_POLICY_ACCESS_OWN:
1338                 return KDBUS_POLICY_OWN;
1339
1340         default:
1341                 assert_not_reached("Unknown policy access");
1342         }
1343 }
1344
1345 static int bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item) {
1346         int r;
1347
1348         assert(policy);
1349         assert(item);
1350
1351         switch (policy->type) {
1352
1353         case BUSNAME_POLICY_TYPE_USER: {
1354                 const char *user = policy->name;
1355                 uid_t uid;
1356
1357                 r = get_user_creds(&user, &uid, NULL, NULL, NULL);
1358                 if (r < 0)
1359                         return r;
1360
1361                 item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
1362                 item->policy_access.id = uid;
1363                 break;
1364         }
1365
1366         case BUSNAME_POLICY_TYPE_GROUP: {
1367                 const char *group = policy->name;
1368                 gid_t gid;
1369
1370                 r = get_group_creds(&group, &gid);
1371                 if (r < 0)
1372                         return r;
1373
1374                 item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
1375                 item->policy_access.id = gid;
1376                 break;
1377         }
1378
1379         default:
1380                 assert_not_reached("Unknown policy type");
1381         }
1382
1383         item->policy_access.access = bus_kernel_translate_access(policy->access);
1384
1385         return 0;
1386 }
1387
1388 int bus_kernel_open_bus_fd(const char *bus, char **path) {
1389         char *p;
1390         int fd;
1391         size_t len;
1392
1393         len = strlen("/dev/kdbus/") + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + strlen("/bus") + 1;
1394
1395         if (path) {
1396                 p = malloc(len);
1397                 if (!p)
1398                         return -ENOMEM;
1399                 *path = p;
1400         } else
1401                 p = alloca(len);
1402         sprintf(p, "/dev/kdbus/" UID_FMT "-%s/bus", getuid(), bus);
1403
1404         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1405         if (fd < 0)
1406                 return -errno;
1407
1408         return fd;
1409 }
1410
1411 int bus_kernel_make_starter(
1412                 int fd,
1413                 const char *name,
1414                 bool activating,
1415                 bool accept_fd,
1416                 BusNamePolicy *policy,
1417                 BusNamePolicyAccess world_policy) {
1418
1419         struct kdbus_cmd_hello *hello;
1420         struct kdbus_item *n;
1421         size_t policy_cnt = 0;
1422         BusNamePolicy *po;
1423         size_t size;
1424         int r;
1425
1426         assert(fd >= 0);
1427         assert(name);
1428
1429         LIST_FOREACH(policy, po, policy)
1430                 policy_cnt++;
1431
1432         if (world_policy >= 0)
1433                 policy_cnt++;
1434
1435         size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
1436                ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
1437                policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
1438
1439         hello = alloca0(size);
1440
1441         n = hello->items;
1442         strcpy(n->str, name);
1443         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1444         n->type = KDBUS_ITEM_NAME;
1445         n = KDBUS_ITEM_NEXT(n);
1446
1447         LIST_FOREACH(policy, po, policy) {
1448                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1449                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1450
1451                 r = bus_kernel_translate_policy(po, n);
1452                 if (r < 0)
1453                         return r;
1454
1455                 n = KDBUS_ITEM_NEXT(n);
1456         }
1457
1458         if (world_policy >= 0) {
1459                 n->type = KDBUS_ITEM_POLICY_ACCESS;
1460                 n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
1461                 n->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
1462                 n->policy_access.access = bus_kernel_translate_access(world_policy);
1463         }
1464
1465         hello->size = size;
1466         hello->conn_flags =
1467                 (activating ? KDBUS_HELLO_ACTIVATOR : KDBUS_HELLO_POLICY_HOLDER) |
1468                 (accept_fd ? KDBUS_HELLO_ACCEPT_FD : 0);
1469         hello->pool_size = KDBUS_POOL_SIZE;
1470         hello->attach_flags = _KDBUS_ATTACH_ALL;
1471
1472         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0)
1473                 return -errno;
1474
1475         /* The higher 32bit of both flags fields are considered
1476          * 'incompatible flags'. Refuse them all for now. */
1477         if (hello->bus_flags > 0xFFFFFFFFULL ||
1478             hello->conn_flags > 0xFFFFFFFFULL)
1479                 return -ENOTSUP;
1480
1481         if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
1482                 return -ENOTSUP;
1483
1484         return fd;
1485 }
1486
1487 int bus_kernel_create_domain(const char *name, char **s) {
1488         struct kdbus_cmd_make *make;
1489         struct kdbus_item *n;
1490         int fd;
1491
1492         assert(name);
1493         assert(s);
1494
1495         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1496         if (fd < 0)
1497                 return -errno;
1498
1499         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1500                               offsetof(struct kdbus_item, str) +
1501                               strlen(name) + 1));
1502
1503         n = make->items;
1504         strcpy(n->str, name);
1505         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1506         n->type = KDBUS_ITEM_MAKE_NAME;
1507
1508         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1509         make->flags = KDBUS_MAKE_ACCESS_WORLD;
1510
1511         if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
1512                 safe_close(fd);
1513                 return -errno;
1514         }
1515
1516         /* The higher 32bit of the flags field are considered
1517          * 'incompatible flags'. Refuse them all for now. */
1518         if (make->flags > 0xFFFFFFFFULL) {
1519                 safe_close(fd);
1520                 return -ENOTSUP;
1521         }
1522
1523         if (s) {
1524                 char *p;
1525
1526                 p = strappend("/dev/kdbus/domain/", name);
1527                 if (!p) {
1528                         safe_close(fd);
1529                         return -ENOMEM;
1530                 }
1531
1532                 *s = p;
1533         }
1534
1535         return fd;
1536 }
1537
1538 int bus_kernel_try_close(sd_bus *bus) {
1539         assert(bus);
1540         assert(bus->is_kernel);
1541
1542         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1543                 return -errno;
1544
1545         return 0;
1546 }
1547
1548 int bus_kernel_drop_one(int fd) {
1549         struct kdbus_cmd_recv recv = {
1550                 .flags = KDBUS_RECV_DROP
1551         };
1552
1553         assert(fd >= 0);
1554
1555         if (ioctl(fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
1556                 return -errno;
1557
1558         return 0;
1559 }