Variant f_socket_server(CStrRef hostname, int port /* = -1 */,
VRefParam errnum /* = null */,
VRefParam errstr /* = null */) {
Object ret;
Socket *sock = NULL;
const char *name = hostname.data();
if (!create_new_socket(name, port, errnum, errstr, ret, sock, 0.0)) {
return false;
}
assert(ret.get() && sock);
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, name, port, sa_ptr, sa_size)) {
return false;
}
if (::bind(sock->fd(), sa_ptr, sa_size) < 0) {
SOCKET_ERROR(sock, "unable to bind to given adress", errno);
return false;
}
if (listen(sock->fd(), 128) < 0) {
SOCKET_ERROR(sock, "unable to listen on socket", errno);
return false;
}
return ret;
}
Variant socket_server_impl(
const HostURL &hosturl,
int flags, /* = STREAM_SERVER_BIND|STREAM_SERVER_LISTEN */
VRefParam errnum /* = null */,
VRefParam errstr /* = null */
) {
errnum = 0;
errstr = empty_string();
auto sock = create_new_socket(hosturl, errnum, errstr);
if (!sock) {
return false;
}
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, hosturl.getHost().c_str(),
hosturl.getPort(), sa_ptr, sa_size)) {
return false;
}
int yes = 1;
setsockopt(sock->fd(), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
if ((flags & k_STREAM_SERVER_BIND) != 0 &&
::bind(sock->fd(), sa_ptr, sa_size) < 0) {
SOCKET_ERROR(sock, "unable to bind to given address", errno);
return false;
}
if ((flags & k_STREAM_SERVER_LISTEN) != 0 && listen(sock->fd(), 128) < 0) {
SOCKET_ERROR(sock, "unable to listen on socket", errno);
return false;
}
return Variant(std::move(sock));
}
int game_add_connect_event(struct sockaddr *sa, int socklen, CLIENT_MAP *client_map)
{
int ret;
struct event *event_conn = &client_map->event_recv;
int fd = 0;
fd = create_new_socket(0);
if (0 != event_assign(event_conn, base, fd, EV_READ|EV_PERSIST, cb_recv, client_map)) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: event_new failed[%d]", __FUNCTION__, __LINE__, errno);
goto fail;
}
event_add(event_conn, NULL);
ret = evutil_socket_connect(&fd, sa, socklen);
if (ret < 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: evutil_socket_connect failed[%d]", __FUNCTION__, __LINE__, errno);
goto fail;
}
game_set_socket_opt(fd);
return (fd);
fail:
if (fd > 0) {
evutil_closesocket(fd);
}
if (event_conn) {
event_del(event_conn);
}
return (-1);
}
int main(int argc, char *argv[]) {
if (argc < 3) {
fprintf(stderr,"usage %s hostname port\n", argv[0]);
exit(0);
}
int portno;
portno = atoi(argv[2]);
int my_socket;
my_socket = create_new_socket();
if (my_socket < 0) error("ERROR opening socket");
struct sockaddr_in serv_addr;
sockaddr_generator(&serv_addr, argv[1], portno);
struct sockaddr* serv_sockaddr = (struct sockaddr *) &serv_addr;
if (connect(my_socket, serv_sockaddr, sizeof(serv_addr)) < 0)
error("ERROR connecting");
char* buffer = "a";
char read_buffer[256];
bzero(read_buffer,256);
int kk = 0;
int write_n, read_n;
ticks t1, t2;
double sum = 0.0;
int loop_times = 1000;
/*printf("before testing!\n");*/
for(kk = 0 ; kk < loop_times; kk ++){
bzero(read_buffer,256);
/*printf("I write:%s\n", buffer);*/
read_n = read(my_socket,read_buffer,255);
t1 = getticks();
write_n = write(my_socket,buffer,strlen(buffer));
read_n = read(my_socket,read_buffer,255);
t2 = getticks();
double etime = elapsed(t2,t1);
sum += etime;
/*printf("elapsed time: %f milliseconds\n", etime * 0.417 / 1e6);*/
if (write_n < 0)
error("ERROR writing to socket");
if (read_n < 0)
error("ERROR reading from socket");
write_n = write(my_socket,buffer,strlen(buffer));
/*printf("I read: %s\n", read_buffer);*/
}
printf("%f\n", (sum / loop_times) * 0.417 / 1e6);
close(my_socket);
return 0;
}
int game_add_listen_event(uint16_t port, LISTEN_CALLBACKS *callback)
{
struct event *event_accept = &callback->event_accept;
int fd = 0;
struct sockaddr_in addr;
if (!callback || !callback->cb_get_client_map)
return (-1);
fd = create_new_socket(1);
if (fd < 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: create new socket failed[%d]", __FUNCTION__, errno);
return (-2);
}
evutil_make_listen_socket_reuseable(fd);
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(0);
addr.sin_port = htons(port);
if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: bind failed[%d]", __FUNCTION__, errno);
return (-10);
}
if (listen(fd, 128) != 0) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: listen failed[%d]", __FUNCTION__, errno);
return (-20);
}
if (0 != event_assign(event_accept, base, fd, EV_READ|EV_PERSIST, cb_listen, (void *)callback)) {
log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s: event_new failed[%d]", __FUNCTION__, errno);
goto fail;
}
event_add(event_accept, NULL);
return (0);
fail:
if (fd > 0) {
evutil_closesocket(fd);
}
if (event_accept) {
event_del(event_accept);
}
return (-1);
}
int main(int argc, char *argv[]) {
if (argc < 2) {
fprintf(stderr,"ERROR: no port provided\n");
exit(1);
}
// create a new socket
int my_socket;
my_socket = create_new_socket();
if (my_socket < 0)
error("ERROR: failed to create new socket");
int portno;
portno = atoi(argv[1]);
struct sockaddr_in serv_addr;
sockaddr_generator(&serv_addr, NULL, portno);
//bind
if (bind(my_socket, (struct sockaddr *) &serv_addr,
sizeof(serv_addr)) < 0)
error("ERROR: binding to socket failed");
// listen: on my_socket with queue size 5
listen(my_socket,100);
printf("===tcp rount trip time experiment===\n");
while(1){
printf("Log: waiting for client to connect!\n");
int newsockfd;
// accept will block until some client connect to the port
newsockfd = accept_incoming_connection(my_socket);
printf("Log: client accepted!\n");
if (newsockfd < 0)
error("ERROR: error when accepting connection");
int read_n, write_n, kk;
char buffer[256];
char* ack = "a";
int loop_times = 1000;
printf("Log: testing round trip 1000 times!\n");
for( kk = 0 ; kk < loop_times ; kk ++ ){
// read and print the message sent from client
bzero(buffer,256);
/*printf("\n++debug++ before read\n");*/
// read should block too, not sure ??
write_n = write(newsockfd, ack, strlen(ack));
read_n = read(newsockfd, buffer, 255);
/*printf("Here is the message: %s\r",buffer);*/
// write ack back to client
/*printf("\n++debug++ before write\n");*/
write_n = write(newsockfd, ack, strlen(ack));
read_n = read(newsockfd, buffer, 255);
if (read_n < 0){
printf("reading fault\n");
error("ERROR: reading from socket failed");
}
if (write_n <= 0){
printf("writing fault\n");
error("ERROR: writing to socket failed");
}
/*printf("\n++debug++ end of while\n");*/
}
// close connection
close(newsockfd);
printf("Log: client left!\n\n");
}
close(my_socket);
return 0;
}
static Variant sockopen_impl(CStrRef hostname, int port, Variant &errnum,
Variant &errstr, double timeout,
bool persistent) {
string key;
if (persistent) {
key = hostname.data();
key += ":";
key += boost::lexical_cast<string>(port);
Socket *sock =
dynamic_cast<Socket*>(g_persistentObjects->get("socket", key.c_str()));
if (sock) {
if (sock->getError() == 0 && sock->checkLiveness()) {
return Object(sock);
}
// socket had an error earlier, we need to remove it from persistent
// storage, and create a new one
g_persistentObjects->remove("socket", key.c_str());
}
}
Object ret;
const char *name = hostname.data();
Socket *sock = NULL;
if (timeout <= 0) timeout = RuntimeOption::SocketDefaultTimeout;
// test if protocol is SSL
SSLSocket *sslsock = SSLSocket::Create(name, port, timeout);
if (sslsock) {
sock = sslsock;
ret = sock;
} else if (!create_new_socket(name, port, errnum, errstr,
ret, sock, timeout)) {
return false;
}
assert(ret.get() && sock);
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, name, port, sa_ptr, sa_size)) {
return false;
}
int retval;
int fd = sock->fd();
IOStatusHelper io("socket::connect", name, port);
if (timeout <= 0) {
retval = connect(fd, sa_ptr, sa_size);
} else {
// set non-blocking so we can do timeouts
long arg = fcntl(fd, F_GETFL, NULL);
fcntl(fd, F_SETFL, arg | O_NONBLOCK);
retval = connect(fd, sa_ptr, sa_size);
if (retval < 0) {
if (errno == EINPROGRESS) {
struct pollfd fds[1];
fds[0].fd = fd;
fds[0].events = POLLOUT;
if (poll(fds, 1, (int)(timeout * 1000))) {
socklen_t lon = sizeof(int);
int valopt;
getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
if (valopt) {
std::string msg = "failed to connect to ";
msg += name;
msg += ":";
msg += boost::lexical_cast<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), valopt);
errnum = sock->getError();
errstr = String(Util::safe_strerror(sock->getError()));
return false;
} else {
retval = 0; // success
}
} else {
std::string msg = "timed out after ";
msg += boost::lexical_cast<std::string>(timeout);
msg += " seconds when connecting to ";
msg += name;
msg += ":";
msg += boost::lexical_cast<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), ETIMEDOUT);
errnum = sock->getError();
errstr = String(Util::safe_strerror(sock->getError()));
return false;
}
}
}
// set to blocking mode
arg = fcntl(fd, F_GETFL, NULL);
fcntl(fd, F_SETFL, arg & ~O_NONBLOCK);
}
if (retval != 0) {
errnum = sock->getError();
errstr = String(Util::safe_strerror(sock->getError()));
return false;
}
if (sslsock && !sslsock->onConnect()) {
raise_warning("Failed to enable crypto");
return false;
}
if (persistent) {
assert(!key.empty());
g_persistentObjects->set("socket", key.c_str(), sock);
}
return ret;
}
int main(int argc, char *argv[]) {
if (argc < 2) {
fprintf(stderr,"ERROR: no port provided\n");
exit(1);
}
// create a new socket
int my_socket;
my_socket = create_new_socket();
if (my_socket < 0)
error("ERROR: failed to create new socket");
int portno;
portno = atoi(argv[1]);
struct sockaddr_in serv_addr;
sockaddr_generator(&serv_addr, NULL, portno);
//bind
if (bind(my_socket, (struct sockaddr *) &serv_addr,
sizeof(serv_addr)) < 0)
error("ERROR: binding to socket failed");
// listen: on my_socket with queue size 5
listen(my_socket,100);
printf("===tcp setup time experiment===\n");
while(1) {
int kk;
int loop_times = 100;
int newsockfd;
char* ack = "a";
char buffer[256];
int read_n, write_n;
printf("ready and wait to run tcp setup and tear down for %d times.\n", loop_times);
double sum = 0.0;
double sum2 = 0.0;
double sum3 = 0.0;
for( kk = 0 ; kk < loop_times; kk ++ ) {
bzero(buffer,256);
// accept will block until some client connect to the port
newsockfd = accept_incoming_connection(my_socket);
/*if (newsockfd < 0) */
/*error("ERROR: error when accepting connection");*/
// read and print the message sent from client
// read should block too, not sure ??
/*read_n = read(newsockfd, buffer, 255);*/
// write ack back to client
/*write_n = write(newsockfd, ack, strlen(ack));*/
/*ticks t0 = getticks();*/
read_n = read(newsockfd, buffer, 255);
ticks t1 = getticks();
/*if (read_n < 0) error("ERROR: reading from socket failed");*/
/*if (write_n <= 0) error("ERROR: writing to socket failed");*/
close(newsockfd);
ticks t2 = getticks();
double etime = elapsed(t2, t1);
/*double etime2 = elapsed(t1, t0);*/
/*double etime3 = elapsed(t2, t0);*/
sum += etime;
/*sum2 += etime2;*/
/*sum3 += etime3;*/
}
printf("%f\n", (sum / loop_times) * 0.417 / 1e6);
/*printf("%f\n", (sum2 / loop_times) * 0.417 / 1e6);*/
/*printf("%f\n", (sum3 / loop_times) * 0.417 / 1e6);*/
// close connection
printf("Log: client left!\n\n");
}
close(my_socket);
return 0;
}
