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