int communicate(const char *host, const char *service, const char *path,
const struct wslay_event_callbacks *callbacks)
{
struct wslay_event_callbacks cb = *callbacks;
cb.recv_callback = feed_body_callback;
int fd = connect_to(host, service);
if(fd == -1) {
std::cerr << "Could not connect to the host" << std::endl;
return -1;
}
std::string body;
if(http_handshake(fd, host, service, path, body) == -1) {
std::cerr << "Failed handshake" << std::endl;
close(fd);
return -1;
}
make_non_block(fd);
int val = 1;
if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val))
== -1) {
perror("setsockopt: TCP_NODELAY");
return -1;
}
WebSocketClient ws(fd, &cb, body);
if(ws.on_read_event() == -1) {
return -1;
}
cb.recv_callback = callbacks->recv_callback;
ws.set_callbacks(&cb);
int epollfd = epoll_create(1);
if(epollfd == -1) {
perror("epoll_create");
return -1;
}
ctl_epollev(epollfd, EPOLL_CTL_ADD, ws);
static const size_t MAX_EVENTS = 1;
epoll_event events[MAX_EVENTS];
bool ok = true;
while(ws.want_read() || ws.want_write()) {
int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
if(nfds == -1) {
perror("epoll_wait");
return -1;
}
for(int n = 0; n < nfds; ++n) {
if(((events[n].events & EPOLLIN) && ws.on_read_event() != 0) ||
((events[n].events & EPOLLOUT) && ws.on_write_event() != 0)) {
ok = false;
break;
}
}
if(!ok) {
break;
}
ctl_epollev(epollfd, EPOLL_CTL_MOD, ws);
}
return ok ? 0 : -1;
}
int main()
{
int status;
pstr_t body;
uint64_t nbytes = 0;
char buf[4096];
int s = connect_to(HOST, 80);
body.data = buf; body.len = sizeof(buf);
status = http_handshake(s, rqh, sizeof(rqh), &body);
printf("GOT %d + %u\n", status, body.len);
for (;;) {
int bytes = read_ms(s, buf, sizeof(buf), 5000);
if (bytes <= 0)
break;
nbytes += bytes;
}
printf("%" PRIu64 " bytes transferred\n", nbytes);
return 0;
}
/*
* Communicate with the client. This function performs HTTP handshake
* and WebSocket data transfer until close handshake is done or an
* error occurs. *fd* is the file descriptor of the connection to the
* client. This function returns 0 if it succeeds, or returns 0.
*/
int communicate(int fd)
{
wslay_event_context_ptr ctx;
struct wslay_event_callbacks callbacks = {
recv_callback,
send_callback,
NULL,
NULL,
NULL,
NULL,
on_msg_recv_callback
};
struct Session session = { fd };
int val = 1;
struct pollfd event;
int res = 0;
if(http_handshake(fd) == -1) {
return -1;
}
if(make_non_block(fd) == -1) {
return -1;
}
if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val))
== -1) {
perror("setsockopt: TCP_NODELAY");
return -1;
}
memset(&event, 0, sizeof(struct pollfd));
event.fd = fd;
event.events = POLLIN;
wslay_event_context_server_init(&ctx, &callbacks, &session);
/*
* Event loop: basically loop until both wslay_event_want_read(ctx)
* and wslay_event_want_write(ctx) return 0.
*/
while(wslay_event_want_read(ctx) || wslay_event_want_write(ctx)) {
int r;
while((r = poll(&event, 1, -1)) == -1 && errno == EINTR);
if(r == -1) {
perror("poll");
res = -1;
break;
}
if(((event.revents & POLLIN) && wslay_event_recv(ctx) != 0) ||
((event.revents & POLLOUT) && wslay_event_send(ctx) != 0) ||
(event.revents & (POLLERR | POLLHUP | POLLNVAL))) {
/*
* If either wslay_event_recv() or wslay_event_send() return
* non-zero value, it means serious error which prevents wslay
* library from processing further data, so WebSocket connection
* must be closed.
*/
res = -1;
break;
}
event.events = 0;
if(wslay_event_want_read(ctx)) {
event.events |= POLLIN;
}
if(wslay_event_want_write(ctx)) {
event.events |= POLLOUT;
}
}
return res;
}
/**
* \brief The function with websocket infinite loop
*/
void *vs_websocket_loop(void *arg)
{
/* The vContext is passed as *user_data* in callback functions. */
struct vContext *C = (struct vContext*)arg;
struct VS_CTX *vs_ctx = CTX_server_ctx(C);
struct IO_CTX *io_ctx = CTX_io_ctx(C);
struct VStreamConn *stream_conn = CTX_current_stream_conn(C);
struct VSession *vsession = CTX_current_session(C);
struct VMessage *r_message=NULL, *s_message=NULL;
wslay_event_context_ptr wslay_ctx;
fd_set read_set, write_set;
struct timeval tv;
int ret, flags;
unsigned int int_size;
struct wslay_event_callbacks callbacks = {
vs_recv_ws_callback_data,
vs_send_ws_callback_data,
NULL,
NULL,
NULL,
NULL,
vs_ws_recv_msg_callback
};
/* Set socket blocking */
flags = fcntl(io_ctx->sockfd, F_GETFL, 0);
fcntl(io_ctx->sockfd, F_SETFL, flags & ~O_NONBLOCK);
http_handshake(io_ctx->sockfd);
/* Try to get size of TCP buffer */
int_size = sizeof(int_size);
getsockopt(io_ctx->sockfd, SOL_SOCKET, SO_RCVBUF,
(void *)&stream_conn->socket_buffer_size, &int_size);
r_message = (struct VMessage*)calloc(1, sizeof(struct VMessage));
s_message = (struct VMessage*)calloc(1, sizeof(struct VMessage));
CTX_r_message_set(C, r_message);
CTX_s_message_set(C, s_message);
stream_conn->host_state = TCP_SERVER_STATE_RESPOND_METHODS;
if(is_log_level(VRS_PRINT_DEBUG_MSG)) {
printf("%c[%d;%dm", 27, 1, 31);
v_print_log(VRS_PRINT_DEBUG_MSG, "Server TCP state: RESPOND_methods\n");
printf("%c[%dm", 27, 0);
}
/* Set non-blocking */
flags = fcntl(io_ctx->sockfd, F_GETFL, 0);
fcntl(io_ctx->sockfd, F_SETFL, flags | O_NONBLOCK);
wslay_event_context_server_init(&wslay_ctx, &callbacks, C);
/* "Never ending" loop */
while(vsession->stream_conn->host_state != TCP_SERVER_STATE_CLOSED)
{
if(vs_ctx->state != SERVER_STATE_READY) {
vsession->stream_conn->host_state = TCP_SERVER_STATE_CLOSING;
/* Try to close connection with websocket client */
wslay_event_queue_close(wslay_ctx,
WSLAY_CODE_GOING_AWAY,
(uint8_t*)"Server shutdown", /* Close message */
15); /* The length of close message s*/
}
/* Initialize read set */
FD_ZERO(&read_set);
FD_SET(io_ctx->sockfd, &read_set);
/* Initialize write set */
FD_ZERO(&write_set);
FD_SET(io_ctx->sockfd, &write_set);
/* Set timeout for select() */
if(stream_conn->host_state == TCP_SERVER_STATE_STREAM_OPEN) {
/* Use negotiated FPS */
tv.tv_sec = 0;
tv.tv_usec = 1000000/vsession->fps_host;
} else {
/* User have to send something in 30 seconds */
tv.tv_sec = VRS_TIMEOUT;
tv.tv_usec = 0;
}
if( (ret = select(io_ctx->sockfd+1,
&read_set,
&write_set,
NULL, /* Exception*/
&tv)) == -1) {
if(is_log_level(VRS_PRINT_ERROR)) v_print_log(VRS_PRINT_ERROR, "%s:%s():%d select(): %s\n",
__FILE__, __FUNCTION__, __LINE__, strerror(errno));
goto end;
/* Was event on the listen socket */
} else if(ret>0){
if(FD_ISSET(io_ctx->sockfd, &read_set)) {
if( wslay_event_recv(wslay_ctx) != 0 ) {
goto end;
}
} else if (FD_ISSET(io_ctx->sockfd, &write_set)) {
if( wslay_event_send(wslay_ctx) != 0 ) {
goto end;
}
}
}
if(stream_conn->host_state == TCP_SERVER_STATE_STREAM_OPEN) {
/* Check if there is any command in outgouing queue
* and eventually pack these commands to buffer */
if((ret = v_STREAM_pack_message(C)) == 0 ) {
goto end;
}
/* When at least one command was packed to buffer, then
* queue this buffer to WebSocket layer */
if(ret == 1) {
struct wslay_event_msg msgarg;
msgarg.opcode = WSLAY_BINARY_FRAME;
msgarg.msg = (uint8_t*)io_ctx->buf;
msgarg.msg_length = io_ctx->buf_size;
wslay_event_queue_msg(wslay_ctx, &msgarg);
}
}
}
end:
if(is_log_level(VRS_PRINT_DEBUG_MSG)) {
printf("%c[%d;%dm", 27, 1, 31);
v_print_log(VRS_PRINT_DEBUG_MSG, "Server TCP state: CLOSING\n");
printf("%c[%dm", 27, 0);
}
/* Set up TCP CLOSING state (non-blocking) */
vs_CLOSING(C);
/* Receive and Send messages are not neccessary any more */
if(r_message!=NULL) {
free(r_message);
r_message = NULL;
CTX_r_message_set(C, NULL);
}
if(s_message!=NULL) {
free(s_message);
s_message = NULL;
CTX_s_message_set(C, NULL);
}
/* TCP connection is considered as CLOSED, but it is not possible to use
* this connection for other client */
stream_conn->host_state = TCP_SERVER_STATE_CLOSED;
/* NULL pointer at stream connection */
CTX_current_stream_conn_set(C, NULL);
/* Set TCP connection to CLOSED */
if(is_log_level(VRS_PRINT_DEBUG_MSG)) {
printf("%c[%d;%dm", 27, 1, 31);
v_print_log(VRS_PRINT_DEBUG_MSG, "Server TCP state: CLOSED\n");
printf("%c[%dm", 27, 0);
}
pthread_mutex_lock(&vs_ctx->data.mutex);
/* Unsubscribe this session (this avatar) from all nodes */
vs_node_free_avatar_reference(vs_ctx, vsession);
/* Try to destroy avatar node */
vs_node_destroy_avatar_node(vs_ctx, vsession);
pthread_mutex_unlock(&vs_ctx->data.mutex);
/* This session could be used again for authentication */
stream_conn->host_state=TCP_SERVER_STATE_LISTEN;
/* Clear session flags */
vsession->flags = 0;
if(is_log_level(VRS_PRINT_DEBUG_MSG)) {
printf("%c[%d;%dm", 27, 1, 31);
v_print_log(VRS_PRINT_DEBUG_MSG, "Server TCP state: LISTEN\n");
printf("%c[%dm", 27, 0);
}
free(C);
C = NULL;
pthread_exit(NULL);
return NULL;
}
