/**
* \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;
}
/* Unpack eight bytes from buffer */
size_t vnp_raw_unpack_uint64(const void *buffer, uint64 *data)
{
union { uint32 uint[2]; uint64 ulong; } punt;
uint32 size;
size = vnp_raw_unpack_uint32(buffer, &punt.uint[1]);
size += vnp_raw_unpack_uint32(((uint8 *)buffer) + size, &punt.uint[0]);
*data = punt.ulong;
return size;
}
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_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;
}
void v_e_data_encrypt_command(uint8 *packet, size_t packet_size, const uint8 *command, size_t command_size, const uint8 *key)
{
uint32 pos, i;
vnp_raw_unpack_uint32(packet, &pos);
/* printf("encrypting packet %u", pos);*/
pos = key[pos % V_ENCRYPTION_DATA_KEY_SIZE] + packet_size;
/* printf(" -> pos=%u (size %u)", pos, packet_size);
printf(", key begins: [");
for(i = 0; i < 16; i++)
printf(" %02X", key[(pos + i) % V_ENCRYPTION_DATA_KEY_SIZE]);
printf(" ]\n");
*/
for(i = 0; i < command_size; i++)
packet[packet_size + i] = command[i] ^ key[(i + pos) % V_ENCRYPTION_DATA_KEY_SIZE];
}
void v_e_data_decrypt_packet(uint8 *to, const uint8 *from, size_t size, const uint8 *key)
{
uint32 pos, i;
vnp_raw_unpack_uint32(from, &pos);
/* printf("decrypting packet %u", pos);*/
pos = key[pos % V_ENCRYPTION_DATA_KEY_SIZE];
/* printf(" -> pos=%u", pos);
printf(", key begins: [");
for(i = 0; i < 16; i++)
printf(" %02X", key[(i + pos) % V_ENCRYPTION_DATA_KEY_SIZE]);
printf(" ]\n");
*/ for(i = 0; i < 4; i++)
to[i] = from[i];
for(i = 4; i < size; i++)
to[i] = from[i] ^ key[(i + pos) % V_ENCRYPTION_DATA_KEY_SIZE];
}
END_TEST
/**
* \brief Unit test of packing uint32 values
*/
START_TEST ( test_UnPack_Uint32 )
{
size_t buf_pos = 0;
unsigned char buffer[UINT32_BUF_SIZE] = {
0x00, 0x00, 0x00, 0x00, /* 0 */
0x00, 0x00, 0x00, 0x01, /* 1 */
0x00, 0x00, 0x02, 0x00, /* 512 */
0x00, 0x01, 0x00, 0x04, /* 65540 */
0x01, 0x00, 0x00, 0x00, /* 16 777 216 */
0xff, 0xff, 0xff, 0xff, /* 4 294 967 295 */
0,
};
uint32 expected_results[UINT32_TV_SIZE] = {
0,
1,
512,
65540,
16777216,
4294967295,
0,
};
uint32 results[UINT32_TV_SIZE] = {0,};
int i = 0;
buf_pos += vnp_raw_unpack_uint32((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint32((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint32((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint32((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint32((void*)&buffer[buf_pos],
&results[i++]);
buf_pos += vnp_raw_unpack_uint32((void*)&buffer[buf_pos],
&results[i++]);
fail_unless( buf_pos == 6*4,
"Size of uint32 buffer: %d != 24",
buf_pos);
for(i = 0; i < UINT32_TV_SIZE; i++) {
fail_unless( results[i] == expected_results[i],
"Test vector of uint32 differs at position: %d (%d != %d)",
i, results[i], expected_results[i]);
}
}
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;
}
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;
}
/* Unpack float value */
size_t vnp_raw_unpack_real32(const void *buffer, real32 *data)
{
return vnp_raw_unpack_uint32(buffer, (uint32 *) 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;
}
/* Main function that receives and distributes all incoming packets. */
boolean v_con_network_listen(void)
{
VNetworkAddress address;
uint8 buf[V_MAX_CONNECT_PACKET_SIZE], *store;
int size = 0;
unsigned int connection;
uint32 packet_id;
boolean ret = FALSE;
v_con_init(); /* Init if needed. */
connection = VConData.current_connection; /* Store current connection in a local variable so that we can restore it later. */
size = v_n_receive_data(&address, buf, sizeof buf); /* Ask for incoming data from the network. */
while(size != -1 && size != 0) /* Did we get any data? */
{
VConData.current_connection = v_co_find_connection(address.ip, address.port); /* Is there a connection matching the IP and port? */
vnp_raw_unpack_uint32(buf, &packet_id); /* Unpack the ID of the packet. */
/* printf("got packet ID %u, %d bytes, connection %u\n", packet_id, size, VConData.current_connection);*/
if(VConData.current_connection < VConData.con_count &&
!(VConData.con[VConData.current_connection].connect_stage == V_CS_CONNECTED && packet_id == 0)) /* If this isn't a packet from an existing connection, disregard it. */
{
if(VConData.con[VConData.current_connection].connect_stage == V_CS_CONNECTED) /* Is this connection initialized? */
{
store = v_niq_store(&VConData.con[VConData.current_connection].in_queue, size, packet_id); /* Store the packet. */
if(store != NULL)
{
VConData.pending_packets++; /* We now have one more packet pending unpack. */
v_e_data_decrypt_packet(store, buf, size, VConData.con[VConData.current_connection].key_data); /* Decrypt the packet. */
v_fs_unpack_beginning(store, size);
}
}
else
{
v_unpack_connection(buf, size); /* This is an ongoing connecton-attempt. */
v_niq_timer_update(&VConData.con[VConData.current_connection].in_queue);
}
}
else if(v_connect_unpack_ping(buf, size, address.ip, address.port)) /* Ping handled. */
;
else if(v_fs_func_accept_connections()) /* Do we accept connection-attempts? */
{
if(VConData.current_connection >= VConData.con_count ||
V_RE_CONNECTON_TIME_OUT < v_niq_time_out(&VConData.con[VConData.current_connection].in_queue)) /* Is it a new client, or an old client that we haven't heard form in some time? */
{
if(VConData.current_connection < VConData.con_count)
{
VConData.con[VConData.current_connection].network_address.ip = 0;
VConData.con[VConData.current_connection].destroy_flag = TRUE; /* Destroy old connection if there is one. */
}
v_con_connect(address.ip, address.port, V_CS_IDLE); /* Create a new connection. */
v_unpack_connection(buf, size); /* Unpack the connection-attempt. */
}
}
else
{
fprintf(stderr, __FILE__ ": Unhandled packet--dropping\n");
if(VConData.con_count > 0)
{
fprintf(stderr, __FILE__ ": State: connections=%u, current=%u (stage %u), packet_id=%u\n",
VConData.con_count,
VConData.current_connection,
(VConData.current_connection < VConData.con_count) ? VConData.con[VConData.current_connection].connect_stage : 0,
packet_id);
}
}
size = v_n_receive_data(&address, buf, sizeof buf); /* See if there are more incoming packets. */
ret = TRUE;
}
VConData.current_connection = connection; /* Reset the current connection. */
return ret;
}