static int ta_access_test(void)
{
int fd;
if (!opt_silent) {
printf("%s:\n", __func__);
}
fd = tipc_connect(dev_name, ta_only_name);
if (fd >= 0) {
fprintf(stderr, "Succeed to connect to '%s' service\n",
"ta_only");
tipc_close(fd);
}
fd = tipc_connect(dev_name, ns_only_name);
if (fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"ns_only");
return fd;
}
tipc_close(fd);
if (!opt_silent) {
printf("%s: done\n",__func__);
}
return 0;
}
static int closer2_test(uint repeat)
{
uint i;
int fd;
if (!opt_silent) {
printf("%s: repeat = %u\n", __func__, repeat);
}
for (i = 0; i < repeat; i++) {
fd = tipc_connect(dev_name, closer2_name);
if (fd < 0) {
if (!opt_silent) {
printf("failed to connect to '%s' service\n", "closer2");
}
} else {
/* this should always fail */
fprintf(stderr, "connected to '%s' service\n", "closer2");
tipc_close(fd);
}
}
if (!opt_silent) {
printf("%s: done\n", __func__);
}
return 0;
}
static int closer1_test(uint repeat)
{
uint i;
int fd;
if (!opt_silent) {
printf("%s: repeat = %u\n", __func__, repeat);
}
for (i = 0; i < repeat; i++) {
fd = tipc_connect(dev_name, closer1_name);
if (fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"closer1");
continue;
}
if (!opt_silent) {
printf("%s: connected\n", __func__);
}
tipc_close(fd);
}
if (!opt_silent) {
printf("%s: done\n", __func__);
}
return 0;
}
static int dev_uuid_test(void)
{
int fd;
ssize_t rc;
uuid_t uuid;
fd = tipc_connect(dev_name, uuid_name);
if (fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"uuid");
return fd;
}
/* wait for test to complete */
rc = read(fd, &uuid, sizeof(uuid));
if (rc < 0) {
perror("dev_uuid_test: read");
} else if (rc != sizeof(uuid)) {
fprintf(stderr, "unexpected uuid size (%d vs. %d)\n",
(int)rc, (int)sizeof(uuid));
} else {
print_uuid(dev_name, &uuid);
}
tipc_close(fd);
return 0;
}
int storage_open_session(const char *device, storage_session_t *session_p,
const char *port)
{
int rc = tipc_connect(device, port);
if (rc < 0)
return rc;
*session_p = (storage_session_t) rc;
return 0;
}
int trusty_gatekeeper_connect() {
int rc = tipc_connect(TRUSTY_DEVICE_NAME, GATEKEEPER_PORT);
if (rc < 0) {
return rc;
}
handle_ = rc;
return 0;
}
int trusty_keymaster_connect() {
int rc = tipc_connect(TRUSTY_DEVICE_NAME, KEYMASTER_PORT);
if (rc < 0) {
return rc;
}
handle_ = rc;
return 0;
}
bool TrustyNvramImplementation::Connect() {
if (tipc_nvram_fd_ != -1) {
return true;
}
int rc = tipc_connect(kTrustyDeviceName, kTrustyNvramAppId);
if (rc < 0) {
ALOGE("Failed to connect to Trusty NVRAM app: %s\n", strerror(-rc));
return false;
}
tipc_nvram_fd_ = rc;
return true;
}
static int connect_test(uint repeat)
{
uint i;
int echo_fd;
int dsink_fd;
if (!opt_silent) {
printf("%s: repeat = %u\n", __func__, repeat);
}
for (i = 0; i < repeat; i++) {
echo_fd = tipc_connect(dev_name, echo_name);
if (echo_fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"echo");
}
dsink_fd = tipc_connect(dev_name, datasink_name);
if (dsink_fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"datasink");
}
if (echo_fd >= 0) {
tipc_close(echo_fd);
}
if (dsink_fd >= 0) {
tipc_close(dsink_fd);
}
}
if (!opt_silent) {
printf("%s: done\n", __func__);
}
return 0;
}
static int burst_write_test(uint repeat, uint msgburst, uint msgsz, bool var)
{
int fd;
uint i, j;
ssize_t rc;
size_t msg_len;
char tx_buf[msgsz];
if (!opt_silent) {
printf("%s: repeat %u: burst %u: msgsz %u: variable %s\n",
__func__, repeat, msgburst, msgsz,
var ? "true" : "false");
}
for (i = 0; i < repeat; i++) {
fd = tipc_connect(dev_name, datasink_name);
if (fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"datasink");
break;
}
for (j = 0; j < msgburst; j++) {
msg_len = msgsz;
if (var && msgsz) {
msg_len = rand() % msgsz;
}
memset(tx_buf, i + 1, msg_len);
rc = write(fd, tx_buf, msg_len);
if ((size_t)rc != msg_len) {
perror("burst_test: write");
break;
}
}
tipc_close(fd);
}
if (!opt_silent) {
printf("%s: done\n",__func__);
}
return 0;
}
static int select_test(uint repeat, uint msgburst, uint msgsz)
{
int fd;
uint i, j;
ssize_t rc;
char tx_buf[msgsz];
if (!opt_silent) {
printf("%s: repeat %u\n", __func__, repeat);
}
fd = tipc_connect(dev_name, echo_name);
if (fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"echo");
return fd;
}
for (i = 0; i < repeat; i++) {
_wait_for_msg(fd, msgsz, 1);
if (!opt_silent) {
printf("sending burst: %u msg\n", msgburst);
}
for (j = 0; j < msgburst; j++) {
memset(tx_buf, i + j, msgsz);
rc = write(fd, tx_buf, msgsz);
if ((size_t)rc != msgsz) {
perror("burst_test: write");
break;
}
}
}
tipc_close(fd);
if (!opt_silent) {
printf("%s: done\n",__func__);
}
return 0;
}
static int blocked_read_test(uint repeat)
{
int fd;
uint i;
ssize_t rc;
char rx_buf[512];
if (!opt_silent) {
printf("%s: repeat %u\n", __func__, repeat);
}
fd = tipc_connect(dev_name, echo_name);
if (fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"echo");
return fd;
}
for (i = 0; i < repeat; i++) {
rc = read(fd, rx_buf, sizeof(rx_buf));
if (rc < 0) {
perror("select_test: read");
break;
} else {
if (!opt_silent) {
printf("got %zd bytes\n", rc);
}
}
}
tipc_close(fd);
if (!opt_silent) {
printf("%s: done\n",__func__);
}
return 0;
}
static int ta2ta_ipc_test(void)
{
int fd;
char rx_buf[64];
if (!opt_silent) {
printf("%s:\n", __func__);
}
fd = tipc_connect(dev_name, main_ctrl_name);
if (fd < 0) {
fprintf(stderr, "Failed to connect to '%s' service\n",
"main_ctrl");
return fd;
}
/* wait for test to complete */
(void) read(fd, rx_buf, sizeof(rx_buf));
tipc_close(fd);
return 0;
}
static int connect_foo(uint repeat)
{
uint i;
int fd;
if (!opt_silent) {
printf("%s: repeat = %u\n", __func__, repeat);
}
for (i = 0; i < repeat; i++) {
fd = tipc_connect(dev_name, "foo");
if (fd >= 0) {
fprintf(stderr, "succeeded to connect to '%s' service\n",
"foo");
tipc_close(fd);
}
}
if (!opt_silent) {
printf("%s: done\n", __func__);
}
return 0;
}
static int closer3_test(uint repeat)
{
uint i, j;
ssize_t rc;
int fd[4];
char buf[64];
if (!opt_silent) {
printf("%s: repeat = %u\n", __func__, repeat);
}
for (i = 0; i < repeat; i++) {
/* open 4 connections to closer3 service */
for (j = 0; j < 4; j++) {
fd[j] = tipc_connect(dev_name, closer3_name);
if (fd[j] < 0) {
fprintf(stderr, "fd[%d]: failed to connect to '%s' service\n", j, "closer3");
} else {
if (!opt_silent) {
printf("%s: fd[%d]=%d: connected\n", __func__, j, fd[j]);
}
memset(buf, i + j, sizeof(buf));
rc = write(fd[j], buf, sizeof(buf));
if (rc != sizeof(buf)) {
if (!opt_silent) {
printf("%s: fd[%d]=%d: write returned = %zd\n",
__func__, j, fd[j], rc);
}
perror("closer3_test: write");
}
}
}
/* sleep a bit */
sleep(1);
/* It is expected that they will be closed by remote */
for (j = 0; j < 4; j++) {
if (fd[j] < 0)
continue;
rc = write(fd[j], buf, sizeof(buf));
if (rc != sizeof(buf)) {
if (!opt_silent) {
printf("%s: fd[%d]=%d: write returned = %zd\n",
__func__, j, fd[j], rc);
}
perror("closer3_test: write");
}
}
/* then they have to be closed by remote */
for (j = 0; j < 4; j++) {
if (fd[j] >= 0) {
tipc_close(fd[j]);
}
}
}
if (!opt_silent) {
printf("%s: done\n", __func__);
}
return 0;
}
/**
* accept - wait for connection request
* @sock: listening socket
* @newsock: new socket that is to be connected
* @flags: file-related flags associated with socket
*
* Returns 0 on success, errno otherwise
*/
static int accept(struct socket *sock, struct socket *new_sock, int flags)
{
struct sock *new_sk, *sk = sock->sk;
struct sk_buff *buf;
struct tipc_sock *new_tsock;
struct tipc_port *new_tport;
struct tipc_msg *msg;
u32 new_ref;
int res;
lock_sock(sk);
if (sock->state != SS_LISTENING) {
res = -EINVAL;
goto exit;
}
while (skb_queue_empty(&sk->sk_receive_queue)) {
if (flags & O_NONBLOCK) {
res = -EWOULDBLOCK;
goto exit;
}
release_sock(sk);
res = wait_event_interruptible(*sk_sleep(sk),
(!skb_queue_empty(&sk->sk_receive_queue)));
lock_sock(sk);
if (res)
goto exit;
}
buf = skb_peek(&sk->sk_receive_queue);
res = tipc_create(sock_net(sock->sk), new_sock, 0, 0);
if (res)
goto exit;
new_sk = new_sock->sk;
new_tsock = tipc_sk(new_sk);
new_tport = new_tsock->p;
new_ref = new_tport->ref;
msg = buf_msg(buf);
/* we lock on new_sk; but lockdep sees the lock on sk */
lock_sock_nested(new_sk, SINGLE_DEPTH_NESTING);
/*
* Reject any stray messages received by new socket
* before the socket lock was taken (very, very unlikely)
*/
reject_rx_queue(new_sk);
/* Connect new socket to it's peer */
new_tsock->peer_name.ref = msg_origport(msg);
new_tsock->peer_name.node = msg_orignode(msg);
tipc_connect(new_ref, &new_tsock->peer_name);
new_sock->state = SS_CONNECTED;
tipc_set_portimportance(new_ref, msg_importance(msg));
if (msg_named(msg)) {
new_tport->conn_type = msg_nametype(msg);
new_tport->conn_instance = msg_nameinst(msg);
}
/*
* Respond to 'SYN-' by discarding it & returning 'ACK'-.
* Respond to 'SYN+' by queuing it on new socket.
*/
if (!msg_data_sz(msg)) {
struct msghdr m = {NULL,};
advance_rx_queue(sk);
send_packet(NULL, new_sock, &m, 0);
} else {
__skb_dequeue(&sk->sk_receive_queue);
__skb_queue_head(&new_sk->sk_receive_queue, buf);
skb_set_owner_r(buf, new_sk);
}
release_sock(new_sk);
exit:
release_sock(sk);
return res;
}
static int echo_test(uint repeat, uint msgsz, bool var)
{
uint i;
ssize_t rc;
size_t msg_len;
int echo_fd =-1;
char tx_buf[msgsz];
char rx_buf[msgsz];
if (!opt_silent) {
printf("%s: repeat %u: msgsz %u: variable %s\n",
__func__, repeat, msgsz, var ? "true" : "false");
}
echo_fd = tipc_connect(dev_name, echo_name);
if (echo_fd < 0) {
fprintf(stderr, "Failed to connect to service\n");
return echo_fd;
}
for (i = 0; i < repeat; i++) {
msg_len = msgsz;
if (opt_variable && msgsz) {
msg_len = rand() % msgsz;
}
memset(tx_buf, i + 1, msg_len);
rc = write(echo_fd, tx_buf, msg_len);
if ((size_t)rc != msg_len) {
perror("echo_test: write");
break;
}
rc = read(echo_fd, rx_buf, msg_len);
if (rc < 0) {
perror("echo_test: read");
break;
}
if ((size_t)rc != msg_len) {
fprintf(stderr, "data truncated (%zu vs. %zu)\n",
rc, msg_len);
continue;
}
if (memcmp(tx_buf, rx_buf, (size_t) rc)) {
fprintf(stderr, "data mismatch\n");
continue;
}
}
tipc_close(echo_fd);
if (!opt_silent) {
printf("%s: done\n",__func__);
}
return 0;
}
int tipc_bind(int sd, uint32_t type, uint32_t lower, uint32_t upper,
tipc_domain_t scope)
{
struct sockaddr_tipc addr = {
.family = AF_TIPC,
.addrtype = TIPC_ADDR_NAMESEQ,
.addr.nameseq.type = type,
.addr.nameseq.lower = lower,
.addr.nameseq.upper = upper
};
if (tipc_own_node() == scope)
addr.scope = TIPC_NODE_SCOPE;
if (tipc_own_cluster() == scope)
addr.scope = TIPC_CLUSTER_SCOPE;
if (tipc_own_zone() == scope)
addr.scope = TIPC_ZONE_SCOPE;
/* TODO: introduce support for global scope in module */
if (!scope)
addr.scope = TIPC_ZONE_SCOPE;
if (!my_scope(scope))
return -1;
return bind(sd, (struct sockaddr *)&addr, sizeof(addr));
}
int tipc_unbind(int sd, uint32_t type, uint32_t lower, uint32_t upper)
{
struct sockaddr_tipc addr = {
.family = AF_TIPC,
.addrtype = TIPC_ADDR_NAMESEQ,
.addr.nameseq.type = type,
.addr.nameseq.lower = lower,
.addr.nameseq.upper = upper,
.scope = -1
};
return bind(sd, (struct sockaddr *)&addr, sizeof(addr));
}
int tipc_connect(int sd, const struct tipc_addr *dst)
{
struct sockaddr_tipc addr;
if (!dst)
return -1;
addr.family = AF_TIPC;
addr.addrtype = TIPC_ADDR_NAME;
addr.addr.name.name.type = dst->type;
addr.addr.name.name.instance = dst->instance;
addr.addr.name.domain = dst->domain;
return connect(sd, (struct sockaddr*)&addr, sizeof(addr));
}
int tipc_listen(int sd, int backlog)
{
return listen(sd, backlog);
}
int tipc_accept(int sd, struct tipc_addr *src)
{
struct sockaddr_tipc addr;
socklen_t addrlen = sizeof(addr);
int rc;
rc = accept(sd, (struct sockaddr *) &addr, &addrlen);
if (src) {
src->type = 0;
src->instance = addr.addr.id.ref;
src->domain = addr.addr.id.node;
}
return rc;
}
int tipc_send(int sd, const char *msg, size_t msg_len)
{
return send(sd, msg, msg_len, 0);
}
int tipc_sendmsg(int sd, const struct msghdr *msg)
{
return sendmsg(sd, msg, 0);
}
int tipc_sendto(int sd, const char *msg, size_t msg_len,
const struct tipc_addr *dst)
{
struct sockaddr_tipc addr;
if(!dst)
return -1;
addr.family = AF_TIPC;
if (dst->type) {
addr.addrtype = TIPC_ADDR_NAME;
addr.addr.name.name.type = dst->type;
addr.addr.name.name.instance = dst->instance;
addr.addr.name.domain = dst->domain;
} else {
addr.addrtype = TIPC_ADDR_ID;
addr.addr.id.ref = dst->instance;
addr.addr.id.node = dst->domain;
}
return sendto(sd, msg, msg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
}
int tipc_mcast(int sd, const char *msg, size_t msg_len,
const struct tipc_addr *dst)
{
struct sockaddr_tipc addr = {
.family = AF_TIPC,
.addrtype = TIPC_ADDR_MCAST,
.addr.name.domain = TIPC_CLUSTER_SCOPE
};
if(!dst)
return -1;
addr.addr.nameseq.type = dst->type;
addr.addr.nameseq.lower = dst->instance;
addr.addr.nameseq.upper = dst->instance;
if (dst->domain != tipc_own_cluster())
return -ENOTSUP;
return sendto(sd, msg, msg_len, 0,
(struct sockaddr*)&addr, sizeof(addr));
}
int tipc_recv(int sd, char* buf, size_t buf_len, bool waitall)
{
int flags = waitall ? MSG_WAITALL : 0;
return recv(sd, buf, buf_len, flags);
}
int tipc_recvfrom(int sd, char *buf, size_t len, struct tipc_addr *src,
struct tipc_addr *dst, int *err)
{
int rc, _err = 0;
struct sockaddr_tipc addr;
struct iovec iov = {buf, len};
struct msghdr msg = {0, };
char anc_space[CMSG_SPACE(8) + CMSG_SPACE(1024) + CMSG_SPACE(16)];
struct cmsghdr *anc;
msg.msg_name = &addr;
msg.msg_namelen = sizeof(addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = (struct cmsghdr *)anc_space;
msg.msg_controllen = sizeof(anc_space);
rc = recvmsg(sd ,&msg ,0);
if (rc < 0)
return rc;
if (src) {
src->type = 0;
src->instance = addr.addr.id.ref;
src->domain = addr.addr.id.node;
}
anc = CMSG_FIRSTHDR(&msg);
if (anc && (anc->cmsg_type == TIPC_ERRINFO)) {
_err = *(int*)(CMSG_DATA(anc));
rc = *(int*)(CMSG_DATA(anc) + 4);
if (rc > len)
rc = len;
anc = CMSG_NXTHDR(&msg, anc);
memcpy(buf, (char*)CMSG_DATA(anc), rc);
anc = CMSG_NXTHDR(&msg, anc);
}
if (_err)
tipc_sockid(sd, src);
if (err)
*err = _err;
else if (_err)
rc = 0;
if (!dst)
return rc;
if (anc && (anc->cmsg_type == TIPC_DESTNAME)) {
dst->type = *((uint32_t*)(CMSG_DATA(anc)));
dst->instance = *((uint32_t*)(CMSG_DATA(anc) + 4));
dst->domain = 0;
} else {
tipc_sockid(sd, dst);
}
return rc;
}
int tipc_topsrv_conn(tipc_domain_t node)
{
int sd;
struct tipc_addr srv = {TIPC_TOP_SRV, TIPC_TOP_SRV, node};
sd = tipc_socket(SOCK_SEQPACKET);
if (sd <= 0)
return sd;
if (tipc_connect(sd, &srv) < 0)
tipc_close(sd);
return sd;
}
static int readv_test(uint repeat, uint msgsz, bool var)
{
uint i;
ssize_t rc;
size_t msg_len;
int echo_fd = -1;
char tx_buf [msgsz];
char rx0_buf[msgsz];
char rx1_buf[msgsz];
struct iovec iovs[2]= {{rx0_buf, 0}, {rx1_buf, 0}};
if (!opt_silent) {
printf("%s: repeat %u: msgsz %u: variable %s\n",
__func__, repeat, msgsz, var ? "true" : "false");
}
echo_fd = tipc_connect(dev_name, echo_name);
if (echo_fd < 0) {
fprintf(stderr, "Failed to connect to service\n");
return echo_fd;
}
for (i = 0; i < repeat; i++) {
msg_len = msgsz;
if (opt_variable && msgsz) {
msg_len = rand() % msgsz;
}
iovs[0].iov_len = msg_len / 3;
iovs[1].iov_len = msg_len - iovs[0].iov_len;
memset(tx_buf, i + 1, sizeof(tx_buf));
memset(rx0_buf, i + 2, iovs[0].iov_len);
memset(rx1_buf, i + 3, iovs[1].iov_len);
rc = write(echo_fd, tx_buf, msg_len);
if (rc < 0) {
perror("readv_test: write");
break;
}
if ((size_t)rc != msg_len) {
fprintf(stderr,
"%s: %s: data size mismatch (%zd vs. %zd)\n",
__func__, "write", (size_t)rc, msg_len);
break;
}
rc = readv(echo_fd, iovs, 2);
if (rc < 0) {
perror("readv_test: readv");
break;
}
if ((size_t)rc != msg_len) {
fprintf(stderr,
"%s: %s: data size mismatch (%zd vs. %zd)\n",
__func__, "write", (size_t)rc, msg_len);
break;
}
if (memcmp(rx0_buf, tx_buf, iovs[0].iov_len)) {
fprintf(stderr, "%s: data mismatch: buf 0\n", __func__);
break;
}
if (memcmp(rx1_buf, tx_buf + iovs[0].iov_len, iovs[1].iov_len)) {
fprintf(stderr, "%s: data mismatch, buf 1\n", __func__);
break;
}
}
tipc_close(echo_fd);
if (!opt_silent) {
printf("%s: done\n",__func__);
}
return 0;
}
