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, bool hint_priority, int64_t priority) {
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         if (hint_priority) {
1054                 recv.flags |= KDBUS_RECV_USE_PRIORITY;
1055                 recv.priority = priority;
1056         }
1057
1058         r = ioctl(bus->input_fd, KDBUS_CMD_MSG_RECV, &recv);
1059         if (r < 0) {
1060                 if (errno == EAGAIN)
1061                         return 0;
1062
1063                 return -errno;
1064         }
1065
1066         k = (struct kdbus_msg *)((uint8_t *)bus->kdbus_buffer + recv.offset);
1067         if (k->payload_type == KDBUS_PAYLOAD_DBUS) {
1068                 r = bus_kernel_make_message(bus, k);
1069
1070                 /* Anybody can send us invalid messages, let's just drop them. */
1071                 if (r == -EBADMSG || r == -EPROTOTYPE) {
1072                         log_debug("Ignoring invalid message: %s", strerror(-r));
1073                         r = 0;
1074                 }
1075
1076         } else if (k->payload_type == KDBUS_PAYLOAD_KERNEL)
1077                 r = bus_kernel_translate_message(bus, k);
1078         else {
1079                 log_debug("Ignoring message with unknown payload type %llu.", (unsigned long long) k->payload_type);
1080                 r = 0;
1081         }
1082
1083         if (r <= 0)
1084                 close_kdbus_msg(bus, k);
1085
1086         return r < 0 ? r : 1;
1087 }
1088
1089 int bus_kernel_pop_memfd(sd_bus *bus, void **address, size_t *mapped, size_t *allocated) {
1090         struct memfd_cache *c;
1091         int fd;
1092
1093         assert(address);
1094         assert(mapped);
1095         assert(allocated);
1096
1097         if (!bus || !bus->is_kernel)
1098                 return -ENOTSUP;
1099
1100         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1101
1102         if (bus->n_memfd_cache <= 0) {
1103                 _cleanup_free_ char *g = NULL;
1104                 struct kdbus_cmd_memfd_make *cmd;
1105                 struct kdbus_item *item;
1106                 size_t l, sz;
1107                 int r;
1108
1109                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1110
1111                 assert(bus->connection_name);
1112
1113                 g = sd_bus_label_escape(bus->connection_name);
1114                 if (!g)
1115                         return -ENOMEM;
1116
1117                 l = strlen(g);
1118                 sz = ALIGN8(offsetof(struct kdbus_cmd_memfd_make, items)) +
1119                         ALIGN8(offsetof(struct kdbus_item, str)) +
1120                         l + 1;
1121                 cmd = alloca0(sz);
1122                 cmd->size = sz;
1123
1124                 item = cmd->items;
1125                 item->size = ALIGN8(offsetof(struct kdbus_item, str)) + l + 1;
1126                 item->type = KDBUS_ITEM_MEMFD_NAME;
1127                 memcpy(item->str, g, l + 1);
1128
1129                 r = ioctl(bus->input_fd, KDBUS_CMD_MEMFD_NEW, cmd);
1130                 if (r < 0)
1131                         return -errno;
1132
1133                 *address = NULL;
1134                 *mapped = 0;
1135                 *allocated = 0;
1136                 return cmd->fd;
1137         }
1138
1139         c = &bus->memfd_cache[--bus->n_memfd_cache];
1140
1141         assert(c->fd >= 0);
1142         assert(c->mapped == 0 || c->address);
1143
1144         *address = c->address;
1145         *mapped = c->mapped;
1146         *allocated = c->allocated;
1147         fd = c->fd;
1148
1149         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1150
1151         return fd;
1152 }
1153
1154 static void close_and_munmap(int fd, void *address, size_t size) {
1155         if (size > 0)
1156                 assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
1157
1158         close_nointr_nofail(fd);
1159 }
1160
1161 void bus_kernel_push_memfd(sd_bus *bus, int fd, void *address, size_t mapped, size_t allocated) {
1162         struct memfd_cache *c;
1163         uint64_t max_mapped = PAGE_ALIGN(MEMFD_CACHE_ITEM_SIZE_MAX);
1164
1165         assert(fd >= 0);
1166         assert(mapped == 0 || address);
1167
1168         if (!bus || !bus->is_kernel) {
1169                 close_and_munmap(fd, address, mapped);
1170                 return;
1171         }
1172
1173         assert_se(pthread_mutex_lock(&bus->memfd_cache_mutex) >= 0);
1174
1175         if (bus->n_memfd_cache >= ELEMENTSOF(bus->memfd_cache)) {
1176                 assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1177
1178                 close_and_munmap(fd, address, mapped);
1179                 return;
1180         }
1181
1182         c = &bus->memfd_cache[bus->n_memfd_cache++];
1183         c->fd = fd;
1184         c->address = address;
1185
1186         /* If overly long, let's return a bit to the OS */
1187         if (mapped > max_mapped) {
1188                 assert_se(ioctl(fd, KDBUS_CMD_MEMFD_SIZE_SET, &max_mapped) >= 0);
1189                 assert_se(munmap((uint8_t*) address + max_mapped, PAGE_ALIGN(mapped - max_mapped)) >= 0);
1190                 c->mapped = c->allocated = max_mapped;
1191         } else {
1192                 c->mapped = mapped;
1193                 c->allocated = allocated;
1194         }
1195
1196         assert_se(pthread_mutex_unlock(&bus->memfd_cache_mutex) >= 0);
1197 }
1198
1199 void bus_kernel_flush_memfd(sd_bus *b) {
1200         unsigned i;
1201
1202         assert(b);
1203
1204         for (i = 0; i < b->n_memfd_cache; i++)
1205                 close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
1206 }
1207
1208 int kdbus_translate_request_name_flags(uint64_t flags, uint64_t *kdbus_flags) {
1209         uint64_t f = 0;
1210
1211         assert(kdbus_flags);
1212
1213         if (flags & SD_BUS_NAME_ALLOW_REPLACEMENT)
1214                 f |= KDBUS_NAME_ALLOW_REPLACEMENT;
1215
1216         if (flags & SD_BUS_NAME_REPLACE_EXISTING)
1217                 f |= KDBUS_NAME_REPLACE_EXISTING;
1218
1219         if (flags & SD_BUS_NAME_QUEUE)
1220                 f |= KDBUS_NAME_QUEUE;
1221
1222         *kdbus_flags = f;
1223         return 0;
1224 }
1225
1226 int kdbus_translate_attach_flags(uint64_t mask, uint64_t *kdbus_mask) {
1227         uint64_t m = 0;
1228
1229         assert(kdbus_mask);
1230
1231         if (mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_GID|SD_BUS_CREDS_PID|SD_BUS_CREDS_PID_STARTTIME|SD_BUS_CREDS_TID))
1232                 m |= KDBUS_ATTACH_CREDS;
1233
1234         if (mask & (SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM))
1235                 m |= KDBUS_ATTACH_COMM;
1236
1237         if (mask & SD_BUS_CREDS_EXE)
1238                 m |= KDBUS_ATTACH_EXE;
1239
1240         if (mask & SD_BUS_CREDS_CMDLINE)
1241                 m |= KDBUS_ATTACH_CMDLINE;
1242
1243         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))
1244                 m |= KDBUS_ATTACH_CGROUP;
1245
1246         if (mask & (SD_BUS_CREDS_EFFECTIVE_CAPS|SD_BUS_CREDS_PERMITTED_CAPS|SD_BUS_CREDS_INHERITABLE_CAPS|SD_BUS_CREDS_BOUNDING_CAPS))
1247                 m |= KDBUS_ATTACH_CAPS;
1248
1249         if (mask & SD_BUS_CREDS_SELINUX_CONTEXT)
1250                 m |= KDBUS_ATTACH_SECLABEL;
1251
1252         if (mask & (SD_BUS_CREDS_AUDIT_SESSION_ID|SD_BUS_CREDS_AUDIT_LOGIN_UID))
1253                 m |= KDBUS_ATTACH_AUDIT;
1254
1255         if (mask & SD_BUS_CREDS_WELL_KNOWN_NAMES)
1256                 m |= KDBUS_ATTACH_NAMES;
1257
1258         if (mask & SD_BUS_CREDS_CONNECTION_NAME)
1259                 m |= KDBUS_ATTACH_CONN_NAME;
1260
1261         *kdbus_mask = m;
1262         return 0;
1263 }
1264
1265 int bus_kernel_create_bus(const char *name, bool world, char **s) {
1266         struct kdbus_cmd_make *make;
1267         struct kdbus_item *n;
1268         int fd;
1269
1270         assert(name);
1271         assert(s);
1272
1273         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1274         if (fd < 0)
1275                 return -errno;
1276
1277         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1278                               offsetof(struct kdbus_item, data64) + sizeof(uint64_t) +
1279                               offsetof(struct kdbus_item, str) +
1280                               DECIMAL_STR_MAX(uid_t) + 1 + strlen(name) + 1));
1281
1282         make->size = offsetof(struct kdbus_cmd_make, items);
1283
1284         n = make->items;
1285         n->size = offsetof(struct kdbus_item, data64) + sizeof(uint64_t);
1286         n->type = KDBUS_ITEM_BLOOM_SIZE;
1287         n->data64[0] = BLOOM_SIZE;
1288         assert_cc(BLOOM_SIZE % 8 == 0);
1289         make->size += ALIGN8(n->size);
1290
1291         n = KDBUS_ITEM_NEXT(n);
1292         sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
1293         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1294         n->type = KDBUS_ITEM_MAKE_NAME;
1295         make->size += ALIGN8(n->size);
1296
1297         make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
1298
1299         if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
1300                 close_nointr_nofail(fd);
1301                 return -errno;
1302         }
1303
1304         /* The higher 32bit of the flags field are considered
1305          * 'incompatible flags'. Refuse them all for now. */
1306         if (make->flags > 0xFFFFFFFFULL) {
1307                 close_nointr_nofail(fd);
1308                 return -ENOTSUP;
1309         }
1310
1311         if (s) {
1312                 char *p;
1313
1314                 p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
1315                 if (!p) {
1316                         close_nointr_nofail(fd);
1317                         return -ENOMEM;
1318                 }
1319
1320                 *s = p;
1321         }
1322
1323         return fd;
1324 }
1325
1326 int bus_kernel_create_starter(const char *bus, const char *name) {
1327         struct kdbus_cmd_hello *hello;
1328         struct kdbus_item *n;
1329         char *p;
1330         int fd;
1331
1332         assert(bus);
1333         assert(name);
1334
1335         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1336         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1337
1338         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1339         if (fd < 0)
1340                 return -errno;
1341
1342         hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
1343                                offsetof(struct kdbus_item, str) +
1344                                strlen(name) + 1));
1345
1346         n = hello->items;
1347         strcpy(n->str, name);
1348         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1349         n->type = KDBUS_ITEM_NAME;
1350
1351         hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
1352         hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1353         hello->pool_size = KDBUS_POOL_SIZE;
1354
1355         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1356                 close_nointr_nofail(fd);
1357                 return -errno;
1358         }
1359
1360         /* The higher 32bit of both flags fields are considered
1361          * 'incompatible flags'. Refuse them all for now. */
1362         if (hello->bus_flags > 0xFFFFFFFFULL ||
1363             hello->conn_flags > 0xFFFFFFFFULL) {
1364                 close_nointr_nofail(fd);
1365                 return -ENOTSUP;
1366         }
1367
1368         if (hello->bloom_size != BLOOM_SIZE) {
1369                 close_nointr_nofail(fd);
1370                 return -ENOTSUP;
1371         }
1372
1373         return fd;
1374 }
1375
1376 int bus_kernel_create_namespace(const char *name, char **s) {
1377         struct kdbus_cmd_make *make;
1378         struct kdbus_item *n;
1379         int fd;
1380
1381         assert(name);
1382         assert(s);
1383
1384         fd = open("/dev/kdbus/control", O_RDWR|O_NOCTTY|O_CLOEXEC);
1385         if (fd < 0)
1386                 return -errno;
1387
1388         make = alloca0(ALIGN8(offsetof(struct kdbus_cmd_make, items) +
1389                               offsetof(struct kdbus_item, str) +
1390                               strlen(name) + 1));
1391
1392         n = make->items;
1393         strcpy(n->str, name);
1394         n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
1395         n->type = KDBUS_ITEM_MAKE_NAME;
1396
1397         make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
1398         make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
1399
1400         if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
1401                 close_nointr_nofail(fd);
1402                 return -errno;
1403         }
1404
1405         /* The higher 32bit of the flags field are considered
1406          * 'incompatible flags'. Refuse them all for now. */
1407         if (make->flags > 0xFFFFFFFFULL) {
1408                 close_nointr_nofail(fd);
1409                 return -ENOTSUP;
1410         }
1411
1412         if (s) {
1413                 char *p;
1414
1415                 p = strappend("/dev/kdbus/ns/", name);
1416                 if (!p) {
1417                         close_nointr_nofail(fd);
1418                         return -ENOMEM;
1419                 }
1420
1421                 *s = p;
1422         }
1423
1424         return fd;
1425 }
1426
1427 int bus_kernel_create_monitor(const char *bus) {
1428         struct kdbus_cmd_hello *hello;
1429         char *p;
1430         int fd;
1431
1432         assert(bus);
1433
1434         p = alloca(sizeof("/dev/kdbus/") - 1 + DECIMAL_STR_MAX(uid_t) + 1 + strlen(bus) + sizeof("/bus"));
1435         sprintf(p, "/dev/kdbus/%lu-%s/bus", (unsigned long) getuid(), bus);
1436
1437         fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
1438         if (fd < 0)
1439                 return -errno;
1440
1441         hello = alloca0(sizeof(struct kdbus_cmd_hello));
1442         hello->size = sizeof(struct kdbus_cmd_hello);
1443         hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
1444         hello->pool_size = KDBUS_POOL_SIZE;
1445
1446         if (ioctl(fd, KDBUS_CMD_HELLO, hello) < 0) {
1447                 close_nointr_nofail(fd);
1448                 return -errno;
1449         }
1450
1451         /* The higher 32bit of both flags fields are considered
1452          * 'incompatible flags'. Refuse them all for now. */
1453         if (hello->bus_flags > 0xFFFFFFFFULL ||
1454             hello->conn_flags > 0xFFFFFFFFULL) {
1455                 close_nointr_nofail(fd);
1456                 return -ENOTSUP;
1457         }
1458
1459         return fd;
1460 }
1461
1462 int bus_kernel_try_close(sd_bus *bus) {
1463         assert(bus);
1464         assert(bus->is_kernel);
1465
1466         if (ioctl(bus->input_fd, KDBUS_CMD_BYEBYE) < 0)
1467                 return -errno;
1468
1469         return 0;
1470 }