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

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