X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-kernel.c;h=c35d95727cadcb193c3c06c0c5067da813fa508f;hb=799e7ea85845bd343eb46daaefa11fd14c9e67cc;hp=c1901384bad13621af992b576e7e51b0590f1818;hpb=d9115e1852ae8e0cb254cf170040e48e5e6c2923;p=elogind.git

diff --git a/src/libsystemd-bus/bus-kernel.c b/src/libsystemd-bus/bus-kernel.c
index c1901384b..c35d95727 100644
--- a/src/libsystemd-bus/bus-kernel.c
+++ b/src/libsystemd-bus/bus-kernel.c
@@ -24,17 +24,22 @@
 #endif
 
 #include <fcntl.h>
+#include <malloc.h>
 
 #include "util.h"
 
 #include "bus-internal.h"
 #include "bus-message.h"
 #include "bus-kernel.h"
+#include "bus-bloom.h"
 
-#define KDBUS_MSG_FOREACH_DATA(d, k)                                    \
-        for ((d) = (k)->data;                                           \
-             (uint8_t*) (d) < (uint8_t*) (k) + (k)->size;               \
-             (d) = (struct kdbus_msg_data*) ((uint8_t*) (d) + ALIGN8((d)->size)))
+#define KDBUS_ITEM_NEXT(item) \
+        (typeof(item))(((uint8_t *)item) + ALIGN8((item)->size))
+
+#define KDBUS_ITEM_FOREACH(item, head)                                          \
+        for (item = (head)->items;                                              \
+             (uint8_t *)(item) < (uint8_t *)(head) + (head)->size;              \
+             item = KDBUS_ITEM_NEXT(item))
 
 static int parse_unique_name(const char *s, uint64_t *id) {
         int r;
@@ -52,41 +57,134 @@ static int parse_unique_name(const char *s, uint64_t *id) {
         return 1;
 }
 
-static void append_payload_vec(struct kdbus_msg_data **d, const void *p, size_t sz) {
+static void append_payload_vec(struct kdbus_msg_item **d, const void *p, size_t sz) {
         assert(d);
         assert(p);
         assert(sz > 0);
 
         *d = ALIGN8_PTR(*d);
 
-        (*d)->size = offsetof(struct kdbus_msg_data, vec) + sizeof(struct kdbus_vec);
+        (*d)->size = offsetof(struct kdbus_msg_item, vec) + sizeof(struct kdbus_vec);
         (*d)->type = KDBUS_MSG_PAYLOAD_VEC;
-        (*d)->vec.address = (uint64_t) p;
+        (*d)->vec.address = (intptr_t) p;
         (*d)->vec.size = sz;
 
-        *d = (struct kdbus_msg_data*) ((uint8_t*) *d + (*d)->size);
+        *d = (struct kdbus_msg_item *) ((uint8_t*) *d + (*d)->size);
 }
 
-static void append_destination(struct kdbus_msg_data **d, const char *s, size_t length) {
-        assert(d);
+static void append_destination(struct kdbus_msg_item **d, const char *s, size_t length) {
         assert(d);
+        assert(s);
 
         *d = ALIGN8_PTR(*d);
 
-        (*d)->size = offsetof(struct kdbus_msg_data, str) + length + 1;
+        (*d)->size = offsetof(struct kdbus_msg_item, str) + length + 1;
         (*d)->type = KDBUS_MSG_DST_NAME;
         memcpy((*d)->str, s, length + 1);
 
-        *d = (struct kdbus_msg_data*) ((uint8_t*) *d + (*d)->size);
+        *d = (struct kdbus_msg_item *) ((uint8_t*) *d + (*d)->size);
+}
+
+static void* append_bloom(struct kdbus_msg_item **d, size_t length) {
+        void *r;
+
+        assert(d);
+
+        *d = ALIGN8_PTR(*d);
+
+        (*d)->size = offsetof(struct kdbus_msg_item, data) + length;
+        (*d)->type = KDBUS_MSG_BLOOM;
+        r = (*d)->data;
+
+        *d = (struct kdbus_msg_item *) ((uint8_t*) *d + (*d)->size);
+
+        return r;
+}
+
+static void append_fds(struct kdbus_msg_item **d, const int fds[], unsigned n_fds) {
+        assert(d);
+        assert(fds);
+        assert(n_fds > 0);
+
+        *d = ALIGN8_PTR(*d);
+        (*d)->size = offsetof(struct kdbus_msg_item, fds) + sizeof(int) * n_fds;
+        (*d)->type = KDBUS_MSG_UNIX_FDS;
+        memcpy((*d)->fds, fds, sizeof(int) * n_fds);
+
+        *d = (struct kdbus_msg_item *) ((uint8_t*) *d + (*d)->size);
 }
 
-static int bus_message_setup_kmsg(sd_bus_message *m) {
-        struct kdbus_msg_data *d;
+static int bus_message_setup_bloom(sd_bus_message *m, void *bloom) {
+        unsigned i;
+        int r;
+
+        assert(m);
+        assert(bloom);
+
+        memset(bloom, 0, BLOOM_SIZE);
+
+        bloom_add_pair(bloom, "message-type", bus_message_type_to_string(m->header->type));
+
+        if (m->interface)
+                bloom_add_pair(bloom, "interface", m->interface);
+        if (m->member)
+                bloom_add_pair(bloom, "member", m->member);
+        if (m->path) {
+                bloom_add_pair(bloom, "path", m->path);
+                bloom_add_prefixes(bloom, "path-slash-prefix", m->path, '/');
+        }
+
+        r = sd_bus_message_rewind(m, true);
+        if (r < 0)
+                return r;
+
+        for (i = 0; i < 64; i++) {
+                char type;
+                const char *t;
+                char buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
+                char *e;
+
+                r = sd_bus_message_peek_type(m, &type, NULL);
+                if (r < 0)
+                        return r;
+
+                if (type != SD_BUS_TYPE_STRING &&
+                    type != SD_BUS_TYPE_OBJECT_PATH &&
+                    type != SD_BUS_TYPE_SIGNATURE)
+                        break;
+
+                r = sd_bus_message_read_basic(m, type, &t);
+                if (r < 0)
+                        return r;
+
+                e = stpcpy(buf, "arg");
+                if (i < 10)
+                        *(e++) = '0' + i;
+                else {
+                        *(e++) = '0' + (i / 10);
+                        *(e++) = '0' + (i % 10);
+                }
+
+                *e = 0;
+                bloom_add_pair(bloom, buf, t);
+
+                strcpy(e, "-dot-prefix");
+                bloom_add_prefixes(bloom, buf, t, '.');
+                strcpy(e, "-slash-prefix");
+                bloom_add_prefixes(bloom, buf, t, '/');
+        }
+
+        return 0;
+}
+
+static int bus_message_setup_kmsg(sd_bus *b, sd_bus_message *m) {
+        struct kdbus_msg_item *d;
         bool well_known;
         uint64_t unique;
         size_t sz, dl;
         int r;
 
+        assert(b);
         assert(m);
         assert(m->sealed);
 
@@ -102,18 +200,25 @@ static int bus_message_setup_kmsg(sd_bus_message *m) {
         } else
                 well_known = false;
 
-        sz = offsetof(struct kdbus_msg, data);
+        sz = offsetof(struct kdbus_msg, items);
+
+        /* Add in fixed header, fields header and payload */
+        sz += 3 * ALIGN8(offsetof(struct kdbus_msg_item, vec) + sizeof(struct kdbus_vec));
 
-        /* Add in fixed header, fields header, fields header padding and payload */
-        sz += 4 * ALIGN8(offsetof(struct kdbus_msg_data, vec) + sizeof(struct kdbus_vec));
+        /* Add space for bloom filter */
+        sz += ALIGN8(offsetof(struct kdbus_msg_item, data) + BLOOM_SIZE);
 
         /* Add in well-known destination header */
         if (well_known) {
                 dl = strlen(m->destination);
-                sz += ALIGN8(offsetof(struct kdbus_msg, data) + dl + 1);
+                sz += ALIGN8(offsetof(struct kdbus_msg_item, str) + dl + 1);
         }
 
-        m->kdbus = aligned_alloc(8, sz);
+        /* Add space for unix fds */
+        if (m->n_fds > 0)
+                sz += ALIGN8(offsetof(struct kdbus_msg_item, fds) + sizeof(int)*m->n_fds);
+
+        m->kdbus = memalign(8, sz);
         if (!m->kdbus)
                 return -ENOMEM;
 
@@ -124,31 +229,39 @@ static int bus_message_setup_kmsg(sd_bus_message *m) {
                 ((m->header->flags & SD_BUS_MESSAGE_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
         m->kdbus->dst_id =
                 well_known ? 0 :
-                m->destination ? unique : (uint64_t) -1;
+                m->destination ? unique : KDBUS_DST_ID_BROADCAST;
         m->kdbus->payload_type = KDBUS_PAYLOAD_DBUS1;
         m->kdbus->cookie = m->header->serial;
 
         m->kdbus->timeout_ns = m->timeout * NSEC_PER_USEC;
 
-        d = m->kdbus->data;
+        d = m->kdbus->items;
 
         if (well_known)
                 append_destination(&d, m->destination, dl);
 
         append_payload_vec(&d, m->header, sizeof(*m->header));
 
-        if (m->fields) {
-                append_payload_vec(&d, m->fields, m->header->fields_size);
+        if (m->fields)
+                append_payload_vec(&d, m->fields, ALIGN8(m->header->fields_size));
+
+        if (m->body)
+                append_payload_vec(&d, m->body, m->header->body_size);
 
-                if (m->header->fields_size % 8 != 0) {
-                        static const uint8_t padding[7] = {};
+        if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
+                void *p;
 
-                        append_payload_vec(&d, padding, 8 - (m->header->fields_size % 8));
+                p = append_bloom(&d, BLOOM_SIZE);
+                r = bus_message_setup_bloom(m, p);
+                if (r < 0) {
+                        free(m->kdbus);
+                        m->kdbus = NULL;
+                        return -r;
                 }
         }
 
-        if (m->body)
-                append_payload_vec(&d, m->body, m->header->body_size);
+        if (m->n_fds > 0)
+                append_fds(&d, m->fds, m->n_fds);
 
         m->kdbus->size = (uint8_t*) d - (uint8_t*) m->kdbus;
         assert(m->kdbus->size <= sz);
@@ -159,7 +272,17 @@ static int bus_message_setup_kmsg(sd_bus_message *m) {
 }
 
 int bus_kernel_take_fd(sd_bus *b) {
-        struct kdbus_cmd_hello hello = {};
+        struct kdbus_cmd_hello hello = {
+                .conn_flags =
+                        KDBUS_HELLO_ACCEPT_FD|
+                        KDBUS_HELLO_ATTACH_COMM|
+                        KDBUS_HELLO_ATTACH_EXE|
+                        KDBUS_HELLO_ATTACH_CMDLINE|
+                        KDBUS_HELLO_ATTACH_CGROUP|
+                        KDBUS_HELLO_ATTACH_CAPS|
+                        KDBUS_HELLO_ATTACH_SECLABEL|
+                        KDBUS_HELLO_ATTACH_AUDIT
+        };
         int r;
 
         assert(b);
@@ -171,11 +294,21 @@ int bus_kernel_take_fd(sd_bus *b) {
         if (r < 0)
                 return -errno;
 
+        /* The higher 32bit of both flags fields are considered
+         * 'incompatible flags'. Refuse them all for now. */
+        if (hello.bus_flags > 0xFFFFFFFFULL ||
+            hello.conn_flags > 0xFFFFFFFFULL)
+                return -ENOTSUP;
+
+        if (hello.bloom_size != BLOOM_SIZE)
+                return -ENOTSUP;
+
         if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello.id) < 0)
                 return -ENOMEM;
 
         b->is_kernel = true;
         b->bus_client = true;
+        b->can_fds = true;
 
         r = bus_start_running(b);
         if (r < 0)
@@ -209,7 +342,7 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
         assert(m);
         assert(bus->state == BUS_RUNNING);
 
-        r = bus_message_setup_kmsg(m);
+        r = bus_message_setup_kmsg(bus, m);
         if (r < 0)
                 return r;
 
@@ -221,27 +354,25 @@ int bus_kernel_write_message(sd_bus *bus, sd_bus_message *m) {
 }
 
 static void close_kdbus_msg(struct kdbus_msg *k) {
-        struct kdbus_msg_data *d;
+        struct kdbus_msg_item *d;
 
-        KDBUS_MSG_FOREACH_DATA(d, k) {
+        KDBUS_ITEM_FOREACH(d, k) {
 
                 if (d->type != KDBUS_MSG_UNIX_FDS)
                         continue;
 
-                close_many(d->fds, (d->size - offsetof(struct kdbus_msg_data, fds)) / sizeof(int));
+                close_many(d->fds, (d->size - offsetof(struct kdbus_msg_item, fds)) / sizeof(int));
         }
 }
 
 static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_message **ret) {
         sd_bus_message *m = NULL;
-        struct kdbus_msg_data *d;
+        struct kdbus_msg_item *d;
         unsigned n_payload = 0, n_fds = 0;
         _cleanup_free_ int *fds = NULL;
         struct bus_header *h = NULL;
         size_t total, n_bytes = 0, idx = 0;
-        struct kdbus_creds *creds = NULL;
-        uint64_t nsec = 0;
-        const char *destination = NULL;
+        const char *destination = NULL, *seclabel = NULL;
         int r;
 
         assert(bus);
@@ -251,10 +382,10 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess
         if (k->payload_type != KDBUS_PAYLOAD_DBUS1)
                 return 0;
 
-        KDBUS_MSG_FOREACH_DATA(d, k) {
+        KDBUS_ITEM_FOREACH(d, k) {
                 size_t l;
 
-                l = d->size - offsetof(struct kdbus_msg_data, data);
+                l = d->size - offsetof(struct kdbus_msg_item, data);
 
                 if (d->type == KDBUS_MSG_PAYLOAD) {
 
@@ -278,15 +409,13 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess
                                 return -ENOMEM;
 
                         fds = f;
-                        memcpy(fds + n_fds, d->fds, j);
+                        memcpy(fds + n_fds, d->fds, sizeof(int) * j);
                         n_fds += j;
 
-                } else if (d->type == KDBUS_MSG_SRC_CREDS)
-                        creds = &d->creds;
-                else if (d->type == KDBUS_MSG_TIMESTAMP)
-                        nsec = d->ts_ns;
-                else if (d->type == KDBUS_MSG_DST_NAME)
+                } else if (d->type == KDBUS_MSG_DST_NAME)
                         destination = d->str;
+                else if (d->type == KDBUS_MSG_SRC_SECLABEL)
+                        seclabel = d->str;
         }
 
         if (!h)
@@ -299,43 +428,59 @@ static int bus_kernel_make_message(sd_bus *bus, struct kdbus_msg *k, sd_bus_mess
         if (n_bytes != total)
                 return -EBADMSG;
 
-        r = bus_message_from_header(h, sizeof(struct bus_header), fds, n_fds, NULL, NULL, 0, &m);
+        r = bus_message_from_header(h, sizeof(struct bus_header), fds, n_fds, NULL, seclabel, 0, &m);
         if (r < 0)
                 return r;
 
-        KDBUS_MSG_FOREACH_DATA(d, k) {
+        KDBUS_ITEM_FOREACH(d, k) {
                 size_t l;
 
-                if (d->type != KDBUS_MSG_PAYLOAD)
-                        continue;
+                l = d->size - offsetof(struct kdbus_msg_item, data);
 
-                l = d->size - offsetof(struct kdbus_msg_data, data);
-                if (idx == sizeof(struct bus_header) &&
-                    l == BUS_MESSAGE_FIELDS_SIZE(m))
-                        m->fields = d->data;
-                else if (idx == sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) &&
-                         l == BUS_MESSAGE_BODY_SIZE(m))
-                        m->body = d->data;
-                else if (!(idx == 0 && l == sizeof(struct bus_header)) &&
-                         !(idx == sizeof(struct bus_header) + BUS_MESSAGE_FIELDS_SIZE(m))) {
-                        sd_bus_message_unref(m);
-                        return -EBADMSG;
-                }
+                if (d->type == KDBUS_MSG_PAYLOAD) {
 
-                idx += l;
-        }
+                        if (idx == sizeof(struct bus_header) &&
+                            l == ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)))
+                                m->fields = d->data;
+                        else if (idx == sizeof(struct bus_header) + ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) &&
+                                 l == BUS_MESSAGE_BODY_SIZE(m))
+                                m->body = d->data;
+                        else if (!(idx == 0 && l == sizeof(struct bus_header))) {
+                                sd_bus_message_unref(m);
+                                return -EBADMSG;
+                        }
 
-        if (creds) {
-                m->pid_starttime = creds->starttime / NSEC_PER_USEC;
-                m->uid = creds->uid;
-                m->gid = creds->gid;
-                m->pid = creds->pid;
-                m->tid = creds->tid;
-                m->uid_valid = m->gid_valid = true;
+                        idx += l;
+                } else if (d->type == KDBUS_MSG_SRC_CREDS) {
+                        m->pid_starttime = d->creds.starttime / NSEC_PER_USEC;
+                        m->uid = d->creds.uid;
+                        m->gid = d->creds.gid;
+                        m->pid = d->creds.pid;
+                        m->tid = d->creds.tid;
+                        m->uid_valid = m->gid_valid = true;
+                } else if (d->type == KDBUS_MSG_TIMESTAMP) {
+                        m->realtime = d->timestamp.realtime_ns / NSEC_PER_USEC;
+                        m->monotonic = d->timestamp.monotonic_ns / NSEC_PER_USEC;
+                } else if (d->type == KDBUS_MSG_SRC_PID_COMM)
+                        m->comm = d->str;
+                else if (d->type == KDBUS_MSG_SRC_TID_COMM)
+                        m->tid_comm = d->str;
+                else if (d->type == KDBUS_MSG_SRC_EXE)
+                        m->exe = d->str;
+                else if (d->type == KDBUS_MSG_SRC_CMDLINE) {
+                        m->cmdline = d->str;
+                        m->cmdline_length = l;
+                } else if (d->type == KDBUS_MSG_SRC_CGROUP)
+                        m->cgroup = d->str;
+                else if (d->type == KDBUS_MSG_SRC_AUDIT)
+                        m->audit = &d->audit;
+                else if (d->type == KDBUS_MSG_SRC_CAPS) {
+                        m->capability = d->data;
+                        m->capability_size = l;
+                } else
+                        log_debug("Got unknown field from kernel %llu", d->type);
         }
 
-        m->timestamp = nsec / NSEC_PER_USEC;
-
         r = bus_message_parse_fields(m);
         if (r < 0) {
                 sd_bus_message_unref(m);
@@ -381,7 +526,7 @@ int bus_kernel_read_message(sd_bus *bus, sd_bus_message **m) {
         for (;;) {
                 void *q;
 
-                q = aligned_alloc(8, sz);
+                q = memalign(8, sz);
                 if (!q)
                         return -errno;
 
@@ -419,7 +564,8 @@ int bus_kernel_read_message(sd_bus *bus, sd_bus_message **m) {
 }
 
 int bus_kernel_create(const char *name, char **s) {
-        struct kdbus_cmd_fname *fname;
+        struct kdbus_cmd_bus_make *make;
+        struct kdbus_cmd_make_item *n, *cg;
         size_t l;
         int fd;
         char *p;
@@ -432,17 +578,31 @@ int bus_kernel_create(const char *name, char **s) {
                 return -errno;
 
         l = strlen(name);
-        fname = alloca(offsetof(struct kdbus_cmd_fname, name) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1);
-        sprintf(fname->name, "%lu-%s", (unsigned long) getuid(), name);
-        fname->size = offsetof(struct kdbus_cmd_fname, name) + strlen(fname->name) + 1;
-        fname->kernel_flags = KDBUS_CMD_FNAME_ACCESS_WORLD | KDBUS_CMD_FNAME_POLICY_OPEN;
-        fname->user_flags = 0;
-
-        p = strjoin("/dev/kdbus/", fname->name, "/bus", NULL);
+        make = alloca0(offsetof(struct kdbus_cmd_bus_make, items) +
+                       sizeof(struct kdbus_cmd_make_item) + sizeof(uint64_t) +
+                       sizeof(struct kdbus_cmd_make_item) + DECIMAL_STR_MAX(uid_t) + 1 + l + 1);
+
+        cg = make->items;
+        cg->type = KDBUS_MAKE_CGROUP;
+        cg->data64[0] = 1;
+        cg->size = sizeof(struct kdbus_cmd_make_item) + sizeof(uint64_t);
+
+        n = KDBUS_ITEM_NEXT(cg);
+        n->type = KDBUS_MAKE_NAME;
+        sprintf(n->str, "%lu-%s", (unsigned long) getuid(), name);
+        n->size = sizeof(struct kdbus_cmd_make_item) + strlen(n->str) + 1;
+
+        make->size = offsetof(struct kdbus_cmd_bus_make, items) + cg->size + n->size;
+        make->flags = KDBUS_MAKE_ACCESS_WORLD | KDBUS_MAKE_POLICY_OPEN;
+        make->bus_flags = 0;
+        make->bloom_size = BLOOM_SIZE;
+        assert_cc(BLOOM_SIZE % 8 == 0);
+
+        p = strjoin("/dev/kdbus/", n->str, "/bus", NULL);
         if (!p)
                 return -ENOMEM;
 
-        if (ioctl(fd, KDBUS_CMD_BUS_MAKE, fname) < 0) {
+        if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
                 close_nointr_nofail(fd);
                 free(p);
                 return -errno;