void* vc_main_dgram_loop(void *arg)
{
struct vContext *C = (struct vContext*)arg;
struct VSession *vsession = CTX_current_session(C);
struct VDgramConn *dgram_conn = vsession->dgram_conn;
struct VStreamConn *stream_conn = CTX_current_stream_conn(C);
struct VPacket *r_packet, *s_packet;
char error = 0;
const uint8 *ret_val = 0;
if(dgram_conn==NULL) {
/* Create new datagrame connection */
if((dgram_conn = vc_create_client_dgram_conn(C))==NULL) {
goto finish;
}
vsession->dgram_conn = dgram_conn;
}
CTX_current_dgram_conn_set(C, dgram_conn);
CTX_io_ctx_set(C, &dgram_conn->io_ctx);
#if (defined WITH_OPENSSL) && OPENSSL_VERSION_NUMBER>=0x10000000
/* If negotiated security is DTLS, then try to do DTLS handshake */
if(dgram_conn->io_ctx.flags & SOCKET_SECURED) {
if(vc_create_dtls_connection(C) == 0) {
CTX_current_dgram_conn_set(C, NULL);
CTX_io_ctx_set(C, NULL);
free(dgram_conn);
ret_val = &vrs_conn_term_error;
goto finish;
}
}
#endif
/* Packet structure for receiving */
r_packet = (struct VPacket*)malloc(sizeof(struct VPacket));
CTX_r_packet_set(C, r_packet);
/* Packet structure for sending */
s_packet = (struct VPacket*)malloc(sizeof(struct VPacket));
CTX_s_packet_set(C, s_packet);
/* Run loop of the first phase of the handshake */
if((error = vc_REQUEST_loop(C)) == STATE_EXIT_ERROR) {
/* Do not confirm proposed URL, when client was not able to connect
* to the server */
CTX_io_ctx_set(C, &stream_conn->io_ctx);
vc_NEGOTIATE_newhost(C, NULL);
CTX_io_ctx_set(C, &dgram_conn->io_ctx);
ret_val = &vrs_conn_term_error;
goto end;
}
/* When server responded in the first phase of the handshake, then run loop of the second
* phase of the handshake */
if((error = vc_PARTOPEN_loop(C)) == STATE_EXIT_ERROR) {
/* Do not confirm proposed URL, when client was not able to connect
* to the server */
CTX_io_ctx_set(C, &stream_conn->io_ctx);
vc_NEGOTIATE_newhost(C, NULL);
CTX_io_ctx_set(C, &dgram_conn->io_ctx);
ret_val = &vrs_conn_term_error;
goto end;
} else {
struct Connect_Accept_Cmd *conn_accept;
/* Put connect accept command to queue -> call callback function */
conn_accept = v_Connect_Accept_create(vsession->avatar_id, vsession->user_id);
v_in_queue_push(vsession->in_queue, (struct Generic_Cmd*)conn_accept);
/* Send confirmation of the URL to the server */
CTX_io_ctx_set(C, &stream_conn->io_ctx);
vc_NEGOTIATE_newhost(C, vsession->host_url);
CTX_io_ctx_set(C, &dgram_conn->io_ctx);
/* TCP connection could be closed now */
vsession->stream_conn->host_state = TCP_CLIENT_STATE_CLOSING;
}
/* Main loop for data exchange */
if((error = vc_OPEN_loop(C)) == STATE_EXIT_ERROR) {
ret_val = &vrs_conn_term_error;
goto end;
}
/* Closing loop */
if((error = vc_CLOSING_loop(C)) == STATE_EXIT_ERROR) {
ret_val = &vrs_conn_term_error;
goto end;
}
/* TODO: distinguish between terminating connection by server and client */
ret_val = &vrs_conn_term_server;
end:
/* CLOSED state */
if(is_log_level(VRS_PRINT_DEBUG_MSG)) {
printf("%c[%d;%dm", 27, 1, 31);
v_print_log(VRS_PRINT_DEBUG_MSG, "Client state: CLOSED\n");
printf("%c[%dm", 27, 0);
}
free(r_packet);
free(s_packet);
#if (defined WITH_OPENSSL) && OPENSSL_VERSION_NUMBER>=0x10000000
if(dgram_conn->io_ctx.flags & SOCKET_SECURED) {
vc_destroy_dtls_connection(C);
}
#endif
v_conn_dgram_destroy(dgram_conn);
CTX_current_dgram_conn_set(C, NULL);
finish:
pthread_exit((void*)ret_val);
return NULL;
}
/**
* \brief This function try to pack message that is going to be
* sent in STREAM OPEN state
*
* \param[in] *C The pointer at context
*
* \return This function return 1, when there is something to send,
* it returns -1, when there is nothing to send and it returns 0, when
* there is some error
*/
int v_STREAM_pack_message(struct vContext *C)
{
struct VS_CTX *vs_ctx = CTX_server_ctx(C);
struct VSession *vsession = CTX_current_session(C);
struct VStreamConn *conn = CTX_current_stream_conn(C);
struct IO_CTX *io_ctx = CTX_io_ctx(C);
struct VMessage *s_message = CTX_s_message(C);
struct Generic_Cmd *cmd, *fake_cmd;
int ret = -1, queue_size = 0, buffer_pos = 0, prio_cmd_count, cmd_rank=0;
int8 cmd_share;
int16 prio, max_prio, min_prio;
uint16 cmd_count, cmd_len, prio_win, swin, sent_size, tot_cmd_size;
real32 prio_sum_high, prio_sum_low, r_prio;
int is_fake_cmd_received = 0;
/* Is here something to send? */
if((v_out_queue_get_count(vsession->out_queue) > 0) ||
(vsession->tmp_flags & SYS_CMD_NEGOTIATE_FPS))
{
/* Get current size of data in TCP outgoing buffer */
#ifdef __linux__
if( ioctl(io_ctx->sockfd, SIOCOUTQ, &queue_size) == -1 ) {
v_print_log(VRS_PRINT_ERROR,
"ioctl(%d, SIOCOUTQ, ...): %s\n",
io_ctx->sockfd,
strerror(errno));
return 0;
}
#endif
/* Compute, how many data could be added to the TCP stack? */
swin = conn->socket_buffer_size - queue_size;
buffer_pos = VERSE_MESSAGE_HEADER_SIZE;
s_message->sys_cmd[0].cmd.id = CMD_RESERVED_ID;
/* When negotiated and used FPS is different, then pack negotiate command
* for FPS */
if(vsession->fps_host != vsession->fps_peer) {
cmd_rank += v_add_negotiate_cmd(s_message->sys_cmd, cmd_rank,
CMD_CHANGE_L_ID, FTR_FPS, &vsession->fps_host, NULL);
} else {
if(vsession->tmp_flags & SYS_CMD_NEGOTIATE_FPS) {
cmd_rank += v_add_negotiate_cmd(s_message->sys_cmd, cmd_rank,
CMD_CONFIRM_L_ID, FTR_FPS, &vsession->fps_peer, NULL);
/* Send confirmation only once for received system command */
vsession->tmp_flags &= ~SYS_CMD_NEGOTIATE_FPS;
}
}
buffer_pos += v_pack_stream_system_commands(s_message, &io_ctx->buf[buffer_pos]);
max_prio = v_out_queue_get_max_prio(vsession->out_queue);
min_prio = v_out_queue_get_min_prio(vsession->out_queue);
prio_sum_high = v_out_queue_get_prio_sum_high(vsession->out_queue);
prio_sum_low = v_out_queue_get_prio_sum_low(vsession->out_queue);
v_print_log(VRS_PRINT_DEBUG_MSG, "Packing prio queues, cmd count: %d\n",
v_out_queue_get_count(vsession->out_queue));
/* Go through all priorities and pick commands from priority queues */
for(prio = max_prio; prio >= min_prio; prio--)
{
prio_cmd_count = v_out_queue_get_count_prio(vsession->out_queue, prio);
if(prio_cmd_count > 0) {
r_prio = v_out_queue_get_prio(vsession->out_queue, prio);
/* Compute size of buffer that could be occupied by
* commands from this queue */
if(prio >= VRS_DEFAULT_PRIORITY) {
prio_win = ((swin - buffer_pos)*r_prio)/prio_sum_high;
} else {
prio_win = ((swin - buffer_pos)*r_prio)/prio_sum_low;
}
/* Debug print */
v_print_log(VRS_PRINT_DEBUG_MSG, "Queue: %d, count: %d, r_prio: %6.3f, prio_win: %d\n",
prio, prio_cmd_count, r_prio, prio_win);
/* Get total size of commands that were stored in queue (sent_size) */
sent_size = 0;
tot_cmd_size = 0;
while(prio_cmd_count > 0) {
cmd_share = 0;
cmd_count = 0;
cmd_len = prio_win - sent_size;
/* Pack commands from queues with high priority to the buffer */
cmd = v_out_queue_pop(vsession->out_queue, prio, &cmd_count, &cmd_share, &cmd_len);
if(cmd != NULL) {
/* Is this command fake command? */
if(cmd->id < MIN_CMD_ID) {
if(cmd->id == FAKE_CMD_CONNECT_TERMINATE) {
/* Close connection */
struct VS_CTX *vs_ctx = CTX_server_ctx(C);
if(vs_ctx != NULL) {
vsession->stream_conn->host_state = TCP_SERVER_STATE_CLOSING;
} else {
vsession->stream_conn->host_state = TCP_CLIENT_STATE_CLOSING;
}
} else if(cmd->id == FAKE_CMD_FPS) {
struct Fps_Cmd *fps_cmd = (struct Fps_Cmd*)cmd;
/* Change value of FPS. It will be sent in negotiate command
* until it is confirmed be the peer (server) */
vsession->fps_host = fps_cmd->fps;
}
} else {
buffer_pos += tot_cmd_size = v_cmd_pack(&io_ctx->buf[buffer_pos], cmd, v_cmd_size(cmd), 0);
if(is_log_level(VRS_PRINT_DEBUG_MSG)) {
printf("%c[%d;%dm", 27, 1, 32);
v_cmd_print(VRS_PRINT_DEBUG_MSG, cmd);
printf("%c[%dm", 27, 0);
}
sent_size += tot_cmd_size;
}
fake_cmd = v_cmd_fake_ack(cmd);
if(fake_cmd != NULL) {
is_fake_cmd_received = 1;
/* Push command to the queue of incoming commands */
v_in_queue_push(vsession->in_queue, fake_cmd);
/* Print content of fake command */
v_fake_cmd_print(VRS_PRINT_DEBUG_MSG, fake_cmd);
}
/* It is not necessary to put cmd to history of sent commands,
* when TCP is used. */
v_cmd_destroy(&cmd);
prio_cmd_count--;
} else {
break;
}
}
}
}
s_message->header.len = io_ctx->buf_size = buffer_pos;
s_message->header.version = VRS_VERSION;
/* Pack header to the beginning of the buffer */
v_pack_message_header(s_message, io_ctx->buf);
/* Debug print of command to be send */
if(is_log_level(VRS_PRINT_DEBUG_MSG)) {
v_print_send_message(C);
}
/* When pure ack packet caused adding some fake commands to the queue, then
* poke server data thread */
if( (vs_ctx != NULL) && (is_fake_cmd_received == 1)) {
sem_post(vs_ctx->data.sem);
}
ret = 1;
}
return ret;
}
/**
* \brief This function removes packet with id from history of sent packets.
* It removes all its commands from the command history too.
*
* \param[in] *C The verse context.
* \param[in] id The ID of packet, the will be removed from the history.
*
* \return This function returns 1, then packet with id was found in the history
* and it returns 0 otherwise.
*/
int v_packet_history_rem_packet(struct vContext *C, uint32 id)
{
struct VS_CTX *vs_ctx = CTX_server_ctx(C);
struct VDgramConn *dgram_conn = CTX_current_dgram_conn(C);
struct VPacket_History *history = &dgram_conn->packet_history;
struct VPacket *r_packet = CTX_r_packet(C);
struct VSent_Packet *sent_packet;
int ret = 0, is_fake_cmd_received = 0;
sent_packet = v_packet_history_find_packet(history, id);
if(sent_packet != NULL) {
struct VSent_Command *sent_cmd;
v_print_log(VRS_PRINT_DEBUG_MSG, "Removing packet: %d from history\n", sent_packet->id);
/* Go through the whole list of sent commands and free them from the
* hashed linked list */
sent_cmd = sent_packet->cmds.first;
while(sent_cmd != NULL) {
/* Remove own command from hashed linked list if it wasn't already
* removed, when command was obsoleted by some newer packet */
if(sent_cmd->vbucket!=NULL) {
struct Generic_Cmd *cmd = (struct Generic_Cmd*)sent_cmd->vbucket->data;
/* Bucket has to include some data */
assert(sent_cmd->vbucket->data!=NULL);
/* Decrease total size of commands that were sent and wasn't acknowladged yet*/
dgram_conn->sent_size -= v_cmd_size(cmd);
/* Put fake command for create/destroy commands at verse server */
if(vs_ctx != NULL) {
struct VSession *vsession = CTX_current_session(C);
struct Generic_Cmd *fake_cmd = NULL;
switch(cmd->id) {
case CMD_NODE_CREATE:
fake_cmd = v_fake_node_create_ack_create(UINT32(cmd->data[UINT16_SIZE + UINT32_SIZE]));
break;
case CMD_NODE_DESTROY:
fake_cmd = v_fake_node_destroy_ack_create(UINT32(cmd->data[0]));
break;
case CMD_TAGGROUP_CREATE:
fake_cmd = v_fake_taggroup_create_ack_create(UINT32(cmd->data[0]),
UINT16(cmd->data[UINT32_SIZE]));
break;
case CMD_TAGGROUP_DESTROY:
fake_cmd = v_fake_taggroup_destroy_ack_create(UINT32(cmd->data[0]),
UINT16(cmd->data[UINT32_SIZE]));
break;
case CMD_TAG_CREATE:
fake_cmd = v_tag_create_ack_create(UINT32(cmd->data[0]),
UINT16(cmd->data[UINT32_SIZE]),
UINT16(cmd->data[UINT32_SIZE + UINT16_SIZE]));
break;
case CMD_TAG_DESTROY:
fake_cmd = v_tag_destroy_ack_create(UINT32(cmd->data[0]),
UINT16(cmd->data[UINT32_SIZE]),
UINT16(cmd->data[UINT32_SIZE + UINT16_SIZE]));
break;
case CMD_LAYER_CREATE:
fake_cmd = v_fake_layer_create_ack_create(UINT32(cmd->data[0]),
UINT16(cmd->data[UINT32_SIZE + UINT16_SIZE]));
break;
case CMD_LAYER_DESTROY:
fake_cmd = v_fake_layer_destroy_ack_create(UINT32(cmd->data[0]),
UINT16(cmd->data[UINT32_SIZE]));
break;
default:
break;
}
if(fake_cmd != NULL) {
is_fake_cmd_received = 1;
/* Push command to the queue of incomming commands */
v_in_queue_push(vsession->in_queue, fake_cmd);
/* Print content of fake command */
v_fake_cmd_print(VRS_PRINT_DEBUG_MSG, fake_cmd);
}
}
/* Remove command from the history of sent commands */
ret = v_hash_array_remove_item(&history->cmd_hist[sent_cmd->id]->cmds, sent_cmd->vbucket->data);
if(ret == 1) {
/* Destroy command */
v_cmd_destroy(&cmd);
} else {
v_print_log(VRS_PRINT_ERROR, "Unable to remove command id: %d\n", sent_cmd->id);
ret = 0;
}
}
sent_cmd = sent_cmd->next;
}
/* Free linked list of sent commands */
v_list_free(&sent_packet->cmds);
/* Remove packet itself from the linked list of sent packet */
v_list_rem_item(&history->packets, sent_packet);
free(sent_packet);
ret = 1;
} else {
/* When acknowledged payload packet is not found in history, then it
* is OK, because it is probably keep alive packet without any node
* commands */
v_print_log(VRS_PRINT_DEBUG_MSG, "Packet with id: %d, not found in history\n", id);
}
/* When pure ack packet caused adding some fake commands to the queue, then
* poke server data thread */
if( (vs_ctx != NULL) && (is_fake_cmd_received == 1) && (r_packet->data == NULL)) {
sem_post(vs_ctx->data.sem);
}
return ret;
}
