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

Merge branch 'udp_connections' of https://github.com/vx-k/ProjectTox-Core into vx-k-udp_connections

Browse Source
This commit is contained in:
irungentoo 2013-08-30 07:53:51 -04:00
commit 7441a234b7
11 changed files with 340 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
other/DHT_bootstrap.c
View File

@ -29,7 +29,7 @@
#include "../toxcore/DHT.h"
#include "../toxcore/friend_requests.h"
#include "../testing/misc_tools.h"
#include "../toxcore/misc_tools.h"
/* Sleep function (x = milliseconds) */
#ifdef WIN32

3
other/Makefile.inc
View File

@ -3,8 +3,7 @@ noinst_PROGRAMS += DHT_bootstrap
DHT_bootstrap_SOURCES = $(top_srcdir)/other/DHT_bootstrap.c \
$(top_srcdir)/toxcore/DHT.h \
$(top_srcdir)/toxcore/friend_requests.h \
$(top_srcdir)/testing/misc_tools.h \
$(top_srcdir)/testing/misc_tools.c
$(top_srcdir)/toxcore/misc_tools.h
DHT_bootstrap_CFLAGS = -I$(top_srcdir)/other \
$(LIBSODIUM_CFLAGS)

17
testing/DHT_test.c
View File

@ -30,7 +30,7 @@
//#include "../core/network.h"
#include "../toxcore/DHT.h"
#include "../toxcore/friend_requests.h"
#include "misc_tools.h"
#include "../toxcore/misc_tools.h"
#include <string.h>
@ -62,11 +62,13 @@ void print_clientlist(DHT *dht)
}
p_ip = dht->close_clientlist[i].ip_port;
printf("\nIP: %u.%u.%u.%u Port: %u", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3], ntohs(p_ip.port));
printf("\nIP: %u.%u.%u.%u Port: %u", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3],
ntohs(p_ip.port));
printf("\nTimestamp: %llu", (long long unsigned int) dht->close_clientlist[i].timestamp);
printf("\nLast pinged: %llu\n", (long long unsigned int) dht->close_clientlist[i].last_pinged);
p_ip = dht->close_clientlist[i].ret_ip_port;
printf("OUR IP: %u.%u.%u.%u Port: %u\n", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3], ntohs(p_ip.port));
printf("OUR IP: %u.%u.%u.%u Port: %u\n", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3],
ntohs(p_ip.port));
printf("Timestamp: %llu\n", (long long unsigned int) dht->close_clientlist[i].ret_timestamp);
}
}
@ -86,7 +88,8 @@ void print_friendlist(DHT *dht)
}
p_ip = DHT_getfriendip(dht, dht->friends_list[k].client_id);
printf("\nIP: %u.%u.%u.%u:%u", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3], ntohs(p_ip.port));
printf("\nIP: %u.%u.%u.%u:%u", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3],
ntohs(p_ip.port));
printf("\nCLIENTS IN LIST:\n\n");
@ -101,11 +104,13 @@ void print_friendlist(DHT *dht)
}
p_ip = dht->friends_list[k].client_list[i].ip_port;
printf("\nIP: %u.%u.%u.%u:%u", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3], ntohs(p_ip.port));
printf("\nIP: %u.%u.%u.%u:%u", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3],
ntohs(p_ip.port));
printf("\nTimestamp: %llu", (long long unsigned int) dht->friends_list[k].client_list[i].timestamp);
printf("\nLast pinged: %llu\n", (long long unsigned int) dht->friends_list[k].client_list[i].last_pinged);
p_ip = dht->friends_list[k].client_list[i].ret_ip_port;
printf("ret IP: %u.%u.%u.%u:%u\n", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3], ntohs(p_ip.port));
printf("ret IP: %u.%u.%u.%u:%u\n", p_ip.ip.uint8[0], p_ip.ip.uint8[1], p_ip.ip.uint8[2], p_ip.ip.uint8[3],
ntohs(p_ip.port));
printf("Timestamp: %llu\n", (long long unsigned int)dht->friends_list[k].client_list[i].ret_timestamp);
}
}

12
testing/Makefile.inc
View File

@ -2,9 +2,7 @@ if BUILD_NTOX
bin_PROGRAMS += nTox
nTox_SOURCES = $(top_srcdir)/testing/misc_tools.h \
$(top_srcdir)/testing/misc_tools.c \
$(top_srcdir)/testing/nTox.h \
nTox_SOURCES = $(top_srcdir)/testing/nTox.h \
$(top_srcdir)/testing/nTox.c
nTox_CFLAGS = $(LIBSODIUM_CFLAGS) \
@ -24,9 +22,7 @@ noinst_PROGRAMS += DHT_test \
Messenger_test \
crypto_speed_test
DHT_test_SOURCES = $(top_srcdir)/testing/DHT_test.c \
$(top_srcdir)/testing/misc_tools.h \
$(top_srcdir)/testing/misc_tools.c
DHT_test_SOURCES = $(top_srcdir)/testing/DHT_test.c
DHT_test_CFLAGS = $(LIBSODIUM_CFLAGS)
@ -63,9 +59,7 @@ Lossless_UDP_testserver_LDADD = \
Messenger_test_SOURCES = \
$(top_srcdir)/testing/Messenger_test.c \
$(top_srcdir)/testing/misc_tools.h \
$(top_srcdir)/testing/misc_tools.c
$(top_srcdir)/testing/Messenger_test.c
Messenger_test_CFLAGS = $(LIBSODIUM_CFLAGS)

2
testing/Messenger_test.c
View File

@ -38,7 +38,7 @@
*/
#include "../toxcore/Messenger.h"
#include "misc_tools.h"
#include "../toxcore/misc_tools.h"
#ifdef WIN32

27
testing/nTox.c
View File

