Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: 2588cd802f
Fetching contributors…

Cannot retrieve contributors at this time

817 lines (644 sloc) 18.722 kB
/*
** Copyright 2009 The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
/** socket testing */
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <sys/uio.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/rfcomm.h>
#include <bluetooth/sco.h>
#include <bluetooth/l2cap.h>
enum sock_type {
UNIX = 0,
RFCOMM,
SCO,
L2CAP,
TCP,
};
struct thread_args {
int fd;
int type;
int delay;
};
struct sockaddr_un local_addr_un = {AF_UNIX, "/data/foo"};
struct sockaddr_rc local_addr_rc = {AF_BLUETOOTH, *BDADDR_ANY, 4};
struct sockaddr_sco local_addr_sco = {AF_BLUETOOTH, *BDADDR_LOCAL};
struct sockaddr_l2 local_addr_l2 = {AF_BLUETOOTH, htobs(0x1001), *BDADDR_ANY, 0};
struct sockaddr_in local_addr_in = {AF_INET, 9999, {0}, {0}};
struct sockaddr_un remote_addr_un ;
struct sockaddr_rc remote_addr_rc ;
struct sockaddr_sco remote_addr_sco ;
struct sockaddr_l2 remote_addr_l2 ;
struct sockaddr_in remote_addr_in ;
static void print_events(int events) {
if (events & POLLIN) printf("POLLIN ");
if (events & POLLPRI) printf("POLLPRI ");
if (events & POLLOUT) printf("POLLOUT ");
if (events & POLLERR) printf("POLLERR ");
if (events & POLLHUP) printf("POLLHUP ");
if (events & POLLNVAL) printf("POLLNVAL ");
printf("\n");
}
static void print_fds(struct pollfd *ufds, nfds_t nfds) {
unsigned int i;
for (i=0; i<nfds; i++)
printf("%d ", ufds[i].fd);
}
static int _socket(int type) {
int ret;
int family = -1;
int typ = -1;
int protocol = -1;
switch (type) {
case UNIX:
family = PF_UNIX;
typ = SOCK_STREAM;
protocol = 0;
break;
case RFCOMM:
family = PF_BLUETOOTH;
typ = SOCK_STREAM;
protocol = BTPROTO_RFCOMM;
break;
case SCO:
family = PF_BLUETOOTH;
typ = SOCK_SEQPACKET;
protocol = BTPROTO_SCO;
break;
case L2CAP:
family = PF_BLUETOOTH;
typ = SOCK_SEQPACKET;
protocol = BTPROTO_L2CAP;
break;
case TCP:
family = PF_INET;
typ = SOCK_STREAM;
protocol = 0;
break;
}
printf("%ld: socket()\n", pthread_self());
ret = socket(family, typ, protocol);
printf("%ld: socket() = %d\n", pthread_self(), ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _close(int fd, int type) {
int ret;
printf("%ld: close(%d)\n", pthread_self(), fd);
ret = close(fd);
printf("%ld: close(%d) = %d\n", pthread_self(), fd, ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _bind(int fd, int type) {
int len = 0;
int ret;
struct sockaddr *addr = NULL;
switch (type) {
case UNIX:
unlink(local_addr_un.sun_path);
addr = (struct sockaddr *) &local_addr_un;
len = sizeof(local_addr_un);
break;
case RFCOMM:
addr = (struct sockaddr *) &local_addr_rc;
len = sizeof(local_addr_rc);
break;
case SCO:
addr = (struct sockaddr *) &local_addr_sco;
len = sizeof(local_addr_sco);
break;
case L2CAP:
addr = (struct sockaddr *) &local_addr_l2;
len = sizeof(local_addr_l2);
break;
case TCP:
addr = (struct sockaddr *) &local_addr_in;
len = sizeof(local_addr_in);
break;
}
printf("%ld: bind(%d)\n", pthread_self(), fd);
ret = bind(fd, addr, len);
printf("%ld: bind(%d) = %d\n", pthread_self(), fd, ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _listen(int fd, int type) {
int ret;
printf("%ld: listen(%d)\n", pthread_self(), fd);
ret = listen(fd, 1);
printf("%ld: listen(%d) = %d\n", pthread_self(), fd, ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _read(int fd) {
int ret;
char buf;
printf("%ld: read(%d)\n", pthread_self(), fd);
ret = read(fd, &buf, 1);
printf("%ld: read(%d) = %d [%d]\n", pthread_self(), fd, ret, (int)buf);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _accept(int fd, int type) {
int ret;
int len;
struct sockaddr *addr = NULL;
switch (type) {
case UNIX:
addr = (struct sockaddr *) &remote_addr_un;
len = sizeof(remote_addr_un);
break;
case RFCOMM:
addr = (struct sockaddr *) &remote_addr_rc;
len = sizeof(remote_addr_rc);
break;
case SCO:
addr = (struct sockaddr *) &remote_addr_sco;
len = sizeof(remote_addr_sco);
break;
case L2CAP:
addr = (struct sockaddr *) &remote_addr_l2;
len = sizeof(remote_addr_l2);
break;
case TCP:
addr = (struct sockaddr *) &remote_addr_in;
len = sizeof(remote_addr_in);
break;
}
printf("%ld: accept(%d)\n", pthread_self(), fd);
ret = accept(fd, addr, &len);
printf("%ld: accept(%d) = %d\n", pthread_self(), fd, ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
else {
printf("\tlen = %d\n", len);
}
return ret;
}
int get_bdaddr(const char *str, bdaddr_t *ba) {
char *d = ((char *)ba) + 5, *endp;
int i;
for(i = 0; i < 6; i++) {
*d-- = strtol(str, &endp, 16);
if (*endp != ':' && i != 5) {
memset(ba, 0, sizeof(bdaddr_t));
return -1;
}
str = endp + 1;
}
return 0;
}
static int _connect(int fd, int type) {
int ret;
int len = 0;
struct sockaddr *addr = NULL;
switch (type) {
case UNIX:
addr = (struct sockaddr *) &local_addr_un;
len = sizeof(local_addr_un);
break;
case RFCOMM:
get_bdaddr("00:11:22:33:44:55", &local_addr_rc.rc_bdaddr);
addr = (struct sockaddr *) &local_addr_rc;
len = sizeof(local_addr_rc);
break;
case SCO:
addr = (struct sockaddr *) &local_addr_sco;
len = sizeof(local_addr_sco);
break;
case L2CAP:
addr = (struct sockaddr *) &local_addr_l2;
len = sizeof(local_addr_l2);
break;
case TCP:
addr = (struct sockaddr *) &local_addr_in;
len = sizeof(local_addr_in);
break;
}
printf("%ld: connect(%d)\n", pthread_self(), fd);
ret = connect(fd, addr, len);
printf("%ld: connect(%d) = %d\n", pthread_self(), fd, ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _write(int fd, int type) {
int ret;
char buf = 69;
printf("%ld: write(%d)\n", pthread_self(), fd);
ret = write(fd, &buf, 1);
printf("%ld: write(%d) = %d\n", pthread_self(), fd, ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _shutdown(int fd, int how) {
int ret;
printf("%ld: shutdown(%d)\n", pthread_self(), fd);
ret = shutdown(fd, how);
printf("%ld: shutdown(%d) = %d\n", pthread_self(), fd, ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
return ret;
}
static int _poll(struct pollfd *ufds, nfds_t nfds, int timeout) {
int ret;
unsigned int i;
printf("%ld: poll(", pthread_self());
print_fds(ufds, nfds);
printf(")\n");
ret = poll(ufds, nfds, timeout);
printf("%ld: poll() = %d\n", pthread_self(), ret);
if (ret < 0) printf("\terr %d (%s)\n", errno, strerror(errno));
if (ret > 0) {
for (i=0; i<nfds; i++) {
if (ufds[i].revents) {
printf("\tfd %d ", ufds[i].fd); print_events(ufds[i].revents);
}
}
}
return ret;
}
static void thread_delay_close(struct thread_args *args) {
printf("%ld: START\n", pthread_self());
sleep(args->delay);
_close(args->fd, args->type);
printf("%ld: END\n", pthread_self());
}
static void thread_poll(void *args) {
int fd = (int)args;
struct pollfd pfd;
printf("%ld: START\n", pthread_self());
pfd.fd = fd;
pfd.events = 0;
_poll(&pfd, 1, -1);
printf("%ld: END\n", pthread_self());
}
static void thread_read(void *args) {
int fd = (int)args;
printf("%ld: START\n", pthread_self());
_read(fd);
printf("%ld: END\n", pthread_self());
}
static void thread_pollin(void *args) {
int fd = (int)args;
struct pollfd pfd;
printf("%ld: START\n", pthread_self());
pfd.fd = fd;
pfd.events = POLLIN;
_poll(&pfd, 1, -1);
printf("%ld: END\n", pthread_self());
}
static void thread_shutdown(int fd) {
printf("%ld: START\n", pthread_self());
sleep(4);
_shutdown(fd, SHUT_RDWR);
printf("%ld: END\n", pthread_self());
}
static void thread_accept(struct thread_args *args) {
printf("%ld: START\n", pthread_self());
sleep(args->delay);
_accept(args->fd, args->type);
printf("%ld: END\n", pthread_self());
}
static void thread_connect(struct thread_args *args) {
printf("%ld: START\n", pthread_self());
sleep(args->delay);
_connect(args->fd, args->type);
printf("%ld: END\n", pthread_self());
}
static void thread_delay_close_write(struct thread_args *args) {
printf("%ld: START\n", pthread_self());
sleep(args->delay);
_close(args->fd, args->type);
sleep(args->delay);
_write(args->fd, args->type);
printf("%ld: END\n", pthread_self());
}
static void thread_accept_write(struct thread_args *args) {
printf("%ld: START\n", pthread_self());
sleep(args->delay);
_accept(args->fd, args->type);
sleep(args->delay);
_write(args->fd, args->type);
printf("%ld: END\n", pthread_self());
}
static void thread_delay_connect(struct thread_args *args) {
printf("%ld: START\n", pthread_self());
sleep(args->delay);
args->fd = _socket(args->type);
_connect(args->fd, args->type);
printf("%ld: END\n", pthread_self());
}
static int do_accept_accept_accept(int type) {
int fd;
fd = _socket(type);
if (fd < 0) goto error;
if (_bind(fd, type) < 0) goto error;
if (_listen(fd, type) < 0) goto error;
while (1) {
_accept(fd, type);
}
return 0;
error:
return -1;
}
static int do_accept_and_close(int type) {
int fd;
pthread_t thread;
struct thread_args args = {-1, type, 1};
fd = _socket(type);
if (fd < 0) goto error;
if (_bind(fd, type) < 0) goto error;
if (_listen(fd, type) < 0) goto error;
args.fd = fd;
pthread_create(&thread, NULL, (void *)thread_delay_close, (void *)&args);
_accept(fd, type);
pthread_join(thread, NULL);
return 0;
error:
return -1;
}
static int do_accept_shutdown(int type) {
int fd;
pthread_t thread;
struct thread_args args = {-1, type, 0};
fd = _socket(type);
if (fd < 0) goto error;
if (_bind(fd, type) < 0) goto error;
if (_listen(fd, type) < 0) goto error;
args.fd = fd;
pthread_create(&thread, NULL, (void *)thread_accept, (void *)&args);
sleep(4);
_shutdown(fd, SHUT_RDWR);
pthread_join(thread, NULL);
_close(fd, type);
return 0;
error:
return -1;
}
static int do_connect_shutdown(int type) {
int fd;
pthread_t thread;
struct thread_args args = {-1, type, 0};
fd = _socket(type);
if (fd < 0) goto error;
args.fd = fd;
pthread_create(&thread, NULL, (void *)thread_connect, (void *)&args);
sleep(4);
_shutdown(fd, SHUT_RDWR);
pthread_join(thread, NULL);
_close(fd, type);
return 0;
error:
return -1;
}
static int do_connectnb_shutdown(int type) {
int fd;
int flags;
pthread_t thread;
struct thread_args args = {-1, type, 0};
fd = _socket(type);
if (fd < 0) goto error;
flags = fcntl(fd, F_GETFL);
if (flags == -1)
return -1;
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK))
return -1;
_connect(fd, type);
sleep(1);
_shutdown(fd, SHUT_RDWR);
sleep(2);
_close(fd, type);
return 0;
error:
return -1;
}
static int do_connectnb_close(int type) {
int fd;
pthread_t thread;
struct thread_args args = {-1, type, 0};
int flags;
fd = _socket(type);
if (fd < 0) goto error;
flags = fcntl(fd, F_GETFL);
if (flags == -1)
return -1;
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK))
return -1;
_connect(fd, type);
sleep(2);
_close(fd, type);
return 0;
error:
return -1;
}
// accept in one thread. close then write in another
static int do_accept_close_write(int type) {
int fd;
pthread_t thread;
struct thread_args args = {-1, type, 1};
fd = _socket(type);
if (fd < 0) goto error;
if (_bind(fd, type) < 0) goto error;
if (_listen(fd, type) < 0) goto error;
args.fd = fd;
pthread_create(&thread, NULL, (void *)thread_delay_close_write, (void *)&args);
_accept(fd, type);
pthread_join(thread, NULL);
return 0;
error:
return -1;
}
static int do_poll_poll_poll_shutdown(int type) {
const int MAX_T = 32;
int fd;
pthread_t t[MAX_T];
int i;
fd = _socket(type);
for (i=0; i<MAX_T; i++)
pthread_create(&t[i], NULL, (void *)thread_poll, (void *)fd);
sleep(1);
_shutdown(fd, SHUT_RDWR);
for (i=0; i<MAX_T; i++)
pthread_join(t[i], NULL);
_close(fd, type);
return 0;
}
static int do_poll_poll_poll_close(int type) {
const int MAX_T = 32;
int fd;
pthread_t t[MAX_T];
int i;
fd = _socket(type);
for (i=0; i<MAX_T; i++)
pthread_create(&t[i], NULL, (void *)thread_poll, (void *)fd);
sleep(1);
_close(fd, type);
for (i=0; i<MAX_T; i++)
pthread_join(t[i], NULL);
return 0;
}
static int do_read_read_read_close(int type) {
const int MAX_T = 32;
int fd;
pthread_t t[MAX_T];
int i;
fd = _socket(type);
for (i=0; i<MAX_T; i++)
pthread_create(&t[i], NULL, (void *)thread_read, (void *)fd);
sleep(1);
_close(fd, type);
for (i=0; i<MAX_T; i++)
pthread_join(t[i], NULL);
return 0;
}
static int do_read_read_read_shutdown(int type) {
const int MAX_T = 32;
int fd;
pthread_t t[MAX_T];
int i;
fd = _socket(type);
for (i=0; i<MAX_T; i++)
pthread_create(&t[i], NULL, (void *)thread_read, (void *)fd);
sleep(1);
_shutdown(fd, SHUT_RDWR);
for (i=0; i<MAX_T; i++)
pthread_join(t[i], NULL);
_close(fd, type);
return 0;
}
static int do_connected_read1_shutdown1(int type) {
int fd1, fd2;
pthread_t t1;
pthread_t t2;
struct thread_args a1 = {-1, type, 0};
struct thread_args a2 = {-1, type, 2};
fd1 = _socket(type);
if (fd1 < 0) goto error;
if (_bind(fd1, type) < 0) goto error;
if (_listen(fd1, type) < 0) goto error;
a1.fd = fd1;
pthread_create(&t1, NULL, (void *)thread_accept_write, (void *)&a1);
fd2 = _socket(type);
if (_connect(fd2, type)) goto error;
pthread_create(&t2, NULL, (void *)thread_shutdown, (void *)&fd2);
while (1) if (_read(fd2)) break;
pthread_join(t1, NULL);
pthread_join(t2, NULL);
return 0;
error:
return -1;
}
// accept in one thread, connect from two different threads
static int do_accept_connect_connect(int type) {
int fd;
pthread_t t1;
pthread_t t2;
struct thread_args a1 = {-1, type, 1};
struct thread_args a2 = {-1, type, 2};
fd = _socket(type);
if (fd < 0) goto error;
if (_bind(fd, type) < 0) goto error;
if (_listen(fd, type) < 0) goto error;
pthread_create(&t1, NULL, (void *)thread_delay_connect, (void *)&a1);
pthread_create(&t2, NULL, (void *)thread_delay_connect, (void *)&a2);
_accept(fd, type);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
return 0;
error:
return -1;
}
struct {
char *name;
int (*ptr)(int);
} action_table[] = {
{"accept_accept_accept", do_accept_accept_accept},
{"accept_and_close", do_accept_and_close},
{"accept_shutdown", do_accept_shutdown},
{"connect_shutdown", do_connect_shutdown},
{"connectnb_shutdown", do_connectnb_shutdown},
{"connectnb_close", do_connectnb_close},
{"accept_close_write", do_accept_close_write},
{"accept_connect_connect", do_accept_connect_connect},
{"poll_poll_poll_shutdown", do_poll_poll_poll_shutdown},
{"poll_poll_poll_close", do_poll_poll_poll_close},
{"read_read_read_shutdown", do_read_read_read_shutdown},
{"read_read_read_close", do_read_read_read_close},
{"connected_read1_shutdown1", do_connected_read1_shutdown1},
{NULL, NULL},
};
struct {
char *name;
enum sock_type type;
} type_table[] = {
{"unix", UNIX},
{"rfcomm", RFCOMM},
{"sco", SCO},
{"l2cap", L2CAP},
{"tcp", TCP},
{NULL, -1},
};
static void usage() {
int i;
printf("socktest TYPE ACTION\n");
printf("\nTYPE:\n");
for (i = 0; type_table[i].name; i++) {
printf("\t%s\n", type_table[i].name);
}
printf("\nACTION:\n");
for (i = 0; action_table[i].name; i++) {
printf("\t%s\n", action_table[i].name);
}
}
int main(int argc, char **argv) {
int i;
int type = -1;
if (argc != 3) {
usage();
return -1;
}
for (i = 0; type_table[i].name; i++) {
if (!strcmp(argv[1], type_table[i].name)) {
type = type_table[i].type;
break;
}
}
if (type == -1) {
usage();
return -1;
}
for (i = 0; action_table[i].name; i++) {
if (!strcmp(argv[2], action_table[i].name)) {
printf("TYPE = %s ACTION = %s\n", type_table[type].name,
action_table[i].name);
return (*action_table[i].ptr)(type);
}
}
usage();
return -1;
}
Jump to Line
Something went wrong with that request. Please try again.