unsigned int v_unpack_b_tile_set(const char *buf, size_t buffer_length)
{
uint8 enum_temp;
unsigned int buffer_pos = 0;
void (* func_b_tile_set)(void *user_data, VNodeID node_id, VLayerID layer_id, uint16 tile_x, uint16 tile_y, uint16 z, VNBLayerType type, const VNBTile *tile);
VNodeID node_id;
VLayerID layer_id;
uint16 tile_x;
uint16 tile_y;
uint16 z;
VNBLayerType type;
const VNBTile *tile;
func_b_tile_set = v_fs_get_user_func(83);
if(buffer_length < 12)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &tile_x);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &tile_y);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &z);
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &enum_temp);
type = (VNBLayerType)enum_temp;
#if defined V_PRINT_RECEIVE_COMMANDS
printf("receive: verse_send_b_tile_set(node_id = %u layer_id = %u tile_x = %u tile_y = %u z = %u type = %u ); callback = %p\n", node_id, layer_id, tile_x, tile_y, z, type, v_fs_get_user_func(83));
#endif
{
VNBTile tile;
switch(type)
{
case VN_B_LAYER_UINT1 :
buffer_pos += vnp_raw_unpack_uint8_vector(&buf[buffer_pos], tile.vuint1, VN_B_TILE_SIZE * VN_B_TILE_SIZE / 8);
break;
case VN_B_LAYER_UINT8 :
buffer_pos += vnp_raw_unpack_uint8_vector(&buf[buffer_pos], tile.vuint8, VN_B_TILE_SIZE * VN_B_TILE_SIZE);
break;
case VN_B_LAYER_UINT16 :
buffer_pos += vnp_raw_unpack_uint16_vector(&buf[buffer_pos], tile.vuint16, VN_B_TILE_SIZE * VN_B_TILE_SIZE);
break;
case VN_B_LAYER_REAL32 :
buffer_pos += vnp_raw_unpack_real32_vector(&buf[buffer_pos], tile.vreal32, VN_B_TILE_SIZE * VN_B_TILE_SIZE);
break;
case VN_B_LAYER_REAL64 :
buffer_pos += vnp_raw_unpack_real64_vector(&buf[buffer_pos], tile.vreal64, VN_B_TILE_SIZE * VN_B_TILE_SIZE);
break;
}
if(func_b_tile_set != NULL && type <= VN_B_LAYER_REAL64)
func_b_tile_set(v_fs_get_user_data(83), node_id, layer_id, tile_x, tile_y, z, type, &tile);
return buffer_pos;
}
if(func_b_tile_set != NULL)
func_b_tile_set(v_fs_get_user_data(83), node_id, layer_id, tile_x, tile_y, z, (VNBLayerType)type, tile);
return buffer_pos;
}
END_TEST
/**
* \brief Unit test of packing uint16 values
*/
START_TEST ( test_UnPack_Uint16 )
{
size_t buf_pos = 0;
unsigned char buffer[UINT16_BUF_SIZE] = {
0x00, 0x00, /* 0 */
0x00, 0x01, /* 1 */
0x02, 0x00, /* 512 */
0x04, 0x06, /* 1030 */
0xff, 0xff, /* 65535 */
0,
};
uint16 expected_results[UINT16_TV_SIZE] = {
0,
1,
512,
1030,
65535,
0,
};
uint16 results[UINT16_TV_SIZE] = {0,};
int i = 0;
buf_pos += vnp_raw_unpack_uint16((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint16((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint16((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint16((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint16((void*)&buffer[buf_pos],
&results[i++]);
fail_unless( buf_pos == 5*2,
"Size of uint16 buffer: %d != 10",
buf_pos);
for(i = 0; i < UINT16_TV_SIZE; i++) {
fail_unless( results[i] == expected_results[i],
"Test vector of uint16 differs at position: %d (%d != %d)",
i, results[i], expected_results[i]);
}
}
/**
* \brief Get header of verse packet from received buffer
* \param[in] *buffer The received buffer
* \param[in] buffer_len The size of received buffer
* \param[out] *vpacket The structure of packet, that will be filled with
* information from the buffer.
* \return This function returns relative buffer position of buffer proceeding.
* When corrupted header detected, then it returns -1.
*/
int v_unpack_packet_header(const char *buffer,
const unsigned short buffer_len,
struct VPacket *vpacket)
{
unsigned short buffer_pos=0;
unsigned char ver;
if(buffer_len < VERSE_PACKET_HEADER_SIZE) return -1;
/* Length of packet */
vpacket->len = buffer_len;
/* Verse version */
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos], &ver);
vpacket->header.version = (ver >> 4) & 0x0F;
/* Flags */
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos], &vpacket->header.flags);
/* Flow control window */
buffer_pos += vnp_raw_unpack_uint16(&buffer[buffer_pos], &vpacket->header.window);
/* Payload ID */
buffer_pos += vnp_raw_unpack_uint32(&buffer[buffer_pos], &vpacket->header.payload_id);
/* ACK NAK ID */
buffer_pos += vnp_raw_unpack_uint32(&buffer[buffer_pos], &vpacket->header.ack_nak_id);
/* ANK ID */
buffer_pos += vnp_raw_unpack_uint32(&buffer[buffer_pos], &vpacket->header.ank_id);
return buffer_pos;
}
unsigned int v_unpack_c_curve_subscribe(const char *buf, size_t buffer_length)
{
unsigned int buffer_pos = 0;
void (* func_c_curve_subscribe)(void *user_data, VNodeID node_id, VLayerID curve_id);
VNodeID node_id;
VLayerID curve_id;
uint8 alias_bool;
func_c_curve_subscribe = v_fs_get_user_func(129);
if(buffer_length < 6)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &curve_id);
if(buffer_length < buffer_pos + 1)
return -1;
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &alias_bool);
#if defined V_PRINT_RECEIVE_COMMANDS
if(!alias_bool)
printf("receive: verse_send_c_curve_unsubscribe(node_id = %u curve_id = %u ); callback = %p\n", node_id, curve_id, v_fs_get_alias_user_func(129));
else
printf("receive: verse_send_c_curve_subscribe(node_id = %u curve_id = %u ); callback = %p\n", node_id, curve_id, v_fs_get_user_func(129));
#endif
if(!alias_bool)
{
void (* alias_c_curve_unsubscribe)(void *user_data, VNodeID node_id, VLayerID curve_id);
alias_c_curve_unsubscribe = v_fs_get_alias_user_func(129);
if(alias_c_curve_unsubscribe != NULL)
alias_c_curve_unsubscribe(v_fs_get_alias_user_data(129), node_id, curve_id);
return buffer_pos;
}
if(func_c_curve_subscribe != NULL)
func_c_curve_subscribe(v_fs_get_user_data(129), node_id, curve_id);
return buffer_pos;
}
unsigned int v_unpack_b_layer_subscribe(const char *buf, size_t buffer_length)
{
unsigned int buffer_pos = 0;
void (* func_b_layer_subscribe)(void *user_data, VNodeID node_id, VLayerID layer_id, uint8 level);
VNodeID node_id;
VLayerID layer_id;
uint8 level;
func_b_layer_subscribe = v_fs_get_user_func(82);
if(buffer_length < 6)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &level);
#if defined V_PRINT_RECEIVE_COMMANDS
if(level == 255)
printf("receive: verse_send_b_layer_unsubscribe(node_id = %u layer_id = %u ); callback = %p\n", node_id, layer_id, v_fs_get_alias_user_func(82));
else
printf("receive: verse_send_b_layer_subscribe(node_id = %u layer_id = %u level = %u ); callback = %p\n", node_id, layer_id, level, v_fs_get_user_func(82));
#endif
if(level == 255)
{
void (* alias_b_layer_unsubscribe)(void *user_data, VNodeID node_id, VLayerID layer_id);
alias_b_layer_unsubscribe = v_fs_get_alias_user_func(82);
if(alias_b_layer_unsubscribe != NULL)
alias_b_layer_unsubscribe(v_fs_get_alias_user_data(82), node_id, layer_id);
return buffer_pos;
}
if(func_b_layer_subscribe != NULL)
func_b_layer_subscribe(v_fs_get_user_data(82), node_id, layer_id, level);
return buffer_pos;
}
unsigned int v_unpack_b_dimensions_set(const char *buf, size_t buffer_length)
{
unsigned int buffer_pos = 0;
void (* func_b_dimensions_set)(void *user_data, VNodeID node_id, uint16 width, uint16 height, uint16 depth);
VNodeID node_id;
uint16 width;
uint16 height;
uint16 depth;
func_b_dimensions_set = v_fs_get_user_func(80);
if(buffer_length < 4)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &width);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &height);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &depth);
#if defined V_PRINT_RECEIVE_COMMANDS
printf("receive: verse_send_b_dimensions_set(node_id = %u width = %u height = %u depth = %u ); callback = %p\n", node_id, width, height, depth, v_fs_get_user_func(80));
#endif
if(func_b_dimensions_set != NULL)
func_b_dimensions_set(v_fs_get_user_data(80), node_id, width, height, depth);
return buffer_pos;
}
/**
* \brief Get header of verse message from received buffer
* \param[in] *buffer The received buffer
* \param[in] buffer_len The size of received buffer
* \param[out] *vmessage The structure of message, that will be filled with
* information from the buffer.
* \return This function returns relative buffer position of buffer proceeding.
* When corrupted header detected, then it returns -1.
*/
int v_unpack_message_header(const char *buffer,
const unsigned short buffer_len,
struct VMessage *vmessage)
{
unsigned short buffer_pos=0;
unsigned char tmp;
if(buffer_len < VERSE_MESSAGE_HEADER_SIZE) return -1;
/* Unpack version of protocol */
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos], &tmp);
vmessage->header.version = (tmp >> 4) & 0x0F;
/* Unpack zero byte for reservation */
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos], &tmp);
/* Unpack message length of message */
buffer_pos += vnp_raw_unpack_uint16(&buffer[buffer_pos], &vmessage->header.len);
return buffer_pos;
}
unsigned int v_unpack_b_layer_create(const char *buf, size_t buffer_length)
{
uint8 enum_temp;
unsigned int buffer_pos = 0;
void (* func_b_layer_create)(void *user_data, VNodeID node_id, VLayerID layer_id, const char *name, VNBLayerType type);
VNodeID node_id;
VLayerID layer_id;
char name[16];
VNBLayerType type;
func_b_layer_create = v_fs_get_user_func(81);
if(buffer_length < 6)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], name, 16, buffer_length - buffer_pos);
if(buffer_length < 1 + buffer_pos)
return -1;
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &enum_temp);
type = (VNBLayerType)enum_temp;
#if defined V_PRINT_RECEIVE_COMMANDS
if(name[0] == 0)
printf("receive: verse_send_b_layer_destroy(node_id = %u layer_id = %u ); callback = %p\n", node_id, layer_id, v_fs_get_alias_user_func(81));
else
printf("receive: verse_send_b_layer_create(node_id = %u layer_id = %u name = %s type = %u ); callback = %p\n", node_id, layer_id, name, type, v_fs_get_user_func(81));
#endif
if(name[0] == 0)
{
void (* alias_b_layer_destroy)(void *user_data, VNodeID node_id, VLayerID layer_id);
alias_b_layer_destroy = v_fs_get_alias_user_func(81);
if(alias_b_layer_destroy != NULL)
alias_b_layer_destroy(v_fs_get_alias_user_data(81), node_id, layer_id);
return buffer_pos;
}
if(func_b_layer_create != NULL)
func_b_layer_create(v_fs_get_user_data(81), node_id, layer_id, name, (VNBLayerType) type);
return buffer_pos;
}
unsigned int v_unpack_c_curve_create(const char *buf, size_t buffer_length)
{
unsigned int buffer_pos = 0;
void (* func_c_curve_create)(void *user_data, VNodeID node_id, VLayerID curve_id, const char *name, uint8 dimensions);
VNodeID node_id;
VLayerID curve_id;
char name[16];
uint8 dimensions;
func_c_curve_create = v_fs_get_user_func(128);
if(buffer_length < 6)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &curve_id);
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], name, 16, buffer_length - buffer_pos);
if(buffer_length < 1 + buffer_pos)
return -1;
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &dimensions);
#if defined V_PRINT_RECEIVE_COMMANDS
if(name[0] == 0)
printf("receive: verse_send_c_curve_destroy(node_id = %u curve_id = %u ); callback = %p\n", node_id, curve_id, v_fs_get_alias_user_func(128));
else
printf("receive: verse_send_c_curve_create(node_id = %u curve_id = %u name = %s dimensions = %u ); callback = %p\n", node_id, curve_id, name, dimensions, v_fs_get_user_func(128));
#endif
if(name[0] == 0)
{
void (* alias_c_curve_destroy)(void *user_data, VNodeID node_id, VLayerID curve_id);
alias_c_curve_destroy = v_fs_get_alias_user_func(128);
if(alias_c_curve_destroy != NULL)
alias_c_curve_destroy(v_fs_get_alias_user_data(128), node_id, curve_id);
return buffer_pos;
}
if(func_c_curve_create != NULL)
func_c_curve_create(v_fs_get_user_data(128), node_id, curve_id, name, dimensions);
return buffer_pos;
}
/* Unpack half-float value */
size_t vnp_raw_unpack_real16(const void *buffer, real16 *data)
{
return vnp_raw_unpack_uint16(buffer, (uint16 *) data);
}
unsigned int v_unpack_c_key_set(const char *buf, size_t buffer_length)
{
unsigned int i, buffer_pos = 0;
VNodeID node_id;
VLayerID curve_id;
uint32 key_id;
uint8 dimensions;
real64 pre_value[4], value[4], pos, post_value[4];
uint32 post_pos[4], pre_pos[4];
if(buffer_length < 11)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &curve_id);
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &key_id);
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &dimensions);
if(dimensions != 0 && dimensions < 5)
{
void (* func_c_key_set)(void *user_data, VNodeID node_id, VLayerID curve_id, uint32 key_id, uint8 dimensions, real64 *pre_value, uint32 *pre_pos, real64 *value, real64 pos, real64 *post_value, uint32 *post_pos);
for(i = 0; i < dimensions; i++)
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &pre_value[i]);
for(i = 0; i < dimensions; i++)
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &pre_pos[i]);
for(i = 0; i < dimensions; i++)
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &value[i]);
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &pos);
for(i = 0; i < dimensions; i++)
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &post_value[i]);
for(i = 0; i < dimensions; i++)
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &post_pos[i]);
#if defined V_PRINT_RECEIVE_COMMANDS
switch(dimensions)
{
case 1:
printf("receive: verse_send_c_key_set(node_id = %u curve_id = %u key_id = %u dimensions = %u pre_value = %f pre_pos = %u value = %f pos = %f, pre_value = %f pre_pos = %u ); callback = %p\n", node_id, curve_id, key_id, dimensions, pre_value[0], pre_pos[0], value[0], pos, pre_value[0], pre_pos[0], v_fs_get_user_func(130));
break;
case 2:
printf("receive: verse_send_c_key_set(node_id = %u curve_id = %u key_id = %u dimensions = %u pre_value = {%f, %f} pre_pos = {%u, %u} value = {%f, %f} pos = %f, pre_value = {%f, %f} pre_pos = {%u, %u}); callback = %p\n",
node_id, curve_id, key_id, dimensions,
pre_value[0], pre_value[1],
pre_pos[0], pre_pos[1],
value[0], value[1], pos,
pre_value[0], pre_value[1],
pre_pos[0], pre_pos[1], v_fs_get_user_func(130));
break;
case 3:
printf("receive: verse_send_c_key_set(node_id = %u curve_id = %u key_id = %u dimensions = %u pre_value = {%f, %f, %f} pre_pos = {%u, %u, %u} value = {%f, %f, %f} pos = %f, pre_value = {%f, %f, %f} pre_pos = {%u, %u, %u}); callback = %p\n",
node_id, curve_id, key_id, dimensions,
pre_value[0], pre_value[1], pre_value[2],
pre_pos[0], pre_pos[1], pre_pos[2],
value[0], value[1], value[2], pos,
pre_value[0], pre_value[1], pre_value[2],
pre_pos[0], pre_pos[1], pre_pos[2], v_fs_get_user_func(130));
break;
case 4:
printf("receive: verse_send_c_key_set(node_id = %u curve_id = %u key_id = %u dimensions = %u pre_value = {%f, %f, %f, %f} pre_pos = {%u, %u, %u, %u} value = {%f, %f, %f, %f} pos = %f, pre_value = {%f, %f, %f, %f} pre_pos = {%u, %u, %u, %u}); callback = %p\n",
node_id, curve_id, key_id, dimensions,
pre_value[0], pre_value[1], pre_value[2], pre_value[3],
pre_pos[0], pre_pos[1], pre_pos[2], pre_pos[3],
value[0], value[1], value[2], value[3], pos,
pre_value[0], pre_value[1], pre_value[2], pre_value[3],
pre_pos[0], pre_pos[1], pre_pos[2], pre_pos[3], v_fs_get_user_func(130));
break;
}
#endif
func_c_key_set = v_fs_get_user_func(130);
if(func_c_key_set != NULL)
func_c_key_set(v_fs_get_user_data(130), node_id, curve_id, key_id, dimensions, pre_value, pre_pos, value, pos, post_value, post_pos);
return buffer_pos;
}else
{
void (* alias_c_key_destroy)(void *user_data, VNodeID node_id, VLayerID curve_id, uint32 key_id);
alias_c_key_destroy = v_fs_get_alias_user_func(130);
printf("receive: verse_send_c_key_destroy(node_id = %u curve_id = %u key_id = %u); callback = %p\n", node_id, curve_id, key_id, alias_c_key_destroy);
if(alias_c_key_destroy != NULL)
alias_c_key_destroy(v_fs_get_alias_user_data(130), node_id, curve_id, key_id);
return buffer_pos;
}
}
unsigned int v_unpack_t_text_set(const char *buf, size_t buffer_length)
{
unsigned int i, buffer_pos = 0;
VOrderedStorage *s;
VTempText l, *line, *past = NULL;
char text[1500];
if(buffer_length < 12)
return -1;
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &l.node_id);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &l.buffer_id);
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &l.pos);
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &l.length);
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &l.index);
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], text, sizeof text, buffer_length - buffer_pos);
if(text[0] == 0)
l.text = NULL;
else
l.text = text;
s = v_con_get_ordered_storage();
if(s->text_receive_id == l.index)
{
call_text_set(&l);
s->text_receive_id++;
line = s->text_temp;
while(line != NULL)
{
if(line->index == s->text_receive_id)
{
call_text_set(line);
if(past == NULL)
s->text_temp = line->next;
else
past->next = line->next;
if(line->text != NULL)
free(line->text);
past = NULL;
free(line);
line = s->text_temp;
s->text_receive_id++;
}
else
{
past = line;
line = line->next;
}
}
}
else
{
line = malloc(sizeof *line);
*line = l;
line->next = s->text_temp;
s->text_temp = line;
i = strlen(text);
if(i > 0)
{
line->text = malloc(i + 1);
strcpy(line->text, text);
}
else
line->text = NULL;
}
return buffer_pos;
}
/**
* \brief This function unpack negotiate commands: Change_L/R and Confirm_L/R
* from the buffer
*
* Unpack negotiate command (CHANGE_L, CONFIRM_L, CHANGE_R, CONFIRM_R). Buffer
* size has to be at least 2 bytes long (this check has to be done before
* calling this function)
*/
int v_raw_unpack_negotiate_cmd(const char *buffer, ssize_t buffer_size, struct Negotiate_Cmd *negotiate_cmd)
{
int str_len=0;
unsigned short buffer_pos = 0, length, i;
unsigned char length8 = 0, len8, lenlen;
/* Unpack command ID */
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos], &negotiate_cmd->id);
/* Unpack Length of values */
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos], &length8);
/* Check if the length of the command is stored in the second byte of
* command or is it stored in two bytes after second byte of the command */
if(length8==0xFF) {
buffer_pos += vnp_raw_unpack_uint16(&buffer[buffer_pos], &length);
lenlen = 3;
} else {
length = length8;
lenlen = 1;
}
/* Security check: check if the length of the command is not bigger
* then buffer_size. If this test failed, then return buffer_size and set
* count of received values to the zero. */
if(buffer_size < length) {
v_print_log(VRS_PRINT_WARNING, "Buffer size: %d < command length: %d.\n", buffer_size, length);
negotiate_cmd->count = 0;
return buffer_size;
/* Security check: check if the length of the command is equal or bigger
* then minimal length of the negotiate command: ID_len + Length_len +
* Feature_len*/
} else if(length < (1+lenlen+1)) {
v_print_log(VRS_PRINT_WARNING, "Command length: %d < (1+%d+1).\n", length, lenlen);
negotiate_cmd->count = 0;
return buffer_size;
}
/* Unpack Feature ID */
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos], &negotiate_cmd->feature);
/* Compute count of values in preference list. When unknown or unsupported
* feature is detected, then processing of this command is stopped and it
* returns the length of command. */
switch(negotiate_cmd->feature) {
case FTR_RSV_ID:
v_print_log(VRS_PRINT_WARNING, "Received RESERVED feature ID\n");
negotiate_cmd->count = 0;
return length; /* This feature id should never be sent or received */
case FTR_FC_ID:
case FTR_CC_ID:
case FTR_RWIN_SCALE:
case FTR_CMD_COMPRESS:
negotiate_cmd->count = length - (1+lenlen+1);
break;
case FTR_HOST_URL:
case FTR_TOKEN:
case FTR_DED:
case FTR_CLIENT_NAME:
case FTR_CLIENT_VERSION:
negotiate_cmd->count = 0;
while(str_len < (length -(1+lenlen+1))) {
vnp_raw_unpack_uint8(&buffer[buffer_pos+str_len], &len8);
str_len += 1 + len8;
negotiate_cmd->count++;
}
break;
case FTR_FPS:
negotiate_cmd->count = (length - (1+lenlen))/4;
break;
default:
v_print_log(VRS_PRINT_WARNING, "Received UNKNOWN feature ID\n");
negotiate_cmd->count = 0;
return length;
}
/* Unpack values (preference list) */
for(i=0; i<negotiate_cmd->count; i++) {
switch(negotiate_cmd->feature) {
case FTR_FC_ID:
case FTR_CC_ID:
case FTR_RWIN_SCALE:
case FTR_CMD_COMPRESS:
buffer_pos += vnp_raw_unpack_uint8(&buffer[buffer_pos],
&negotiate_cmd->value[i].uint8);
break;
case FTR_HOST_URL:
case FTR_TOKEN:
case FTR_DED:
case FTR_CLIENT_NAME:
case FTR_CLIENT_VERSION:
buffer_pos += vnp_raw_unpack_string8_(&buffer[buffer_pos],
buffer_size-buffer_pos,
&negotiate_cmd->value[i].string8);
break;
case FTR_FPS:
buffer_pos += vnp_raw_unpack_real32(&buffer[buffer_pos],
&negotiate_cmd->value[i].real32);
break;
default:
break;
}
}
/* Check if length and buffer_pos match */
if(buffer_pos!=length) {
v_print_log(VRS_PRINT_DEBUG_MSG, "%s: buffer_pos: %d != length: %d\n",
__FUNCTION__, buffer_pos, length);
return length;
}
return length;
}
