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