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