#include "bus-kernel.h"
#include "bus-bloom.h"
#include "bus-util.h"
+#include "bus-label.h"
#include "cgroup-util.h"
#define UNIQUE_NAME_MAX (3+DECIMAL_STR_MAX(uint64_t))
assert(bloom);
data = bloom->data;
- memset(data, 0, BLOOM_SIZE);
+ memzero(data, m->bus->bloom_size);
bloom->generation = 0;
- bloom_add_pair(data, "message-type", bus_message_type_to_string(m->header->type));
+ bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "message-type", bus_message_type_to_string(m->header->type));
if (m->interface)
- bloom_add_pair(data, "interface", m->interface);
+ bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "interface", m->interface);
if (m->member)
- bloom_add_pair(data, "member", m->member);
+ bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "member", m->member);
if (m->path) {
- bloom_add_pair(data, "path", m->path);
- bloom_add_pair(data, "path-slash-prefix", m->path);
- bloom_add_prefixes(data, "path-slash-prefix", m->path, '/');
+ bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path", m->path);
+ bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path);
+ bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, "path-slash-prefix", m->path, '/');
}
r = sd_bus_message_rewind(m, true);
}
*e = 0;
- bloom_add_pair(data, buf, t);
+ bloom_add_pair(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t);
strcpy(e, "-dot-prefix");
- bloom_add_prefixes(data, buf, t, '.');
+ bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '.');
strcpy(e, "-slash-prefix");
- bloom_add_prefixes(data, buf, t, '/');
+ bloom_add_prefixes(data, m->bus->bloom_size, m->bus->bloom_n_hash, buf, t, '/');
}
return 0;
/* Add space for bloom filter */
sz += ALIGN8(offsetof(struct kdbus_item, bloom_filter) +
offsetof(struct kdbus_bloom_filter, data) +
- BLOOM_SIZE);
+ m->bus->bloom_size);
/* Add in well-known destination header */
if (well_known) {
}
m->free_kdbus = true;
- memset(m->kdbus, 0, sz);
+ memzero(m->kdbus, sz);
m->kdbus->flags =
((m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
continue;
}
- /* Otherwise let's send a vector to the actual data,
- * for that we need to map it first. */
+ /* Otherwise, let's send a vector to the actual data.
+ * For that, we need to map it first. */
r = bus_body_part_map(part);
if (r < 0)
goto fail;
if (m->kdbus->dst_id == KDBUS_DST_ID_BROADCAST) {
struct kdbus_bloom_filter *bloom;
- bloom = append_bloom(&d, BLOOM_SIZE);
+ bloom = append_bloom(&d, m->bus->bloom_size);
r = bus_message_setup_bloom(m, bloom);
if (r < 0)
goto fail;
b->use_memfd = 1;
if (b->connection_name) {
- g = sd_bus_label_escape(b->connection_name);
+ g = bus_label_escape(b->connection_name);
if (!g)
return -ENOMEM;
} else {
_cleanup_free_ char *e = NULL;
- e = sd_bus_label_escape(pr);
+ e = bus_label_escape(pr);
if (!e)
return -ENOMEM;
name = g;
}
- b->connection_name = sd_bus_label_unescape(name);
+ b->connection_name = bus_label_unescape(name);
if (!b->connection_name)
return -ENOMEM;
}
hello->conn_flags > 0xFFFFFFFFULL)
return -ENOTSUP;
- if (hello->bloom.size != BLOOM_SIZE)
+ if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash))
return -ENOTSUP;
+ b->bloom_size = (size_t) hello->bloom.size;
+ b->bloom_n_hash = (unsigned) hello->bloom.n_hash;
+
if (asprintf(&b->unique_name, ":1.%llu", (unsigned long long) hello->id) < 0)
return -ENOMEM;
r = sd_bus_message_new_signal(
bus,
+ &m,
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
- "NameOwnerChanged",
- &m);
+ "NameOwnerChanged");
if (r < 0)
return r;
assert(bus->connection_name);
- g = sd_bus_label_escape(bus->connection_name);
+ g = bus_label_escape(bus->connection_name);
if (!g)
return -ENOMEM;
n->size = offsetof(struct kdbus_item, bloom_parameter) +
sizeof(struct kdbus_bloom_parameter);
n->type = KDBUS_ITEM_BLOOM_PARAMETER;
- n->bloom_parameter.size = BLOOM_SIZE;
- n->bloom_parameter.n_hash = 1;
- assert_cc(BLOOM_SIZE % 8 == 0);
+
+ n->bloom_parameter.size = DEFAULT_BLOOM_SIZE;
+ n->bloom_parameter.n_hash = DEFAULT_BLOOM_N_HASH;
+
+ assert_cc(DEFAULT_BLOOM_SIZE > 0);
+ assert_cc(DEFAULT_BLOOM_N_HASH > 0);
+
make->size += ALIGN8(n->size);
n = KDBUS_ITEM_NEXT(n);
n->type = KDBUS_ITEM_MAKE_NAME;
make->size += ALIGN8(n->size);
- make->flags = KDBUS_MAKE_POLICY_OPEN | (world ? KDBUS_MAKE_ACCESS_WORLD : 0);
+ make->flags = world ? KDBUS_MAKE_ACCESS_WORLD : 0;
if (ioctl(fd, KDBUS_CMD_BUS_MAKE, make) < 0) {
close_nointr_nofail(fd);
return fd;
}
-int bus_kernel_create_starter(const char *bus, const char *name) {
+static void bus_kernel_translate_policy(const BusNamePolicy *policy, struct kdbus_item *item)
+{
+ switch (policy->type) {
+ case BUSNAME_POLICY_TYPE_USER:
+ item->policy_access.type = KDBUS_POLICY_ACCESS_USER;
+ item->policy_access.id = policy->uid;
+ break;
+
+ case BUSNAME_POLICY_TYPE_GROUP:
+ item->policy_access.type = KDBUS_POLICY_ACCESS_GROUP;
+ item->policy_access.id = policy->gid;
+ break;
+
+ case BUSNAME_POLICY_TYPE_WORLD:
+ item->policy_access.type = KDBUS_POLICY_ACCESS_WORLD;
+ break;
+
+ default:
+ assert_not_reached("Unknown policy type");
+ }
+
+ switch (policy->access) {
+ case BUSNAME_POLICY_ACCESS_SEE:
+ item->policy_access.access = KDBUS_POLICY_SEE;
+ break;
+
+ case BUSNAME_POLICY_ACCESS_TALK:
+ item->policy_access.access = KDBUS_POLICY_TALK;
+ break;
+
+ case BUSNAME_POLICY_ACCESS_OWN:
+ item->policy_access.access = KDBUS_POLICY_OWN;
+ break;
+
+ default:
+ assert_not_reached("Unknown policy access");
+ }
+}
+
+int bus_kernel_create_starter(const char *bus, const char *name, BusNamePolicy *policy) {
struct kdbus_cmd_hello *hello;
struct kdbus_item *n;
+ size_t policy_cnt = 0;
+ BusNamePolicy *po;
+ size_t size;
char *p;
int fd;
if (fd < 0)
return -errno;
- hello = alloca0(ALIGN8(offsetof(struct kdbus_cmd_hello, items) +
- offsetof(struct kdbus_item, str) +
- strlen(name) + 1));
+ LIST_FOREACH(policy, po, policy)
+ policy_cnt++;
+
+ size = ALIGN8(offsetof(struct kdbus_cmd_hello, items)) +
+ ALIGN8(offsetof(struct kdbus_item, str) + strlen(name) + 1) +
+ policy_cnt * ALIGN8(offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access));
+
+ hello = alloca0(size);
n = hello->items;
strcpy(n->str, name);
n->size = offsetof(struct kdbus_item, str) + strlen(n->str) + 1;
n->type = KDBUS_ITEM_NAME;
+ n = KDBUS_ITEM_NEXT(n);
+
+ LIST_FOREACH(policy, po, policy) {
+ n->type = KDBUS_ITEM_POLICY_ACCESS;
+ n->size = offsetof(struct kdbus_item, policy_access) + sizeof(struct kdbus_policy_access);
+ bus_kernel_translate_policy(po, n);
+ n = KDBUS_ITEM_NEXT(n);
+ }
- hello->size = ALIGN8(offsetof(struct kdbus_cmd_hello, items) + n->size);
+ hello->size = size;
hello->conn_flags = KDBUS_HELLO_ACTIVATOR;
hello->pool_size = KDBUS_POOL_SIZE;
return -ENOTSUP;
}
- if (hello->bloom.size != BLOOM_SIZE) {
+ if (!bloom_validate_parameters((size_t) hello->bloom.size, (unsigned) hello->bloom.n_hash)) {
close_nointr_nofail(fd);
return -ENOTSUP;
}
return fd;
}
-int bus_kernel_create_namespace(const char *name, char **s) {
+int bus_kernel_create_domain(const char *name, char **s) {
struct kdbus_cmd_make *make;
struct kdbus_item *n;
int fd;
n->type = KDBUS_ITEM_MAKE_NAME;
make->size = ALIGN8(offsetof(struct kdbus_cmd_make, items) + n->size);
- make->flags = KDBUS_MAKE_POLICY_OPEN | KDBUS_MAKE_ACCESS_WORLD;
+ make->flags = KDBUS_MAKE_ACCESS_WORLD;
- if (ioctl(fd, KDBUS_CMD_NS_MAKE, make) < 0) {
+ if (ioctl(fd, KDBUS_CMD_DOMAIN_MAKE, make) < 0) {
close_nointr_nofail(fd);
return -errno;
}
if (s) {
char *p;
- p = strappend("/dev/kdbus/ns/", name);
+ p = strappend("/dev/kdbus/domain/", name);
if (!p) {
close_nointr_nofail(fd);
return -ENOMEM;
~ianmdlvl / elogind.git / blobdiff