/**
* \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;
}