@ -21,24 +21,24 @@
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#include "config.h"
#endif
#ifdef __WIN32__
#define _WIN32_WINNT 0x501
#include <winsock2.h>
#include <ws2tcpip.h>
#define _WIN32_WINNT 0x501
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <netdb.h>
#endif
#include "nTox.h"
#include "misc_tools.h"
#include "../toxcore/misc_tools.h"
#include <stdio.h>
#include <time.h>
@ -93,10 +93,11 @@ uint32_t resolve_addr(const char *address)
WSADATA wsa_data;
res = WSAStartup(MAKEWORD(2, 2), &wsa_data);
if (res != 0)
{
if (res != 0) {
return 0;
}
#endif
rc = getaddrinfo(address, "echo", &hints, &server);
@ -123,7 +124,7 @@ uint32_t resolve_addr(const char *address)
freeaddrinfo(server);
#ifdef __WIN32__
WSACleanup();
WSACleanup();
#endif
return addr;
}

573
toxcore/Lossless_UDP.c
View File

@ -38,13 +38,12 @@
*/
int getconnection_id(Lossless_UDP *ludp, IP_Port ip_port)
{
uint32_t i;
for (i = 0; i < ludp->connections_length; ++i) {
if (ludp->connections[i].ip_port.ip.uint32 == ip_port.ip.uint32 &&
ludp->connections[i].ip_port.port == ip_port.port &&
ludp->connections[i].status > 0)
return i;
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->ip_port.ip.i == ip_port.ip.i &&
tmp->ip_port.port == ip_port.port &&
tmp->status > 0) {
return tmp_i;
}
}
return -1;
@ -87,61 +86,55 @@ static void change_handshake(Lossless_UDP *ludp, IP_Port source)
}
/*
* Initialize a new connection to ip_port.
* return an integer corresponding to the connection idt.
* return -1 if it could not initialize the connectiont
* Initialize a new connection to ip_port
* Returns an integer corresponding to the connection id.
* Return -1 if it could not initialize the connectiont
* 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 connect = getconnection_id(ludp, ip_port);
int connection_id = getconnection_id(ludp, ip_port);
if (connect != -1)
return connect;
if (connection_id != -1)
return connection_id;
if (ludp->connections_number == ludp->connections_length) {
Connection *temp;
temp = realloc(ludp->connections, sizeof(Connection) * (ludp->connections_length + 1));
if (temp == NULL)
return -1;
memset(&temp[ludp->connections_length], 0, sizeof(Connection));
++ludp->connections_length;
ludp->connections = temp;
}
uint32_t i;
for (i = 0; i < ludp->connections_length; ++i) {
if (ludp->connections[i].status == 0) {
memset(&ludp->connections[i], 0, sizeof(Connection));
uint32_t handshake_id1 = handshake_id(ludp, ip_port);
ludp->connections[i] = (Connection) {
.ip_port = ip_port,
.status = 1,
.inbound = 0,
.handshake_id1 = handshake_id1,
.sent_packetnum = handshake_id1,
.sendbuff_packetnum = handshake_id1,
.successful_sent = handshake_id1,
.SYNC_rate = SYNC_RATE,
.data_rate = DATA_SYNC_RATE,
.last_recvSYNC = current_time(),
.last_sent = current_time(),
.killat = ~0,
.send_counter = 0,
/* Add randomness to timeout to prevent connections getting stuck in a loop. */
.timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT
};
++ludp->connections_number;
return i;
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->status == 0) {
connection_id = tmp_i;
break;
}
}
return -1;
if (connection_id == -1) {
tox_array_push_ptr(&ludp->connections, 0); /* TODO: check return value */
connection_id = ludp->connections.len - 1;
}
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
memset(connection, 0, sizeof(Connection));
uint32_t handshake_id1 = handshake_id(ludp, ip_port);
*connection = (Connection) {
.ip_port = ip_port,
.status = 1,
.inbound = 0,
.handshake_id1 = handshake_id1,
.sent_packetnum = handshake_id1,
.sendbuff_packetnum = handshake_id1,
.successful_sent = handshake_id1,
.SYNC_rate = SYNC_RATE,
.data_rate = DATA_SYNC_RATE,
.last_recvSYNC = current_time(),
.last_sent = current_time(),
.killat = ~0,
.send_counter = 0,
/* add randomness to timeout to prevent connections getting stuck in a loop. */
.timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT
};
return connection_id;
}
/*
@ -152,49 +145,44 @@ int new_connection(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)
return -1;
return -1; /* TODO: return existing connection instead? */
if (ludp->connections_number == ludp->connections_length) {
Connection *temp;
temp = realloc(ludp->connections, sizeof(Connection) * (ludp->connections_length + 1));
if (temp == NULL)
return -1;
memset(&temp[ludp->connections_length], 0, sizeof(Connection));
++ludp->connections_length;
ludp->connections = temp;
}
uint32_t i;
for (i = 0; i < ludp->connections_length; ++i) {
if (ludp->connections[i].status == 0) {
memset(&ludp->connections[i], 0, sizeof(Connection));
uint64_t timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
ludp->connections[i] = (Connection) {
.ip_port = ip_port,
.status = 2,
.inbound = 2,
.SYNC_rate = SYNC_RATE,
.data_rate = DATA_SYNC_RATE,
.last_recvSYNC = current_time(),
.last_sent = current_time(),
.send_counter = 127,
/* Add randomness to timeout to prevent connections getting stuck in a loop. */
.timeout = timeout,
/* If this connection isn't handled within the timeout kill it. */
.killat = current_time() + 1000000UL * timeout
};
++ludp->connections_number;
return i;
int connection_id = -1;
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->status == 0) {
connection_id = tmp_i;
break;
}
}
return -1;
if (connection_id == -1) {
tox_array_push_ptr(&ludp->connections, 0); /* TODO: check return value */
connection_id = ludp->connections.len - 1;
}
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
memset(connection, 0, sizeof(Connection));
uint64_t timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
*connection = (Connection) {
.ip_port = ip_port,
.status = 2,
.inbound = 2,
.SYNC_rate = SYNC_RATE,
.data_rate = DATA_SYNC_RATE,
.last_recvSYNC = current_time(),
.last_sent = current_time(),
.send_counter = 127,
/* add randomness to timeout to prevent connections getting stuck in a loop. */
.timeout = timeout,
/* if this connection isn't handled within the timeout kill it. */
.killat = current_time() + 1000000UL * timeout
};
return connection_id;
}
/*
@ -203,59 +191,28 @@ static int new_inconnection(Lossless_UDP *ludp, IP_Port ip_port)
*/
int incoming_connection(Lossless_UDP *ludp)
{
uint32_t i;
for (i = 0; i < ludp->connections_length; ++i) {
if (ludp->connections[i].inbound == 2) {
ludp->connections[i].inbound = 1;
return i;
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->inbound == 2) {
tmp->inbound = 1;
return tmp_i;
}
}
return -1;
}
/* Try to free some memory from the connections array. */
static void free_connections(Lossless_UDP *ludp)
{
uint32_t i;
for (i = ludp->connections_length; i != 0; --i)
if (ludp->connections[i - 1].status != 0)
break;
if (ludp->connections_length == i)
return;
if (i == 0) {
free(ludp->connections);
ludp->connections = NULL;
ludp->connections_length = i;
return;
}
Connection *temp;
temp = realloc(ludp->connections, sizeof(Connection) * i);
if (temp == NULL && i != 0)
return;
ludp->connections = temp;
ludp->connections_length = i;
}
/*
* return -1 if it could not kill the connection.
* return 0 if killed successfully.
*/
int kill_connection(Lossless_UDP *ludp, int connection_id)
{
if (connection_id >= 0 && connection_id < ludp->connections_length) {
if (ludp->connections[connection_id].status > 0) {
ludp->connections[connection_id].status = 0;
change_handshake(ludp, ludp->connections[connection_id].ip_port);
--ludp->connections_number;
free_connections(ludp);
if (connection_id >= 0 && connection_id < ludp->connections.len) {
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (connection->status > 0) {
connection->status = 0;
change_handshake(ludp, connection->ip_port);
memset(connection, 0, sizeof(Connection));
return 0;
}
}
@ -270,9 +227,11 @@ int kill_connection(Lossless_UDP *ludp, int connection_id)
*/
int kill_connection_in(Lossless_UDP *ludp, int connection_id, uint32_t seconds)
{
if (connection_id >= 0 && connection_id < ludp->connections_length) {
if (ludp->connections[connection_id].status > 0) {
ludp->connections[connection_id].killat = current_time() + 1000000UL * seconds;
if (connection_id >= 0 && connection_id < ludp->connections.len) {
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (connection->status > 0) {
connection->killat = current_time() + 1000000UL * seconds;
return 0;
}
}
@ -290,8 +249,8 @@ int kill_connection_in(Lossless_UDP *ludp, int connection_id, uint32_t seconds)
*/
int is_connected(Lossless_UDP *ludp, int connection_id)
{
if (connection_id >= 0 && connection_id < ludp->connections_length)
return ludp->connections[connection_id].status;
if (connection_id >= 0 && connection_id < ludp->connections.len)
return tox_array_get(&ludp->connections, connection_id, Connection).status;
return 0;
}
@ -299,8 +258,8 @@ int is_connected(Lossless_UDP *ludp, int connection_id)
/* return the ip_port of the corresponding connection. */
IP_Port connection_ip(Lossless_UDP *ludp, int connection_id)
{
if (connection_id >= 0 && connection_id < ludp->connections_length)
return ludp->connections[connection_id].ip_port;
if (connection_id >= 0 && connection_id < ludp->connections.len)
return tox_array_get(&ludp->connections, connection_id, Connection).ip_port;
IP_Port zero = { .ip = {0}, .port = 0, .padding = 0 };
return zero;
@ -309,19 +268,21 @@ IP_Port connection_ip(Lossless_UDP *ludp, int connection_id)
/* returns the number of packets in the queue waiting to be successfully sent. */
uint32_t sendqueue(Lossless_UDP *ludp, int connection_id)
{
if (connection_id < 0 || connection_id >= ludp->connections_length)
if (connection_id < 0 || connection_id >= ludp->connections.len)
return 0;
return ludp->connections[connection_id].sendbuff_packetnum - ludp->connections[connection_id].successful_sent;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
return connection->sendbuff_packetnum - connection->successful_sent;
}
/* returns the number of packets in the queue waiting to be successfully read with read_packet(...). */
uint32_t recvqueue(Lossless_UDP *ludp, int connection_id)
{
if (connection_id < 0 || connection_id >= ludp->connections_length)
if (connection_id < 0 || connection_id >= ludp->connections.len)
return 0;
return ludp->connections[connection_id].recv_packetnum - ludp->connections[connection_id].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.
@ -329,12 +290,13 @@ uint32_t recvqueue(Lossless_UDP *ludp, int connection_id)
*/
char id_packet(Lossless_UDP *ludp, int connection_id)
{
if (connection_id < 0 || connection_id >= ludp->connections_length)
if (connection_id < 0 || connection_id >= ludp->connections.len || recvqueue(ludp, connection_id) == 0)
return -1;
if (recvqueue(ludp, connection_id) != 0 && ludp->connections[connection_id].status != 0)
return ludp->connections[connection_id].recvbuffer[ludp->connections[connection_id].successful_read %
MAX_QUEUE_NUM].data[0];
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (connection->status != 0)
return connection->recvbuffer[connection->successful_read % MAX_QUEUE_NUM].data[0];
return -1;
}
@ -344,16 +306,17 @@ char id_packet(Lossless_UDP *ludp, int connection_id)
*/
int read_packet(Lossless_UDP *ludp, int connection_id, uint8_t *data)
{
if (recvqueue(ludp, connection_id) != 0) {
uint16_t index = ludp->connections[connection_id].successful_read % MAX_QUEUE_NUM;
uint16_t size = ludp->connections[connection_id].recvbuffer[index].size;
memcpy(data, ludp->connections[connection_id].recvbuffer[index].data, size);
++ludp->connections[connection_id].successful_read;
ludp->connections[connection_id].recvbuffer[index].size = 0;
return size;
}
if (recvqueue(ludp, connection_id) == 0)
return 0;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint16_t index = connection->successful_read % MAX_QUEUE_NUM;
uint16_t size = connection->recvbuffer[index].size;
memcpy(data, connection->recvbuffer[index].data, size);
++connection->successful_read;
connection->recvbuffer[index].size = 0;
return size;
return 0;
}
/*
@ -362,33 +325,34 @@ 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)
{
if (length > MAX_DATA_SIZE || length == 0)
if (length > MAX_DATA_SIZE || length == 0 || sendqueue(ludp, connection_id) >= BUFFER_PACKET_NUM)
return 0;
if (sendqueue(ludp, connection_id) < BUFFER_PACKET_NUM) {
uint32_t index = ludp->connections[connection_id].sendbuff_packetnum % MAX_QUEUE_NUM;
memcpy(ludp->connections[connection_id].sendbuffer[index].data, data, length);
ludp->connections[connection_id].sendbuffer[index].size = length;
ludp->connections[connection_id].sendbuff_packetnum++;
return 1;
}
return 0;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint32_t index = connection->sendbuff_packetnum % MAX_QUEUE_NUM;
memcpy(connection->sendbuffer[index].data, data, length);
connection->sendbuffer[index].size = length;
connection->sendbuff_packetnum++;
return 1;
}
/* 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)
{
/* don't request packets if the buffer is full. */
if (recvqueue(ludp, connection_id) >= (BUFFER_PACKET_NUM - 1))
return 0;
uint32_t number = 0;
uint32_t i;
uint32_t temp;
/* Don't request packets if the buffer is full. */
if (recvqueue(ludp, connection_id) >= (BUFFER_PACKET_NUM - 1))
return 0;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
for (i = ludp->connections[connection_id].recv_packetnum; i != ludp->connections[connection_id].osent_packetnum; i++) {
if (ludp->connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size == 0) {
for (i = connection->recv_packetnum;
i != connection->osent_packetnum;
i++) {
if (connection->recvbuffer[i % MAX_QUEUE_NUM].size == 0) {
temp = htonl(i);
memcpy(requested + number, &temp, 4);
++number;
@ -396,7 +360,7 @@ uint32_t missing_packets(Lossless_UDP *ludp, int connection_id, uint32_t *reques
}
if (number == 0)
ludp->connections[connection_id].recv_packetnum = ludp->connections[connection_id].osent_packetnum;
connection->recv_packetnum = connection->osent_packetnum;
return number;
}
@ -421,15 +385,16 @@ static int send_handshake(Lossless_UDP *ludp, IP_Port ip_port, uint32_t handshak
return sendpacket(ludp->net->sock, ip_port, packet, sizeof(packet));
}
static int send_SYNC(Lossless_UDP *ludp, uint32_t connection_id)
static int send_SYNC(Lossless_UDP *ludp, int connection_id)
{
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint8_t packet[(BUFFER_PACKET_NUM * 4 + 4 + 4 + 2)];
uint16_t index = 0;
IP_Port ip_port = ludp->connections[connection_id].ip_port;
uint8_t counter = ludp->connections[connection_id].send_counter;
uint32_t recv_packetnum = htonl(ludp->connections[connection_id].recv_packetnum);
uint32_t sent_packetnum = htonl(ludp->connections[connection_id].sent_packetnum);
IP_Port ip_port = connection->ip_port;
uint8_t counter = connection->send_counter;
uint32_t recv_packetnum = htonl(connection->recv_packetnum);
uint32_t sent_packetnum = htonl(connection->sent_packetnum);
uint32_t requested[BUFFER_PACKET_NUM];
uint32_t number = missing_packets(ludp, connection_id, requested);
@ -448,37 +413,38 @@ static int send_SYNC(Lossless_UDP *ludp, uint32_t connection_id)
}
static int send_data_packet(Lossless_UDP *ludp, uint32_t connection_id, uint32_t packet_num)
static int send_data_packet(Lossless_UDP *ludp, int connection_id, uint32_t packet_num)
{
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint32_t index = packet_num % MAX_QUEUE_NUM;
uint32_t temp;
uint8_t packet[1 + 4 + MAX_DATA_SIZE];
packet[0] = NET_PACKET_DATA;
temp = htonl(packet_num);
memcpy(packet + 1, &temp, 4);
memcpy(packet + 5, ludp->connections[connection_id].sendbuffer[index].data,
ludp->connections[connection_id].sendbuffer[index].size);
return sendpacket(ludp->net->sock, ludp->connections[connection_id].ip_port, packet,
1 + 4 + ludp->connections[connection_id].sendbuffer[index].size);
memcpy(packet + 5, connection->sendbuffer[index].data, connection->sendbuffer[index].size);
return sendpacket(ludp->net->sock, connection->ip_port, packet, 1 + 4 + connection->sendbuffer[index].size);
}
/* Sends 1 data packet. */
static int send_DATA(Lossless_UDP *ludp, uint32_t connection_id)
/* sends 1 data packet */
static int send_DATA(Lossless_UDP *ludp, int connection_id)
{
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
int ret;
uint32_t buffer[BUFFER_PACKET_NUM];
if (ludp->connections[connection_id].num_req_paquets > 0) {
ret = send_data_packet(ludp, connection_id, ludp->connections[connection_id].req_packets[0]);
ludp->connections[connection_id].num_req_paquets--;
memcpy(buffer, ludp->connections[connection_id].req_packets + 1, ludp->connections[connection_id].num_req_paquets * 4);
memcpy(ludp->connections[connection_id].req_packets, buffer, ludp->connections[connection_id].num_req_paquets * 4);
if (connection->num_req_paquets > 0) {
ret = send_data_packet(ludp, connection_id, connection->req_packets[0]);
connection->num_req_paquets--;
memcpy(buffer, connection->req_packets + 1, connection->num_req_paquets * 4);
memcpy(connection->req_packets, buffer, connection->num_req_paquets * 4);
return ret;
}
if (ludp->connections[connection_id].sendbuff_packetnum != ludp->connections[connection_id].sent_packetnum) {
ret = send_data_packet(ludp, connection_id, ludp->connections[connection_id].sent_packetnum);
ludp->connections[connection_id].sent_packetnum++;
if (connection->sendbuff_packetnum != connection->sent_packetnum) {
ret = send_data_packet(ludp, connection_id, connection->sent_packetnum);
connection->sent_packetnum++;
return ret;
}
@ -506,31 +472,33 @@ static int handle_handshake(void *object, IP_Port source, uint8_t *packet, uint3
uint32_t temp;
uint32_t handshake_id1, handshake_id2;
int connection_id = getconnection_id(ludp, source);
int connection = getconnection_id(ludp, source);
memcpy(&temp, packet + 1, 4);
handshake_id1 = ntohl(temp);
memcpy(&temp, packet + 5, 4);
handshake_id2 = ntohl(temp);
if (handshake_id2 == 0 && is_connected(ludp, connection) < 3) {
if (handshake_id2 == 0 && is_connected(ludp, connection_id) < 3) {
send_handshake(ludp, source, handshake_id(ludp, source), handshake_id1);
return 0;
}
if (is_connected(ludp, connection) != 1)
if (is_connected(ludp, connection_id) != 1)
return 1;
/* If handshake_id2 is what we sent previously as handshake_id1. */
if (handshake_id2 == ludp->connections[connection].handshake_id1) {
ludp->connections[connection].status = 2;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
/* if handshake_id2 is what we sent previously as handshake_id1 */
if (handshake_id2 == connection->handshake_id1) {
connection->status = 2;
/* NOTE: is this necessary?
* ludp->connections[connection].handshake_id2 = handshake_id1;
*/
ludp->connections[connection].orecv_packetnum = handshake_id2;
ludp->connections[connection].osent_packetnum = handshake_id1;
ludp->connections[connection].recv_packetnum = handshake_id1;
ludp->connections[connection].successful_read = handshake_id1;
connection->handshake_id2 = handshake_id1; */
connection->orecv_packetnum = handshake_id2;
connection->osent_packetnum = handshake_id1;
connection->recv_packetnum = handshake_id1;
connection->successful_read = handshake_id1;
}
return 0;
@ -553,18 +521,19 @@ static int SYNC_valid(uint32_t length)
static int handle_SYNC1(Lossless_UDP *ludp, IP_Port source, uint32_t recv_packetnum, uint32_t sent_packetnum)
{
if (handshake_id(ludp, source) == recv_packetnum) {
int x = new_inconnection(ludp, source);
int connection_id = new_inconnection(ludp, source);
if (x != -1) {
ludp->connections[x].orecv_packetnum = recv_packetnum;
ludp->connections[x].sent_packetnum = recv_packetnum;
ludp->connections[x].sendbuff_packetnum = recv_packetnum;
ludp->connections[x].successful_sent = recv_packetnum;
ludp->connections[x].osent_packetnum = sent_packetnum;
ludp->connections[x].recv_packetnum = sent_packetnum;
ludp->connections[x].successful_read = sent_packetnum;
if (connection_id != -1) {
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
connection->orecv_packetnum = recv_packetnum;
connection->sent_packetnum = recv_packetnum;
connection->sendbuff_packetnum = recv_packetnum;
connection->successful_sent = recv_packetnum;
connection->osent_packetnum = sent_packetnum;
connection->recv_packetnum = sent_packetnum;
connection->successful_read = sent_packetnum;
return x;
return connection_id;
}
}
@ -575,11 +544,13 @@ static int handle_SYNC1(Lossless_UDP *ludp, IP_Port source, uint32_t recv_packet
static int handle_SYNC2(Lossless_UDP *ludp, int connection_id, uint8_t counter, uint32_t recv_packetnum,
uint32_t sent_packetnum)
{
if (recv_packetnum == ludp->connections[connection_id].orecv_packetnum) {
/* && sent_packetnum == ludp->connections[connection_id].osent_packetnum) */
ludp->connections[connection_id].status = 3;
ludp->connections[connection_id].recv_counter = counter;
++ludp->connections[connection_id].send_counter;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (recv_packetnum == connection->orecv_packetnum) {
/* && sent_packetnum == connection->osent_packetnum) */
connection->status = 3;
connection->recv_counter = counter;
++connection->send_counter;
send_SYNC(ludp, connection_id);
return 0;
}
@ -589,35 +560,36 @@ static int handle_SYNC2(Lossless_UDP *ludp, int connection_id, uint8_t counter,
/* case 3 in handle_SYNC: */
static int handle_SYNC3(Lossless_UDP *ludp, int connection_id, uint8_t counter, uint32_t recv_packetnum,
uint32_t sent_packetnum,
uint32_t *req_packets,
uint32_t *req_packets,
uint16_t number)
{
uint8_t comp_counter = (counter - ludp->connections[connection_id].recv_counter );
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint8_t comp_counter = (counter - connection->recv_counter);
uint32_t i, temp;
/* uint32_t comp_1 = (recv_packetnum - ludp->connections[connection_id].successful_sent);
uint32_t comp_2 = (sent_packetnum - ludp->connections[connection_id].successful_read); */
uint32_t comp_1 = (recv_packetnum - ludp->connections[connection_id].orecv_packetnum);
uint32_t comp_2 = (sent_packetnum - ludp->connections[connection_id].osent_packetnum);
/* uint32_t comp_1 = (recv_packetnum - connection->successful_sent);
uint32_t comp_2 = (sent_packetnum - connection->successful_read); */
uint32_t comp_1 = (recv_packetnum - connection->orecv_packetnum);
uint32_t comp_2 = (sent_packetnum - connection->osent_packetnum);
/* Packet valid. */
if (comp_1 <= BUFFER_PACKET_NUM &&
comp_2 <= BUFFER_PACKET_NUM &&
comp_counter < 10 && comp_counter != 0) {
connection->orecv_packetnum = recv_packetnum;
connection->osent_packetnum = sent_packetnum;
connection->successful_sent = recv_packetnum;
connection->last_recvSYNC = current_time();
connection->recv_counter = counter;
ludp->connections[connection_id].orecv_packetnum = recv_packetnum;
ludp->connections[connection_id].osent_packetnum = sent_packetnum;
ludp->connections[connection_id].successful_sent = recv_packetnum;
ludp->connections[connection_id].last_recvSYNC = current_time();
ludp->connections[connection_id].recv_counter = counter;
++ludp->connections[connection_id].send_counter;
++connection->send_counter;
for (i = 0; i < number; ++i) {
temp = ntohl(req_packets[i]);
memcpy(ludp->connections[connection_id].req_packets + i, &temp, 4 * number);
memcpy(connection->req_packets + i, &temp, 4 * number);
}
ludp->connections[connection_id].num_req_paquets = number;
connection->num_req_paquets = number;
return 0;
}
@ -631,7 +603,6 @@ static int handle_SYNC(void *object, IP_Port source, uint8_t *packet, uint32_t l
if (!SYNC_valid(length))
return 1;
int connection = getconnection_id(ludp, source);
uint8_t counter;
uint32_t temp;
uint32_t recv_packetnum, sent_packetnum;
@ -641,21 +612,25 @@ static int handle_SYNC(void *object, IP_Port source, uint8_t *packet, uint32_t l
memcpy(&counter, packet + 1, 1);
memcpy(&temp, packet + 2, 4);
recv_packetnum = ntohl(temp);
memcpy(&temp, packet + 6, 4);
memcpy(&temp, packet + 6, 4);
sent_packetnum = ntohl(temp);
if (number != 0)
memcpy(req_packets, packet + 10, 4 * number);
memcpy(req_packets, packet + 10, 4 * number);
if (connection == -1)
int connection_id = getconnection_id(ludp, source);
if (connection_id == -1)
return handle_SYNC1(ludp, source, recv_packetnum, sent_packetnum);
if (ludp->connections[connection].status == 2)
return handle_SYNC2(ludp, connection, counter,
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
if (connection->status == 2)
return handle_SYNC2(ludp, connection_id, counter,
recv_packetnum, sent_packetnum);
if (ludp->connections[connection].status == 3)
return handle_SYNC3(ludp, connection, counter, recv_packetnum,
if (connection->status == 3)
return handle_SYNC3(ludp, connection_id, counter, recv_packetnum,
sent_packetnum, req_packets, number);
return 0;
@ -672,28 +647,28 @@ static int add_recv(Lossless_UDP *ludp, int connection_id, uint32_t data_num, ui
if (size > MAX_DATA_SIZE)
return 1;
Connection *connection = &tox_array_get(&ludp->connections, connection_id, Connection);
uint32_t i;
uint32_t maxnum = ludp->connections[connection_id].successful_read + BUFFER_PACKET_NUM;
uint32_t sent_packet = data_num - ludp->connections[connection_id].osent_packetnum;
uint32_t maxnum = connection->successful_read + BUFFER_PACKET_NUM;
uint32_t sent_packet = data_num - connection->osent_packetnum;
for (i = ludp->connections[connection_id].recv_packetnum; i != maxnum; ++i) {
for (i = connection->recv_packetnum; i != maxnum; ++i) {
if (i == data_num) {
memcpy(ludp->connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].data, data, size);
memcpy(connection->recvbuffer[i % MAX_QUEUE_NUM].data, data, size);
ludp->connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size = size;
ludp->connections[connection_id].last_recvdata = current_time();
connection->recvbuffer[i % MAX_QUEUE_NUM].size = size;
connection->last_recvdata = current_time();
if (sent_packet < BUFFER_PACKET_NUM) {
ludp->connections[connection_id].osent_packetnum = data_num;
}
if (sent_packet < BUFFER_PACKET_NUM)
connection->osent_packetnum = data_num;
break;
}
}
for (i = ludp->connections[connection_id].recv_packetnum; i != maxnum; ++i) {
if (ludp->connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size != 0)
ludp->connections[connection_id].recv_packetnum = i;
for (i = connection->recv_packetnum; i != maxnum; ++i) {
if (connection->recvbuffer[i % MAX_QUEUE_NUM].size != 0)
connection->recv_packetnum = i;
else
break;
}
@ -704,13 +679,10 @@ static int add_recv(Lossless_UDP *ludp, int connection_id, uint32_t data_num, ui
static int handle_data(void *object, IP_Port source, uint8_t *packet, uint32_t length)
{
Lossless_UDP *ludp = object;
int connection = getconnection_id(ludp, source);
if (connection == -1)
return 1;
int connection_id = getconnection_id(ludp, source);
/* Drop the data packet if connection is not connected. */
if (ludp->connections[connection].status != 3)
if (connection_id == -1 || tox_array_get(&ludp->connections, connection_id, Connection).status != 3)
return 1;
if (length > 1 + 4 + MAX_DATA_SIZE || length < 1 + 4 + 1)
@ -723,7 +695,7 @@ static int handle_data(void *object, IP_Port source, uint8_t *packet, uint32_t l
memcpy(&temp, packet + 1, 4);
number = ntohl(temp);
return add_recv(ludp, connection, number, packet + 5, size);
return add_recv(ludp, connection_id, number, packet + 5, size);
}
/*
@ -740,6 +712,8 @@ Lossless_UDP *new_lossless_udp(Networking_Core *net)
if (temp == NULL)
return NULL;
tox_array_init(&temp->connections, sizeof(Connection));
temp->net = net;
networking_registerhandler(net, NET_PACKET_HANDSHAKE, &handle_handshake, temp);
networking_registerhandler(net, NET_PACKET_SYNC, &handle_SYNC, temp);
@ -753,57 +727,53 @@ Lossless_UDP *new_lossless_udp(Networking_Core *net)
*/
static void do_new(Lossless_UDP *ludp)
{
uint32_t i;
uint64_t temp_time = current_time();
for (i = 0; i < ludp->connections_length; ++i) {
if (ludp->connections[i].status == 1)
if ((ludp->connections[i].last_sent + (1000000UL / ludp->connections[i].SYNC_rate)) <= temp_time) {
send_handshake(ludp, ludp->connections[i].ip_port, ludp->connections[i].handshake_id1, 0);
ludp->connections[i].last_sent = temp_time;
}
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->status == 1 && (tmp->last_sent + (1000000UL / tmp->SYNC_rate)) <= temp_time) {
send_handshake(ludp, tmp->ip_port, tmp->handshake_id1, 0);
tmp->last_sent = temp_time;
}
/* Kill all timed out connections. */
if (ludp->connections[i].status > 0 &&
(ludp->connections[i].last_recvSYNC + ludp->connections[i].timeout * 1000000UL) < temp_time &&
ludp->connections[i].status != 4) {
ludp->connections[i].status = 4;
/* kill all timed out connections */
if (tmp->status > 0 && (tmp->last_recvSYNC + tmp->timeout * 1000000UL) < temp_time && tmp->status != 4) {
tmp->status = 4;
/* kill_connection(i); */
}
if (ludp->connections[i].status > 0 && ludp->connections[i].killat < temp_time)
kill_connection(ludp, i);
if (tmp->status > 0 && tmp->killat < temp_time)
kill_connection(ludp, tmp_i);
}
}
static void do_SYNC(Lossless_UDP *ludp)
{
uint32_t i;
uint64_t temp_time = current_time();
for (i = 0; i < ludp->connections_length; ++i) {
if (ludp->connections[i].status == 2 || ludp->connections[i].status == 3)
if ((ludp->connections[i].last_SYNC + (1000000UL / ludp->connections[i].SYNC_rate)) <= temp_time) {
send_SYNC(ludp, i);
ludp->connections[i].last_SYNC = temp_time;
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->status == 2 || tmp->status == 3)
if ((tmp->last_SYNC + (1000000UL / tmp->SYNC_rate)) <= temp_time) {
send_SYNC(ludp, tmp_i);
tmp->last_SYNC = temp_time;
}
}
}
static void do_data(Lossless_UDP *ludp)
{
uint32_t i;
uint64_t j;
uint64_t temp_time = current_time();
for (i = 0; i < ludp->connections_length; ++i)
if (ludp->connections[i].status == 3 && sendqueue(ludp, i) != 0)
if ((ludp->connections[i].last_sent + (1000000UL / ludp->connections[i].data_rate)) <= temp_time) {
for (j = ludp->connections[i].last_sent; j < temp_time; j += (1000000UL / ludp->connections[i].data_rate))
send_DATA(ludp, i);
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->status == 3 && sendqueue(ludp, tmp_i) != 0 &&
(tmp->last_sent + (1000000UL / tmp->data_rate)) <= temp_time) {
for (j = tmp->last_sent; j < temp_time; j += (1000000UL / tmp->data_rate))
send_DATA(ludp, tmp_i);
ludp->connections[i].last_sent = temp_time;
}
tmp->last_sent = temp_time;
}
}
}
#define MAX_SYNC_RATE 10
@ -815,21 +785,20 @@ static void do_data(Lossless_UDP *ludp)
*/
static void adjust_rates(Lossless_UDP *ludp)
{
uint32_t i;
uint64_t temp_time = current_time();
for (i = 0; i < ludp->connections_length; ++i) {
if (ludp->connections[i].status == 1 || ludp->connections[i].status == 2)
ludp->connections[i].SYNC_rate = MAX_SYNC_RATE;
tox_array_for_each(&ludp->connections, Connection, tmp) {
if (tmp->status == 1 || tmp->status == 2)
tmp->SYNC_rate = MAX_SYNC_RATE;
if (ludp->connections[i].status == 3) {
if (sendqueue(ludp, i) != 0) {
ludp->connections[i].data_rate = (BUFFER_PACKET_NUM - ludp->connections[i].num_req_paquets) * MAX_SYNC_RATE;
ludp->connections[i].SYNC_rate = MAX_SYNC_RATE;
} else if (ludp->connections[i].last_recvdata + 1000000UL > temp_time)
ludp->connections[i].SYNC_rate = MAX_SYNC_RATE;
if (tmp->status == 3) {
if (sendqueue(ludp, tmp_i) != 0) {
tmp->data_rate = (BUFFER_PACKET_NUM - tmp->num_req_paquets) * MAX_SYNC_RATE;
tmp->SYNC_rate = MAX_SYNC_RATE;
} else if (tmp->last_recvdata + 1000000UL > temp_time)
tmp->SYNC_rate = MAX_SYNC_RATE;
else
ludp->connections[i].SYNC_rate = SYNC_RATE;
tmp->SYNC_rate = SYNC_RATE;
}
}
}
@ -845,6 +814,6 @@ void do_lossless_udp(Lossless_UDP *ludp)
void kill_lossless_udp(Lossless_UDP *ludp)
{
free(ludp->connections);
tox_array_delete(&ludp->connections);
free(ludp);
}

5
toxcore/Lossless_UDP.h
View File

@ -25,6 +25,7 @@
#define LOSSLESS_UDP_H
#include "network.h"
#include "misc_tools.h"
/* Maximum length of the data in the data packets. */
@ -118,10 +119,8 @@ typedef struct {
typedef struct {
Networking_Core *net;
Connection *connections;
uint32_t connections_length; /* Length of connections array. */
uint32_t connections_number; /* Number of connections in connections array. */
tox_array connections;
/* Table of random numbers used in handshake_id. */
uint32_t randtable[6][256];

4
toxcore/Makefile.inc
View File

@ -24,7 +24,9 @@ libtoxcore_la_SOURCES = $(top_srcdir)/toxcore/DHT.h \
$(top_srcdir)/toxcore/tox.h \
$(top_srcdir)/toxcore/tox.c \
$(top_srcdir)/toxcore/util.h \
$(top_srcdir)/toxcore/util.c
$(top_srcdir)/toxcore/util.c \
$(top_srcdir)/toxcore/misc_tools.h \
$(top_srcdir)/toxcore/misc_tools.c
libtoxcore_la_CFLAGS = -I$(top_srcdir) \
-I$(top_srcdir)/toxcore \

0
testing/misc_tools.c → toxcore/misc_tools.c
View File

53
testing/misc_tools.h → toxcore/misc_tools.h
View File

@ -34,36 +34,36 @@ unsigned char *hex_string_to_bin(char hex_string[]);
* wiki.tox.im/index.php/Internal_functions_and_data_structures#Debugging
*********************************************************/
#ifdef DEBUG
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#define DEBUG_PRINT(str, ...) do { \
#define DEBUG_PRINT(str, ...) do { \
char msg[1000]; \
sprintf(msg, "%s(): line %d (file %s): %s%%c\n", __FUNCTION__, __LINE__, __FILE__, str); \
fprintf(stderr, msg, __VA_ARGS__); \
} while (0)
#define WARNING(...) do { \
#define WARNING(...) do { \
fprintf(stderr, "warning in "); \
DEBUG_PRINT(__VA_ARGS__, ' '); \
} while (0)
#define INFO(...) do { \
#define INFO(...) do { \
DEBUG_PRINT(__VA_ARGS__, ' '); \
} while (0)
#undef ERROR
#define ERROR(exit_status, ...) do { \
#undef ERROR
#define ERROR(exit_status, ...) do { \
fprintf(stderr, "error in "); \
DEBUG_PRINT(__VA_ARGS__, ' '); \
exit(exit_status); \
} while (0)
#else
#define WARNING(...)
#define INFO(...)
#undef ERROR
#define ERROR(...)
#define WARNING(...)
#define INFO(...)
#undef ERROR
#define ERROR(...)
#endif // DEBUG
/************************Linked List***********************
@ -117,7 +117,7 @@ static inline void tox_list_remove(tox_list *lst)
************************************************************/
typedef struct tox_array {
void *data;
uint8_t *data; /* last elem is data[len-1] */
uint32_t len;
size_t elem_size; /* in bytes */
} tox_array;
@ -135,24 +135,37 @@ static inline void tox_array_delete(tox_array *arr)
arr->len = arr->elem_size = 0;
}
static inline void _tox_array_push(tox_array *arr, uint8_t *item)
static inline uint8_t tox_array_push_ptr(tox_array *arr, uint8_t *item)
{
arr->data = realloc(arr->data, arr->elem_size * (arr->len+1));
arr->data = realloc(arr->data, arr->elem_size * (arr->len + 1));
if (item != NULL)
memcpy(arr->data + arr->elem_size * arr->len, item, arr->elem_size);
memcpy(arr->data + arr->elem_size*arr->len, item, arr->elem_size);
arr->len++;
return 1;
}
#define tox_array_push(arr, item) _tox_array_push(arr, (void*)(&(item)))
#define tox_array_push(arr, item) tox_array_push_ptr(arr, (uint8_t*)(&(item)))
/* Deletes num items from array.
* Not same as pop in stacks, because to access elements you use data.
*/
static inline void tox_array_pop(tox_array *arr, uint32_t num)
{
arr->len--;
arr->data = realloc(arr->data, arr->elem_size*arr->len);
if (num == 0)
num = 1;
arr->len -= num;
arr->data = realloc(arr->data, arr->elem_size * arr->len);
}
#define tox_array_get(arr, i, type) ((type*)(arr)->data)[i]
/* TODO: return ptr and do not take type */
#define tox_array_get(arr, i, type) (((type*)(arr)->data)[i])
#define tox_array_for_each(arr, type, tmp_name) \
type *tmp_name = &tox_array_get(arr, 0, type); uint32_t tmp_name ## _i = 0; \
for (; tmp_name ## _i < (arr)->len; tmp_name = &tox_array_get(arr, ++ tmp_name ## _i, type))
#endif // MISC_TOOLS_H