int main(int argc, char *argv[])
{
struct {
struct kdbus_cmd_make head;
/* bloom size item */
struct {
uint64_t size;
uint64_t type;
struct kdbus_bloom_parameter bloom;
} bs;
/* name item */
uint64_t n_size;
uint64_t n_type;
char name[64];
} bus_make;
int fdc, ret;
char *bus;
struct conn *activator, *conn_a;
struct pollfd fds[2];
bool activator_done = false;
struct kdbus_policy_access access[2];
printf("-- opening /dev/" KBUILD_MODNAME "/control\n");
fdc = open("/dev/" KBUILD_MODNAME "/control", O_RDWR|O_CLOEXEC);
if (fdc < 0) {
fprintf(stderr, "--- error %d (%m)\n", fdc);
return EXIT_FAILURE;
}
memset(&bus_make, 0, sizeof(bus_make));
bus_make.bs.size = sizeof(bus_make.bs);
bus_make.bs.type = KDBUS_ITEM_BLOOM_PARAMETER;
bus_make.bs.bloom.size = 64;
bus_make.bs.bloom.n_hash = 1;
snprintf(bus_make.name, sizeof(bus_make.name), "%u-testbus", getuid());
bus_make.n_type = KDBUS_ITEM_MAKE_NAME;
bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1;
bus_make.head.size = sizeof(struct kdbus_cmd_make) +
sizeof(bus_make.bs) +
bus_make.n_size;
printf("-- creating bus '%s'\n", bus_make.name);
ret = ioctl(fdc, KDBUS_CMD_BUS_MAKE, &bus_make);
if (ret) {
fprintf(stderr, "--- error %d (%m)\n", ret);
return EXIT_FAILURE;
}
if (asprintf(&bus, "/dev/" KBUILD_MODNAME "/%s/bus", bus_make.name) < 0)
return EXIT_FAILURE;
access[0].type = KDBUS_POLICY_ACCESS_USER;
access[0].id = 1001;
access[0].access = KDBUS_POLICY_OWN;
access[1].type = KDBUS_POLICY_ACCESS_WORLD;
access[1].access = KDBUS_POLICY_TALK;
activator = kdbus_hello_activator(bus, "foo.test.activator", access, 2);
if (!activator)
return EXIT_FAILURE;
conn_a = kdbus_hello(bus, 0, NULL, 0);
if (!conn_a)
return EXIT_FAILURE;
add_match_empty(conn_a->fd);
name_list(conn_a, KDBUS_NAME_LIST_NAMES |
KDBUS_NAME_LIST_UNIQUE |
KDBUS_NAME_LIST_ACTIVATORS |
KDBUS_NAME_LIST_QUEUED);
msg_send(conn_a, "foo.test.activator", 0xdeafbeef, 0, 0, 0, KDBUS_DST_ID_NAME);
fds[0].fd = activator->fd;
fds[1].fd = conn_a->fd;
printf("-- entering poll loop ...\n");
for (;;) {
int i, nfds = sizeof(fds) / sizeof(fds[0]);
for (i = 0; i < nfds; i++) {
fds[i].events = POLLIN | POLLPRI;
fds[i].revents = 0;
}
ret = poll(fds, nfds, 3000);
if (ret <= 0)
break;
name_list(conn_a, KDBUS_NAME_LIST_NAMES);
if ((fds[0].revents & POLLIN) && !activator_done) {
printf("Starter was called back!\n");
ret = name_acquire(conn_a, "foo.test.activator", KDBUS_NAME_REPLACE_EXISTING);
if (ret != 0)
break;
activator_done = true;
}
if (fds[1].revents & POLLIN) {
msg_recv(conn_a);
break;
}
}
printf("-- closing bus connections\n");
close(activator->fd);
close(conn_a->fd);
free(activator);
free(conn_a);
printf("-- closing bus master\n");
close(fdc);
free(bus);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct {
struct kdbus_cmd_bus_make head;
/* name item */
uint64_t n_size;
uint64_t n_type;
char name[64];
} __attribute__ ((__aligned__(8))) bus_make;
int fdc, ret;
char *bus;
struct conn *conn_a;
struct conn *conn_b;
struct pollfd fds[2];
struct timeval start;
unsigned int i;
for (i = 0; i < sizeof(stress_payload); i++)
stress_payload[i] = i;
printf("-- opening /dev/kdbus/control\n");
fdc = open("/dev/kdbus/control", O_RDWR|O_CLOEXEC);
if (fdc < 0) {
fprintf(stderr, "--- error %d (%m)\n", fdc);
return EXIT_FAILURE;
}
memset(&bus_make, 0, sizeof(bus_make));
bus_make.head.bloom_size = 64;
snprintf(bus_make.name, sizeof(bus_make.name), "%u-testbus", getuid());
bus_make.n_type = KDBUS_ITEM_MAKE_NAME;
bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1;
bus_make.head.size = sizeof(struct kdbus_cmd_bus_make) +
bus_make.n_size;
printf("-- creating bus '%s'\n", bus_make.name);
ret = ioctl(fdc, KDBUS_CMD_BUS_MAKE, &bus_make);
if (ret) {
fprintf(stderr, "--- error %d (%m)\n", ret);
return EXIT_FAILURE;
}
if (asprintf(&bus, "/dev/kdbus/%s/bus", bus_make.name) < 0)
return EXIT_FAILURE;
conn_a = connect_to_bus(bus);
if (!conn_a)
return EXIT_FAILURE;
conn_b = connect_to_bus(bus);
if (!conn_b)
return EXIT_FAILURE;
upload_policy(conn_a->fd, SERVICE_NAME);
add_match_empty(conn_a->fd);
add_match_empty(conn_b->fd);
fds[0].fd = conn_a->fd;
fds[1].fd = conn_b->fd;
name_acquire(conn_a, SERVICE_NAME, 0);
gettimeofday(&start, NULL);
reset_stats();
ret = send_echo_request(conn_b, conn_a->id);
if (ret)
return EXIT_FAILURE;
printf("-- entering poll loop ...\n");
while (1) {
struct timeval now;
unsigned int nfds = sizeof(fds) / sizeof(fds[0]);
unsigned int i;
for (i = 0; i < nfds; i++) {
fds[i].events = POLLIN | POLLPRI | POLLHUP;
fds[i].revents = 0;
}
ret = poll(fds, nfds, 10);
if (ret < 0)
break;
if (fds[0].revents & POLLIN) {
ret = handle_echo_reply(conn_a);
if (ret)
break;
ret = send_echo_request(conn_b, conn_a->id);
if (ret)
break;
}
gettimeofday(&now, NULL);
if (timeval_diff(&now, &start) / 1000ULL > 1000ULL) {
start.tv_sec = now.tv_sec;
start.tv_usec = now.tv_usec;
dump_stats();
reset_stats();
}
}
printf("-- closing bus connections\n");
close(conn_a->fd);
close(conn_b->fd);
free(conn_a);
free(conn_b);
printf("-- closing bus master\n");
close(fdc);
free(bus);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct {
struct kdbus_cmd_bus_make head;
/* name item */
uint64_t n_size;
uint64_t n_type;
char name[64];
} __attribute__ ((__aligned__(8))) bus_make;
int fdc, ret, cookie;
char *bus;
struct conn *conn_a, *conn_b;
struct pollfd fds[2];
int count;
int r;
printf("-- opening /dev/kdbus/control\n");
fdc = open("/dev/kdbus/control", O_RDWR|O_CLOEXEC);
if (fdc < 0) {
fprintf(stderr, "--- error %d (%m)\n", fdc);
return EXIT_FAILURE;
}
memset(&bus_make, 0, sizeof(bus_make));
bus_make.head.bloom_size = 64;
snprintf(bus_make.name, sizeof(bus_make.name), "%u-testbus", getuid());
bus_make.n_type = KDBUS_ITEM_MAKE_NAME;
bus_make.n_size = KDBUS_ITEM_HEADER_SIZE + strlen(bus_make.name) + 1;
bus_make.head.size = sizeof(struct kdbus_cmd_bus_make) +
bus_make.n_size;
printf("-- creating bus '%s'\n", bus_make.name);
ret = ioctl(fdc, KDBUS_CMD_BUS_MAKE, &bus_make);
if (ret) {
fprintf(stderr, "--- error %d (%m)\n", ret);
return EXIT_FAILURE;
}
if (asprintf(&bus, "/dev/kdbus/%s/bus", bus_make.name) < 0)
return EXIT_FAILURE;
conn_a = connect_to_bus(bus);
conn_b = connect_to_bus(bus);
if (!conn_a || !conn_b)
return EXIT_FAILURE;
r = upload_policy(conn_a->fd, "foo.bar.test");
if (r < 0)
return EXIT_FAILURE;
r = upload_policy(conn_a->fd, "foo.bar.baz");
if (r < 0)
return EXIT_FAILURE;
r = upload_policy(conn_a->fd, "foo.bar.double");
if (r < 0)
return EXIT_FAILURE;
r = name_acquire(conn_a, "foo.bar.test", KDBUS_NAME_ALLOW_REPLACEMENT);
if (r < 0)
return EXIT_FAILURE;
r = name_acquire(conn_a, "foo.bar.baz", 0);
if (r < 0)
return EXIT_FAILURE;
r = name_acquire(conn_b, "foo.bar.baz", KDBUS_NAME_QUEUE);
if (r < 0)
return EXIT_FAILURE;
r = name_acquire(conn_a, "foo.bar.double", 0);
if (r < 0)
return EXIT_FAILURE;
r = name_acquire(conn_a, "foo.bar.double", 0);
if (r != -EALREADY)
return EXIT_FAILURE;
r = name_release(conn_a, "foo.bar.double");
if (r < 0)
return EXIT_FAILURE;
r = name_release(conn_a, "foo.bar.double");
if (r != -ESRCH)
return EXIT_FAILURE;
name_list(conn_b, KDBUS_NAME_LIST_UNIQUE | KDBUS_NAME_LIST_NAMES);
add_match_empty(conn_a->fd);
add_match_empty(conn_b->fd);
cookie = 0;
msg_send(conn_b, NULL, 0xc0000000 | cookie, KDBUS_DST_ID_BROADCAST);
fds[0].fd = conn_a->fd;
fds[1].fd = conn_b->fd;
printf("-- entering poll loop ...\n");
for (count = 0;; count++) {
int i, nfds = sizeof(fds) / sizeof(fds[0]);
for (i = 0; i < nfds; i++) {
fds[i].events = POLLIN | POLLPRI | POLLHUP;
fds[i].revents = 0;
}
ret = poll(fds, nfds, 3000);
if (ret <= 0)
break;
if (fds[0].revents & POLLIN) {
if (count > 2)
name_release(conn_a, "foo.bar.baz");
msg_recv(conn_a);
msg_send(conn_a, NULL, 0xc0000000 | cookie++, conn_b->id);
}
if (fds[1].revents & POLLIN) {
msg_recv(conn_b);
msg_send(conn_b, NULL, 0xc0000000 | cookie++, conn_a->id);
}
name_list(conn_b, KDBUS_NAME_LIST_UNIQUE | KDBUS_NAME_LIST_NAMES);
if (count > 10)
break;
}
printf("-- closing bus connections\n");
close(conn_a->fd);
close(conn_b->fd);
free(conn_a);
free(conn_b);
printf("-- closing bus master\n");
close(fdc);
free(bus);
return EXIT_SUCCESS;
}
