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

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