/**
* \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 packs and compress command to the packet from one
* priority queue.
*
* \param[in] *C The verse context
* \param[in] *sent_packet The pointer at structure with send packet
* \param[in] buffer_pos The curent size of buffer of sent packet
* \param[in] prio The priority of sub queue
* \param[in] prio_win The window size of current prio queue
* \param[out] tot_cmd_size The total size of commands that were poped from prio queue
*/
static int pack_prio_queue(struct vContext *C,
struct VSent_Packet *sent_packet,
int buffer_pos,
uint8 prio,
uint16 prio_win,
uint16 *tot_cmd_size)
{
struct VSession *vsession = CTX_current_session(C);
struct VDgramConn *vconn = CTX_current_dgram_conn(C);
struct IO_CTX *io_ctx = CTX_io_ctx(C);
struct Generic_Cmd *cmd;
int ret, last_cmd_count = 0;
uint16 cmd_count, cmd_len, cmd_size, sum_len=0;
int8 cmd_share;
uint8 last_cmd_id = CMD_RESERVED_ID;
while( (v_out_queue_get_count_prio(vsession->out_queue, prio) > 0) &&
(sum_len < prio_win) &&
(buffer_pos < vconn->io_ctx.mtu))
{
cmd_count = 0;
cmd_share = 0;
/* Compute how many commands could be compressed to the packet
* and compute right length of compressed commands. */
cmd_len = ((prio_win - sum_len)<(vconn->io_ctx.mtu - buffer_pos)) ?
(prio_win - sum_len) :
(vconn->io_ctx.mtu - buffer_pos);
/* Remove command from queue */
cmd = v_out_queue_pop(vsession->out_queue, prio, &cmd_count, &cmd_share, &cmd_len);
/* When it is not possible to pop more commands from queue, then break
* while loop */
if(cmd == NULL) {
break;
}
/* Is this command fake command? */
if(cmd->id < MIN_CMD_ID) {
if(cmd->id == FAKE_CMD_CONNECT_TERMINATE) {
struct VS_CTX *vs_ctx = CTX_server_ctx(C);
if(vs_ctx != NULL) {
vconn->host_state = UDP_SERVER_STATE_CLOSEREQ;
} else {
vconn->host_state = UDP_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;
}
v_cmd_destroy(&cmd);
} else {
/* What was size of command in queue */
cmd_size = v_cmd_size(cmd);
if(!(buffer_pos < (vconn->io_ctx.mtu - cmd_size))) {
/* When there is not enough space for other command,
* then push command back to the beginning of queue. */
v_out_queue_push_head(vsession->out_queue, prio, cmd);
break;
} else {
/* Update total size of commands that were poped from queue */
*tot_cmd_size += cmd_size;
/* When compression is not allowed, then add this command as is */
if( vconn->host_cmd_cmpr == CMPR_NONE) {
cmd_count = 0;
cmd_len = cmd_size;
/* Debug print */
v_print_log(VRS_PRINT_DEBUG_MSG, "Cmd: %d, count: %d, length: %d\n",
cmd->id, cmd_count, cmd_len);
/* Add command to the buffer */
buffer_pos += v_cmd_pack(&io_ctx->buf[buffer_pos], cmd, cmd_len, 0);
} else {
/* When command compression is allowed and was ID of command changed? */
if( (cmd->id != last_cmd_id) || (last_cmd_count <= 0) ) {
/* When this command is alone, then use default command size */
if(cmd_count == 0) {
cmd_len = cmd_size;
} else {
/* FIXME: do not recompute command length here, but do it right,
* when command is added to the queue */
cmd_len = v_cmds_len(cmd, cmd_count, cmd_share, cmd_len);
}
/* Debug print */
v_print_log(VRS_PRINT_DEBUG_MSG, "Cmd: %d, count: %d, length: %d\n",
cmd->id, cmd_count, cmd_len);
/* Add command to the buffer */
buffer_pos += v_cmd_pack(&io_ctx->buf[buffer_pos], cmd, cmd_len, cmd_share);
/* Set up current count of commands in the line */
last_cmd_count = cmd_count;
/* Update summary of commands length */
sum_len += cmd_len;
} else {
buffer_pos += v_cmd_pack(&io_ctx->buf[buffer_pos], cmd, 0, cmd_share);
}
}
/* Print command */
v_cmd_print(VRS_PRINT_DEBUG_MSG, cmd);
/* TODO: remove command alias here (layer value set/unset) */
/* Add command to the packet history */
ret = v_packet_history_add_cmd(&vconn->packet_history, sent_packet, cmd, prio);
assert(ret==1);
/* Update last command id */
last_cmd_id = cmd->id;
/* Decrement counter of commands in queue */
last_cmd_count--;
}
}
}
return buffer_pos;
}
/*
* \brief This function pop command from queue with specific priority.
*
* Returned command is allocated on the heap and have to be free from calling
* function. When *count is not NULL, then this function will write number of
* commands with same ID that could be compressed on this address. When *len
* is not NULL, then this function will write length of compressed commands
* at this address. When *len value is not 0, then this value represents maximal
* size of commands that could be removed from this priority queue.
*
* \param[in] *out_queue The pointer at list of priority queues
* \param[in] prio The value of priority
* \param[out] *count The pointer at count of commands with same id that
* could be compressed.
* \param[out] *share The size of address that could be shared
* \param[out] *len The length of compressed commands.
*
* \return This function returns pointer at command. This command is allocated
* at the heap.
*/
struct Generic_Cmd *v_out_queue_pop(struct VOutQueue *out_queue,
uint8 prio,
uint16 *count,
int8 *share,
uint16 *len)
{
struct VPrioOutQueue *prio_queue = out_queue->queues[prio];
struct VOutQueueCommand *queue_cmd;
struct Generic_Cmd *cmd=NULL;
int i, can_pop_cmd = 1;
/* Lock mutex */
pthread_mutex_lock(&out_queue->lock);
/*printf("\tcount: %u, share: %u, len: %u\n", *count, *share, *len);*/
queue_cmd = prio_queue->cmds.first;
if(queue_cmd != NULL ) {
cmd = (struct Generic_Cmd *)queue_cmd->vbucket->data;
assert(cmd != NULL);
/* Return value of count and length of compressed commands */
if(queue_cmd->counter != NULL) {
if(count != NULL) {
*count = *queue_cmd->counter;
}
if(share != NULL) {
*share = *queue_cmd->share;
}
if(len != NULL) {
/* When *len value is not 0, then this value represents maximal
* size of buffer that could be filled with this priority queue. This
* function should return value, that is smaller or equal than this
* maximum. */
if(*len != 0) {
if(*len < *queue_cmd->len) {
if (count != NULL) {
*count = v_cmd_count(cmd, *len, *queue_cmd->share);
/* FIXME: compute length and count correctly, when command is added to the queue */
*count = ((*count) > (*queue_cmd->counter)) ? *queue_cmd->counter : *count;
/* Is enough space in buffer to unpack this command? */
if(*count == 0) {
can_pop_cmd = 0;
}
*len = v_cmds_len(cmd, *count, *queue_cmd->share, 0);
} else {
can_pop_cmd = 0;
}
} else {
*len = *queue_cmd->len;
}
} else {
*len = *queue_cmd->len;
}
}
} else {
if(count != NULL) {
*count = 0;
}
if(share != NULL) {
*share = 0;
}
if(len != NULL) {
if(v_cmd_size(cmd) > *len) {
can_pop_cmd = 0;
}
*len = 0;
}
}
/* Is it possible to pop command from the queue */
if(can_pop_cmd == 1) {
/* Remove command from hashed linked list */
v_hash_array_remove_item(&out_queue->cmds[cmd->id]->cmds, (void*)cmd);
/* Remove command from priority queue */
v_list_rem_item(&prio_queue->cmds, queue_cmd);
/* Update total count and size of commands */
out_queue->count--;
out_queue->size -= out_queue->cmds[cmd->id]->item_size;
/* Update count and size of commands in subqueue with priority prio */
out_queue->queues[prio]->count--;
out_queue->queues[prio]->size -= out_queue->cmds[cmd->id]->item_size;
/* If needed, then update counter of commands with the same id in the queue */
if(queue_cmd->counter != NULL) {
*queue_cmd->counter -= 1;
/* Free values, when it's last command in the queue */
if(*queue_cmd->counter == 0) {
free(queue_cmd->counter);
queue_cmd->counter = NULL;
free(queue_cmd->share);
queue_cmd->share = NULL;
free(queue_cmd->len);
queue_cmd->len = NULL;
}
}
/* When this priority queue is empty now, then update summary of
* real priorities and it is possibly necessary to change maximal
* or minimal priority queue*/
if(out_queue->queues[prio]->count == 0) {
if(prio>=VRS_DEFAULT_PRIORITY) {
out_queue->r_prio_sum_high -= out_queue->queues[prio]->r_prio;
} else {
out_queue->r_prio_sum_low -= out_queue->queues[prio]->r_prio;
}
if(out_queue->max_prio == prio && out_queue->min_prio != prio) {
for(i=prio; i>=out_queue->min_prio; i--) {
if(out_queue->queues[i]->count != 0) {
out_queue->max_prio = i;
break;
}
}
} else if(out_queue->min_prio == prio && out_queue->max_prio != prio) {
for(i=prio; i<=out_queue->max_prio; i++) {
if(out_queue->queues[i]->count != 0) {
out_queue->min_prio = i;
break;
}
}
} else if(out_queue->min_prio == prio && out_queue->max_prio == prio) {
out_queue->min_prio = out_queue->max_prio = VRS_DEFAULT_PRIORITY;
}
}
/* Free queue command */
free(queue_cmd);
} else {
cmd = NULL;
}
}
pthread_mutex_unlock(&out_queue->lock);
return cmd;
}
/**
* \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;
}
