StarMirror/toxcore
1
0
Fork 0
mirror of https://github.com/irungentoo/toxcore.git synced 2024-03-22 13:30:51 +08:00
Code Issues Projects Releases Wiki Activity

Fixed several embarrassing errors and potential problems in tox_array.

Browse Source
This commit is contained in:
Anony Moose 2013-08-26 22:04:41 +00:00
parent 4e9d09f217
commit abaaef051c
No known key found for this signature in database
GPG Key ID: A567AC285089C602
2 changed files with 77 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
testing/misc_tools.h
View File

@ -166,7 +166,7 @@ static inline void tox_array_pop(tox_array *arr, uint32_t num)
#define tox_array_for_each(arr, type, tmp_name) \ #define tox_array_for_each(arr, type, tmp_name) \
type tmp_name; uint32_t tmp_name ## _i = 0; \ type *tmp_name; uint32_t tmp_name ## _i = 0; \
for (; tmp_name ## _i != (arr)->len; tmp_name = tox_array_get(arr, ++ tmp_name ## _i, type)) for (; tmp_name ## _i != (arr)->len; tmp_name = &tox_array_get(arr, ++ tmp_name ## _i, type))
#endif // MISC_TOOLS_H #endif // MISC_TOOLS_H

135
toxcore/Lossless_UDP.c
View File

@ -39,9 +39,9 @@
int getconnection_id(Lossless_UDP *ludp, IP_Port ip_port) int getconnection_id(Lossless_UDP *ludp, IP_Port ip_port)
{ {
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.ip_port.ip.i == ip_port.ip.i && if (tmp->ip_port.ip.i == ip_port.ip.i &&
tmp.ip_port.port == ip_port.port && tmp->ip_port.port == ip_port.port &&
tmp.status > 0) tmp->status > 0)
{ {
return tmp_i; return tmp_i;
} }
@ -87,20 +87,19 @@ static void change_handshake(Lossless_UDP *ludp, IP_Port source)
/* /*
* Initialize a new connection to ip_port * Initialize a new connection to ip_port
* Returns an integer corresponding to the connection idt * Returns an integer corresponding to the connection id.
* Return -1 if it could not initialize the connectiont * Return -1 if it could not initialize the connectiont
* If there already was an existing connection to that ip_port return its number. * If there already was an existing connection to that ip_port return its number.
*/ */
int new_connection(Lossless_UDP *ludp, IP_Port ip_port) int new_connection(Lossless_UDP *ludp, IP_Port ip_port)
{ {
int connect = getconnection_id(ludp, ip_port); int connection_id = getconnection_id(ludp, ip_port);
if (connect != -1) if (connection_id != -1)
return connect; return connection_id;
int connection_id = -1;
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.status == 0) { if (tmp->status == 0) {
connection_id = tmp_i; connection_id = tmp_i;
break; break;
} }
@ -145,11 +144,11 @@ int new_connection(Lossless_UDP *ludp, IP_Port ip_port)
static int new_inconnection(Lossless_UDP *ludp, IP_Port ip_port) static int new_inconnection(Lossless_UDP *ludp, IP_Port ip_port)
{ {
if (getconnection_id(ludp, ip_port) != -1) if (getconnection_id(ludp, ip_port) != -1)
return -1; return -1; /* TODO: return existing connection instead? */
int connection_id = -1; int connection_id = -1;
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.status == 0) { if (tmp->status == 0) {
connection_id = tmp_i; connection_id = tmp_i;
break; break;
} }
@ -191,12 +190,11 @@ static int new_inconnection(Lossless_UDP *ludp, IP_Port ip_port)
int incoming_connection(Lossless_UDP *ludp) int incoming_connection(Lossless_UDP *ludp)
{ {
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.inbound == 2) { if (tmp->inbound == 2) {
tmp.inbound = 1; tmp->inbound = 1;
return tmp_i; return tmp_i;
} }
} }
return -1; return -1;
} }
@ -206,9 +204,8 @@ int incoming_connection(Lossless_UDP *ludp)
*/ */
int kill_connection(Lossless_UDP *ludp, int connection_id) int kill_connection(Lossless_UDP *ludp, int connection_id)
{ {
Connection* connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (connection_id >= 0 && connection_id < ludp->connections.len) { if (connection_id >= 0 && connection_id < ludp->connections.len) {
Connection* connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (connection->status > 0) { if (connection->status > 0) {
connection->status = 0; connection->status = 0;
change_handshake(ludp, connection->ip_port); change_handshake(ludp, connection->ip_port);
@ -228,8 +225,9 @@ int kill_connection(Lossless_UDP *ludp, int connection_id)
int kill_connection_in(Lossless_UDP *ludp, int connection_id, uint32_t seconds) int kill_connection_in(Lossless_UDP *ludp, int connection_id, uint32_t seconds)
{ {
if (connection_id >= 0 && connection_id < ludp->connections.len) { if (connection_id >= 0 && connection_id < ludp->connections.len) {
if (tox_array_get(&ludp->connections, connection_id, Connection).status > 0) { Connection* connection = &tox_array_get(&ludp->connections, connection_id, Connection);
tox_array_get(&ludp->connections, connection_id, Connection).killat = current_time() + 1000000UL * seconds; if (connection->status > 0) {
connection->killat = current_time() + 1000000UL * seconds;
return 0; return 0;
} }
} }
@ -269,8 +267,8 @@ uint32_t sendqueue(Lossless_UDP *ludp, int connection_id)
if (connection_id < 0 || connection_id >= ludp->connections.len) if (connection_id < 0 || connection_id >= ludp->connections.len)
return 0; return 0;
return tox_array_get(&ludp->connections, connection_id, Connection).sendbuff_packetnum - Connection* connection = &tox_array_get(&ludp->connections, connection_id, Connection);
tox_array_get(&ludp->connections, connection_id, Connection).successful_sent; return connection->sendbuff_packetnum - connection->successful_sent;
} }
/* returns the number of packets in the queue waiting to be successfully read with read_packet(...) */ /* returns the number of packets in the queue waiting to be successfully read with read_packet(...) */
@ -279,19 +277,20 @@ uint32_t recvqueue(Lossless_UDP *ludp, int connection_id)
if (connection_id < 0 || connection_id >= ludp->connections.len) if (connection_id < 0 || connection_id >= ludp->connections.len)
return 0; return 0;
return tox_array_get(&ludp->connections, connection_id, Connection).recv_packetnum - tox_array_get(&ludp->connections, connection_id, Connection).successful_read; Connection* connection = &tox_array_get(&ludp->connections, connection_id, Connection);
return connection->recv_packetnum - connection->successful_read;
} }
/* returns the id of the next packet in the queue /* returns the id of the next packet in the queue
return -1 if no packet in queue */ return -1 if no packet in queue */
char id_packet(Lossless_UDP *ludp, int connection_id) char id_packet(Lossless_UDP *ludp, int connection_id)
{ {
if (connection_id < 0 || connection_id >= ludp->connections.len) if (connection_id < 0 || connection_id >= ludp->connections.len || recvqueue(ludp, connection_id) == 0)
return -1; return -1;
if (recvqueue(ludp, connection_id) != 0 && tox_array_get(&ludp->connections, connection_id, Connection).status != 0) Connection* connection = &tox_array_get(&ludp->connections, connection_id, Connection);
return tox_array_get(&ludp->connections, connection_id, Connection).recvbuffer[tox_array_get(&ludp->connections, connection_id, Connection).successful_read % if (connection->status != 0)
MAX_QUEUE_NUM].data[0]; return connection->recvbuffer[connection->successful_read % MAX_QUEUE_NUM].data[0];
return -1; return -1;
} }
@ -300,7 +299,9 @@ char id_packet(Lossless_UDP *ludp, int connection_id)
return length of received packet if successful */ return length of received packet if successful */
int read_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data) int read_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data)
{ {
if (recvqueue(ludp, connection_id) != 0) { if (recvqueue(ludp, connection_id) == 0)
return 0;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection); Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint16_t index = connection->successful_read % MAX_QUEUE_NUM; uint16_t index = connection->successful_read % MAX_QUEUE_NUM;
uint16_t size = connection->recvbuffer[index].size; uint16_t size = connection->recvbuffer[index].size;
@ -308,9 +309,7 @@ int read_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data)
++connection->successful_read; ++connection->successful_read;
connection->recvbuffer[index].size = 0; connection->recvbuffer[index].size = 0;
return size; return size;
}
return 0;
} }
/* /*
@ -319,10 +318,9 @@ int read_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data)
*/ */
int write_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data, uint32_t length) int write_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data, uint32_t length)
{ {
if (length > MAX_DATA_SIZE || length == 0) if (length > MAX_DATA_SIZE || length == 0 || sendqueue(ludp, connection_id) >= BUFFER_PACKET_NUM)
return 0; return 0;
if (sendqueue(ludp, connection_id) < BUFFER_PACKET_NUM) {
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection); Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint32_t index = connection->sendbuff_packetnum % MAX_QUEUE_NUM; uint32_t index = connection->sendbuff_packetnum % MAX_QUEUE_NUM;
memcpy(connection->sendbuffer[index].data, data, length); memcpy(connection->sendbuffer[index].data, data, length);
@ -331,20 +329,17 @@ int write_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data, uint32_t
return 1; return 1;
} }
return 0;
}
/* put the packet numbers the we are missing in requested and return the number */ /* put the packet numbers the we are missing in requested and return the number */
uint32_t missing_packets(Lossless_UDP *ludp, int connection_id, uint32_t *requested) uint32_t missing_packets(Lossless_UDP *ludp, int connection_id, uint32_t *requested)
{ {
uint32_t number = 0;
uint32_t i;
uint32_t temp;
/* don't request packets if the buffer is full. */ /* don't request packets if the buffer is full. */
if (recvqueue(ludp, connection_id) >= (BUFFER_PACKET_NUM - 1)) if (recvqueue(ludp, connection_id) >= (BUFFER_PACKET_NUM - 1))
return 0; return 0;
uint32_t number = 0;
uint32_t i;
uint32_t temp;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection); Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
for (i = connection->recv_packetnum; for (i = connection->recv_packetnum;
@ -387,7 +382,6 @@ static int send_handshake(Lossless_UDP *ludp, IP_Port ip_port, uint32_t handshak
static int send_SYNC(Lossless_UDP *ludp, int connection_id) static int send_SYNC(Lossless_UDP *ludp, int connection_id)
{ {
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection); Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint8_t packet[(BUFFER_PACKET_NUM * 4 + 4 + 4 + 2)]; uint8_t packet[(BUFFER_PACKET_NUM * 4 + 4 + 4 + 2)];
uint16_t index = 0; uint16_t index = 0;
@ -470,15 +464,14 @@ static int handle_handshake(void *object, IP_Port source, uint8_t *packet, uint3
uint32_t temp; uint32_t temp;
uint32_t handshake_id1, handshake_id2; uint32_t handshake_id1, handshake_id2;
int connection_id = getconnection_id(ludp, source); int connection_id = getconnection_id(ludp, source);
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
memcpy(&temp, packet + 1, 4); memcpy(&temp, packet + 1, 4);
handshake_id1 = ntohl(temp); handshake_id1 = ntohl(temp);
memcpy(&temp, packet + 5, 4); memcpy(&temp, packet + 5, 4);
handshake_id2 = ntohl(temp); handshake_id2 = ntohl(temp);
if (handshake_id2 == 0 && is_connected(ludp, connection_id) < 3) { if (handshake_id2 == 0 && is_connected(ludp, connection_id) < 3) {
send_handshake(ludp, source, handshake_id(ludp, source), handshake_id1); send_handshake(ludp, source, handshake_id(ludp, source), handshake_id1);
return 0; return 0;
@ -487,6 +480,7 @@ static int handle_handshake(void *object, IP_Port source, uint8_t *packet, uint3
if (is_connected(ludp, connection_id) != 1) if (is_connected(ludp, connection_id) != 1)
return 1; return 1;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
/* if handshake_id2 is what we sent previously as handshake_id1 */ /* if handshake_id2 is what we sent previously as handshake_id1 */
if (handshake_id2 == connection->handshake_id1) { if (handshake_id2 == connection->handshake_id1) {
connection->status = 2; connection->status = 2;
@ -519,9 +513,9 @@ static int handle_SYNC1(Lossless_UDP *ludp, IP_Port source, uint32_t recv_packet
{ {
if (handshake_id(ludp, source) == recv_packetnum) { if (handshake_id(ludp, source) == recv_packetnum) {
int connection_id = new_inconnection(ludp, source); int connection_id = new_inconnection(ludp, source);
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (connection_id != -1) { if (connection_id != -1) {
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
connection->orecv_packetnum = recv_packetnum; connection->orecv_packetnum = recv_packetnum;
connection->sent_packetnum = recv_packetnum; connection->sent_packetnum = recv_packetnum;
connection->sendbuff_packetnum = recv_packetnum; connection->sendbuff_packetnum = recv_packetnum;
@ -572,8 +566,8 @@ static int handle_SYNC3(Lossless_UDP *ludp, int connection_id, uint8_t counter,
/* packet valid */ /* packet valid */
if (comp_1 <= BUFFER_PACKET_NUM && if (comp_1 <= BUFFER_PACKET_NUM &&
comp_2 <= BUFFER_PACKET_NUM && comp_2 <= BUFFER_PACKET_NUM &&
comp_counter < 10 && comp_counter != 0) { comp_counter < 10 && comp_counter != 0)
{
connection->orecv_packetnum = recv_packetnum; connection->orecv_packetnum = recv_packetnum;
connection->osent_packetnum = sent_packetnum; connection->osent_packetnum = sent_packetnum;
connection->successful_sent = recv_packetnum; connection->successful_sent = recv_packetnum;
@ -638,11 +632,10 @@ static int handle_SYNC(void *object, IP_Port source, uint8_t *packet, uint32_t l
*/ */
static int add_recv(Lossless_UDP *ludp, int connection_id, uint32_t data_num, uint8_t *data, uint16_t size) static int add_recv(Lossless_UDP *ludp, int connection_id, uint32_t data_num, uint8_t *data, uint16_t size)
{ {
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (size > MAX_DATA_SIZE) if (size > MAX_DATA_SIZE)
return 1; return 1;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint32_t i; uint32_t i;
uint32_t maxnum = connection->successful_read + BUFFER_PACKET_NUM; uint32_t maxnum = connection->successful_read + BUFFER_PACKET_NUM;
uint32_t sent_packet = data_num - connection->osent_packetnum; uint32_t sent_packet = data_num - connection->osent_packetnum;
@ -654,9 +647,8 @@ static int add_recv(Lossless_UDP *ludp, int connection_id, uint32_t data_num, ui
connection->recvbuffer[i % MAX_QUEUE_NUM].size = size; connection->recvbuffer[i % MAX_QUEUE_NUM].size = size;
connection->last_recvdata = current_time(); connection->last_recvdata = current_time();
if (sent_packet < BUFFER_PACKET_NUM) { if (sent_packet < BUFFER_PACKET_NUM)
connection->osent_packetnum = data_num; connection->osent_packetnum = data_num;
}
break; break;
} }
@ -676,12 +668,9 @@ static int handle_data(void *object, IP_Port source, uint8_t *packet, uint32_t l
{ {
Lossless_UDP *ludp = object; Lossless_UDP *ludp = object;
int connection_id = getconnection_id(ludp, source); int connection_id = getconnection_id(ludp, source);
if (connection_id == -1)
return 1;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
/* Drop the data packet if connection is not connected. */ /* Drop the data packet if connection is not connected. */
if (connection->status != 3) if (connection_id == -1 || tox_array_get(&ludp->connections, connection_id, Connection).status != 3)
return 1; return 1;
if (length > 1 + 4 + MAX_DATA_SIZE || length < 1 + 4 + 1) if (length > 1 + 4 + MAX_DATA_SIZE || length < 1 + 4 + 1)
@ -728,19 +717,19 @@ static void do_new(Lossless_UDP *ludp)
uint64_t temp_time = current_time(); uint64_t temp_time = current_time();
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.status == 1) if (tmp->status == 1)
if ((tmp.last_sent + (1000000UL / tmp.SYNC_rate)) <= temp_time) { if ((tmp->last_sent + (1000000UL / tmp->SYNC_rate)) <= temp_time) {
send_handshake(ludp, tmp.ip_port, tmp.handshake_id1, 0); send_handshake(ludp, tmp->ip_port, tmp->handshake_id1, 0);
tmp.last_sent = temp_time; tmp->last_sent = temp_time;
} }
/* kill all timed out connections */ /* kill all timed out connections */
if (tmp.status > 0 && (tmp.last_recvSYNC + tmp.timeout * 1000000UL) < temp_time && tmp.status != 4) { if (tmp->status > 0 && (tmp->last_recvSYNC + tmp->timeout * 1000000UL) < temp_time && tmp->status != 4) {
tmp.status = 4; tmp->status = 4;
/* kill_connection(i); */ /* kill_connection(i); */
} }
if (tmp.status > 0 && tmp.killat < temp_time) if (tmp->status > 0 && tmp->killat < temp_time)
kill_connection(ludp, i); kill_connection(ludp, i);
} }
} }
@ -751,10 +740,10 @@ static void do_SYNC(Lossless_UDP *ludp)
uint64_t temp_time = current_time(); uint64_t temp_time = current_time();
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.status == 2 || tmp.status == 3) if (tmp->status == 2 || tmp->status == 3)
if ((tmp.last_SYNC + (1000000UL / tmp.SYNC_rate)) <= temp_time) { if ((tmp->last_SYNC + (1000000UL / tmp->SYNC_rate)) <= temp_time) {
send_SYNC(ludp, i); send_SYNC(ludp, i);
tmp.last_SYNC = temp_time; tmp->last_SYNC = temp_time;
} }
} }
} }
@ -766,13 +755,13 @@ static void do_data(Lossless_UDP *ludp)
uint64_t temp_time = current_time(); uint64_t temp_time = current_time();
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.status == 3 && sendqueue(ludp, i) != 0 && if (tmp->status == 3 && sendqueue(ludp, i) != 0 &&
(tmp.last_sent + (1000000UL / tmp.data_rate)) <= temp_time) (tmp->last_sent + (1000000UL / tmp->data_rate)) <= temp_time)
{ {
for (j = tmp.last_sent; j < temp_time; j += (1000000UL / tmp.data_rate)) for (j = tmp->last_sent; j < temp_time; j += (1000000UL / tmp->data_rate))
send_DATA(ludp, i); send_DATA(ludp, i);
tmp.last_sent = temp_time; tmp->last_sent = temp_time;
} }
} }
@ -791,17 +780,17 @@ static void adjust_rates(Lossless_UDP *ludp)
uint64_t temp_time = current_time(); uint64_t temp_time = current_time();
tox_array_for_each(&ludp->connections, Connection, tmp) { tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp.status == 1 || tmp.status == 2) if (tmp->status == 1 || tmp->status == 2)
tmp.SYNC_rate = MAX_SYNC_RATE; tmp->SYNC_rate = MAX_SYNC_RATE;
if (tmp.status == 3) { if (tmp->status == 3) {
if (sendqueue(ludp, i) != 0) { if (sendqueue(ludp, i) != 0) {
tmp.data_rate = (BUFFER_PACKET_NUM - tmp.num_req_paquets) * MAX_SYNC_RATE; tmp->data_rate = (BUFFER_PACKET_NUM - tmp->num_req_paquets) * MAX_SYNC_RATE;
tmp.SYNC_rate = MAX_SYNC_RATE; tmp->SYNC_rate = MAX_SYNC_RATE;
} else if (tmp.last_recvdata + 1000000UL > temp_time) } else if (tmp->last_recvdata + 1000000UL > temp_time)
tmp.SYNC_rate = MAX_SYNC_RATE; tmp->SYNC_rate = MAX_SYNC_RATE;
else else
tmp.SYNC_rate = SYNC_RATE; tmp->SYNC_rate = SYNC_RATE;
} }
} }
} }