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

Add a monolith_test that includes all toxcore sources.

Browse Source 
This requires that every symbol, even if static (file-scope), is unique.
The idea is that we can easily run "whole" program static analysis on
programs that include monolith.h ("whole" is in quotes, as we don't
include dependencies like libsodium in this static analysis).
This commit is contained in:
iphydf 2017-06-04 12:59:34 +00:00
parent 03f99bde2e
commit 1e8fa85aad
No known key found for this signature in database
GPG Key ID: 3855DBA2D74403C9
12 changed files with 172 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
CMakeLists.txt
View File

@ -149,7 +149,7 @@ option(BUILD_TOXAV "Whether to build the tox AV library" ON)
include(Dependencies)
if (BUILD_TOXAV)
if(BUILD_TOXAV)
if(NOT OPUS_FOUND)
message(SEND_ERROR "Option BUILD_TOXAV is enabled but required library OPUS was not found.")
endif()
@ -395,6 +395,16 @@ function(auto_test target)
endif()
endfunction()
if(BUILD_TOXAV)
add_c_executable(auto_monolith_test auto_tests/monolith_test.c)
target_link_modules(auto_monolith_test
${toxcore_PKGCONFIG_LIBS}
${LIBSODIUM_LIBRARIES}
${OPUS_LIBRARIES}
${VPX_LIBRARIES})
add_test(NAME monolith COMMAND auto_monolith_test)
endif()
auto_test(TCP)
auto_test(conference)
auto_test(crypto)

15
auto_tests/monolith_test.c Normal file
View File

@ -0,0 +1,15 @@
/* Auto Tests: One instance.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _DARWIN_C_SOURCE
#define _XOPEN_SOURCE 600
#include "../other/monolith.h"
int main(int argc, char *argv[])
{
return 0;
}

36
other/monolith.h Normal file
View File

@ -0,0 +1,36 @@
#include "../toxcore/tox.c"
#include "../toxcore/crypto_core.c"
#include "../toxcore/crypto_core_mem.c"
#include "../toxcore/DHT.c"
#include "../toxcore/friend_connection.c"
#include "../toxcore/friend_requests.c"
#include "../toxcore/group.c"
#include "../toxcore/LAN_discovery.c"
#include "../toxcore/list.c"
#include "../toxcore/logger.c"
#include "../toxcore/Messenger.c"
#include "../toxcore/net_crypto.c"
#include "../toxcore/network.c"
#include "../toxcore/onion_announce.c"
#include "../toxcore/onion.c"
#include "../toxcore/onion_client.c"
#include "../toxcore/ping_array.c"
#include "../toxcore/ping.c"
#include "../toxcore/TCP_client.c"
#include "../toxcore/TCP_connection.c"
#include "../toxcore/TCP_server.c"
#include "../toxcore/tox_api.c"
#include "../toxcore/util.c"
#include "../toxav/audio.c"
#include "../toxav/bwcontroller.c"
#include "../toxav/groupav.c"
#include "../toxav/msi.c"
#include "../toxav/ring_buffer.c"
#include "../toxav/rtp.c"
#include "../toxav/toxav.c"
#include "../toxav/toxav_old.c"
#include "../toxav/video.c"
#include "../toxencryptsave/toxencryptsave.c"

6
toxav/toxav_old.c
View File

@ -35,7 +35,7 @@
*
* Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
*/
int toxav_add_av_groupchat(struct Tox *tox, void (*audio_callback)(void *, int, int, const int16_t *, unsigned int,
int toxav_add_av_groupchat(Tox *tox, void (*audio_callback)(void *, int, int, const int16_t *, unsigned int,
uint8_t, unsigned int, void *), void *userdata)
{
Messenger *m = (Messenger *)tox;
@ -54,7 +54,7 @@ int toxav_add_av_groupchat(struct Tox *tox, void (*audio_callback)(void *, int,
*
* Note that total size of pcm in bytes is equal to (samples * channels * sizeof(int16_t)).
*/
int toxav_join_av_groupchat(struct Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length,
int toxav_join_av_groupchat(Tox *tox, int32_t friendnumber, const uint8_t *data, uint16_t length,
void (*audio_callback)(void *, int, int, const int16_t *, unsigned int, uint8_t, unsigned int, void *),
void *userdata)
{
@ -77,7 +77,7 @@ int toxav_join_av_groupchat(struct Tox *tox, int32_t friendnumber, const uint8_t
*
* Recommended values are: samples = 960, channels = 1, sample_rate = 48000
*/
int toxav_group_send_audio(struct Tox *tox, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
int toxav_group_send_audio(Tox *tox, int groupnumber, const int16_t *pcm, unsigned int samples, uint8_t channels,
unsigned int sample_rate)
{
Messenger *m = (Messenger *)tox;

18
toxcore/DHT.c
View File

@ -798,13 +798,13 @@ int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *node
typedef struct {
const uint8_t *base_public_key;
Client_data entry;
} Cmp_data;
} DHT_Cmp_data;
static int cmp_dht_entry(const void *a, const void *b)
{
Cmp_data cmp1, cmp2;
memcpy(&cmp1, a, sizeof(Cmp_data));
memcpy(&cmp2, b, sizeof(Cmp_data));
DHT_Cmp_data cmp1, cmp2;
memcpy(&cmp1, a, sizeof(DHT_Cmp_data));
memcpy(&cmp2, b, sizeof(DHT_Cmp_data));
Client_data entry1 = cmp1.entry;
Client_data entry2 = cmp2.entry;
const uint8_t *cmp_public_key = cmp1.base_public_key;
@ -871,14 +871,14 @@ static void sort_client_list(Client_data *list, unsigned int length, const uint8
{
// Pass comp_public_key to qsort with each Client_data entry, so the
// comparison function can use it as the base of comparison.
VLA(Cmp_data, cmp_list, length);
VLA(DHT_Cmp_data, cmp_list, length);
for (uint32_t i = 0; i < length; i++) {
cmp_list[i].base_public_key = comp_public_key;
cmp_list[i].entry = list[i];
}
qsort(cmp_list, length, sizeof(Cmp_data), cmp_dht_entry);
qsort(cmp_list, length, sizeof(DHT_Cmp_data), cmp_dht_entry);
for (uint32_t i = 0; i < length; i++) {
list[i] = cmp_list[i].entry;
@ -2736,7 +2736,7 @@ uint32_t DHT_size(const DHT *dht)
return size32 + sizesubhead + (packed_node_size(AF_INET) * numv4) + (packed_node_size(AF_INET6) * numv6);
}
static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
static uint8_t *DHT_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
{
host_to_lendian32(data, len);
data += sizeof(uint32_t);
@ -2757,7 +2757,7 @@ void DHT_save(DHT *dht, uint8_t *data)
uint8_t *old_data = data;
/* get right offset. we write the actual header later. */
data = z_state_save_subheader(data, 0, 0);
data = DHT_save_subheader(data, 0, 0);
Node_format clients[MAX_SAVED_DHT_NODES];
@ -2793,7 +2793,7 @@ void DHT_save(DHT *dht, uint8_t *data)
}
}
z_state_save_subheader(old_data, pack_nodes(data, sizeof(Node_format) * num, clients, num), DHT_STATE_TYPE_NODES);
DHT_save_subheader(old_data, pack_nodes(data, sizeof(Node_format) * num, clients, num), DHT_STATE_TYPE_NODES);
}
/* Bootstrap from this number of nodes every time DHT_connect_after_load() is called */

44
toxcore/Messenger.c
View File

@ -166,10 +166,10 @@ static int send_offline_packet(Messenger *m, int friendcon_id)
sizeof(packet), 0) != -1;
}
static int handle_status(void *object, int i, uint8_t status, void *userdata);
static int handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata);
static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
void *userdata);
static int m_handle_status(void *object, int i, uint8_t status, void *userdata);
static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata);
static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
void *userdata);
static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t status)
{
@ -198,8 +198,8 @@ static int32_t init_new_friend(Messenger *m, const uint8_t *real_pk, uint8_t sta
m->friendlist[i].userstatus = USERSTATUS_NONE;
m->friendlist[i].is_typing = 0;
m->friendlist[i].message_id = 0;
friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &handle_status, &handle_packet,
&handle_custom_lossy_packet, m, i);
friend_connection_callbacks(m->fr_c, friendcon_id, MESSENGER_CALLBACK_INDEX, &m_handle_status, &m_handle_packet,
&m_handle_custom_lossy_packet, m, i);
if (m->numfriends == i) {
++m->numfriends;
@ -1757,8 +1757,8 @@ int m_msi_packet(const Messenger *m, int32_t friendnumber, const uint8_t *data,
return write_cryptpacket_id(m, friendnumber, PACKET_ID_MSI, data, length, 0);
}
static int handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
void *userdata)
static int m_handle_custom_lossy_packet(void *object, int friend_num, const uint8_t *packet, uint16_t length,
void *userdata)
{
Messenger *m = (Messenger *)object;
@ -2080,7 +2080,7 @@ static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t,
}
}
static int handle_status(void *object, int i, uint8_t status, void *userdata)
static int m_handle_status(void *object, int i, uint8_t status, void *userdata)
{
Messenger *m = (Messenger *)object;
@ -2095,7 +2095,7 @@ static int handle_status(void *object, int i, uint8_t status, void *userdata)
return 0;
}
static int handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata)
static int m_handle_packet(void *object, int i, const uint8_t *temp, uint16_t len, void *userdata)
{
if (len == 0) {
return -1;
@ -2902,7 +2902,7 @@ uint32_t messenger_size(const Messenger *m)
+ sizesubhead;
}
static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
static uint8_t *messenger_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
{
host_to_lendian32(data, len);
data += sizeof(uint32_t);
@ -2928,69 +2928,69 @@ void messenger_save(const Messenger *m, uint8_t *data)
assert(sizeof(get_nospam(&m->fr)) == sizeof(uint32_t));
len = size32 + CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SECRET_KEY_SIZE;
type = MESSENGER_STATE_TYPE_NOSPAMKEYS;
data = z_state_save_subheader(data, len, type);
data = messenger_save_subheader(data, len, type);
*(uint32_t *)data = get_nospam(&(m->fr));
save_keys(m->net_crypto, data + size32);
data += len;
len = saved_friendslist_size(m);
type = MESSENGER_STATE_TYPE_FRIENDS;
data = z_state_save_subheader(data, len, type);
data = messenger_save_subheader(data, len, type);
friends_list_save(m, data);
data += len;
len = m->name_length;
type = MESSENGER_STATE_TYPE_NAME;
data = z_state_save_subheader(data, len, type);
data = messenger_save_subheader(data, len, type);
memcpy(data, m->name, len);
data += len;
len = m->statusmessage_length;
type = MESSENGER_STATE_TYPE_STATUSMESSAGE;
data = z_state_save_subheader(data, len, type);
data = messenger_save_subheader(data, len, type);
memcpy(data, m->statusmessage, len);
data += len;
len = 1;
type = MESSENGER_STATE_TYPE_STATUS;
data = z_state_save_subheader(data, len, type);
data = messenger_save_subheader(data, len, type);
*data = m->userstatus;
data += len;
len = DHT_size(m->dht);
type = MESSENGER_STATE_TYPE_DHT;
data = z_state_save_subheader(data, len, type);
data = messenger_save_subheader(data, len, type);
DHT_save(m->dht, data);
data += len;
Node_format relays[NUM_SAVED_TCP_RELAYS];
type = MESSENGER_STATE_TYPE_TCP_RELAY;
uint8_t *temp_data = data;
data = z_state_save_subheader(temp_data, 0, type);
data = messenger_save_subheader(temp_data, 0, type);
unsigned int num = copy_connected_tcp_relays(m->net_crypto, relays, NUM_SAVED_TCP_RELAYS);
int l = pack_nodes(data, NUM_SAVED_TCP_RELAYS * packed_node_size(TCP_INET6), relays, num);
if (l > 0) {
len = l;
data = z_state_save_subheader(temp_data, len, type);
data = messenger_save_subheader(temp_data, len, type);
data += len;
}
Node_format nodes[NUM_SAVED_PATH_NODES];
type = MESSENGER_STATE_TYPE_PATH_NODE;
temp_data = data;
data = z_state_save_subheader(data, 0, type);
data = messenger_save_subheader(data, 0, type);
memset(nodes, 0, sizeof(nodes));
num = onion_backup_nodes(m->onion_c, nodes, NUM_SAVED_PATH_NODES);
l = pack_nodes(data, NUM_SAVED_PATH_NODES * packed_node_size(TCP_INET6), nodes, num);
if (l > 0) {
len = l;
data = z_state_save_subheader(temp_data, len, type);
data = messenger_save_subheader(temp_data, len, type);
data += len;
}
z_state_save_subheader(data, 0, MESSENGER_STATE_TYPE_END);
messenger_save_subheader(data, 0, MESSENGER_STATE_TYPE_END);
}
static int messenger_load_state_callback(void *outer, const uint8_t *data, uint32_t length, uint16_t type)

64
toxcore/TCP_client.c
View File

@ -244,7 +244,7 @@ static int handle_handshake(TCP_Client_Connection *TCP_conn, const uint8_t *data
/* return 0 if pending data was sent completely
* return -1 if it wasn't
*/
static int send_pending_data_nonpriority(TCP_Client_Connection *con)
static int client_send_pending_data_nonpriority(TCP_Client_Connection *con)
{
if (con->last_packet_length == 0) {
return 0;
@ -270,10 +270,10 @@ static int send_pending_data_nonpriority(TCP_Client_Connection *con)
/* return 0 if pending data was sent completely
* return -1 if it wasn't
*/
static int send_pending_data(TCP_Client_Connection *con)
static int client_send_pending_data(TCP_Client_Connection *con)
{
/* finish sending current non-priority packet */
if (send_pending_data_nonpriority(con) == -1) {
if (client_send_pending_data_nonpriority(con) == -1) {
return -1;
}
@ -309,7 +309,7 @@ static int send_pending_data(TCP_Client_Connection *con)
/* return 0 on failure (only if malloc fails)
* return 1 on success
*/
static bool add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
static bool client_add_priority(TCP_Client_Connection *con, const uint8_t *packet, uint16_t size, uint16_t sent)
{
TCP_Priority_List *p = con->priority_queue_end;
TCP_Priority_List *new_list = (TCP_Priority_List *)malloc(sizeof(TCP_Priority_List) + size);
@ -348,7 +348,7 @@ static void wipe_priority_list(TCP_Client_Connection *con)
* return 0 if could not send packet.
* return -1 on failure (connection must be killed).
*/
static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length,
static int write_packet_TCP_client_secure_connection(TCP_Client_Connection *con, const uint8_t *data, uint16_t length,
bool priority)
{
if (length + CRYPTO_MAC_SIZE > MAX_PACKET_SIZE) {
@ -357,7 +357,7 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
bool sendpriority = 1;
if (send_pending_data(con) == -1) {
if (client_send_pending_data(con) == -1) {
if (priority) {
sendpriority = 0;
} else {
@ -388,7 +388,7 @@ static int write_packet_TCP_secure_connection(TCP_Client_Connection *con, const
return 1;
}
return add_priority(con, packet, SIZEOF_VLA(packet), len);
return client_add_priority(con, packet, SIZEOF_VLA(packet), len);
}
len = send(con->sock, (const char *)packet, SIZEOF_VLA(packet), MSG_NOSIGNAL);
@ -418,7 +418,7 @@ int send_routing_request(TCP_Client_Connection *con, uint8_t *public_key)
uint8_t packet[1 + CRYPTO_PUBLIC_KEY_SIZE];
packet[0] = TCP_PACKET_ROUTING_REQUEST;
memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
return write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1);
}
void routing_response_handler(TCP_Client_Connection *con, int (*response_callback)(void *object, uint8_t connection_id,
@ -435,8 +435,8 @@ void routing_status_handler(TCP_Client_Connection *con, int (*status_callback)(v
con->status_callback_object = object;
}
static int send_ping_response(TCP_Client_Connection *con);
static int send_ping_request(TCP_Client_Connection *con);
static int tcp_send_ping_response(TCP_Client_Connection *con);
static int tcp_send_ping_request(TCP_Client_Connection *con);
/* return 1 on success.
* return 0 if could not send packet.
@ -452,14 +452,14 @@ int send_data(TCP_Client_Connection *con, uint8_t con_id, const uint8_t *data, u
return -1;
}
if (send_ping_response(con) == 0 || send_ping_request(con) == 0) {
if (tcp_send_ping_response(con) == 0 || tcp_send_ping_request(con) == 0) {
return 0;
}
VLA(uint8_t, packet, 1 + length);
packet[0] = con_id + NUM_RESERVED_PORTS;
memcpy(packet + 1, data, length);
return write_packet_TCP_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
}
/* return 1 on success.
@ -476,7 +476,7 @@ int send_oob_packet(TCP_Client_Connection *con, const uint8_t *public_key, const
packet[0] = TCP_PACKET_OOB_SEND;
memcpy(packet + 1, public_key, CRYPTO_PUBLIC_KEY_SIZE);
memcpy(packet + 1 + CRYPTO_PUBLIC_KEY_SIZE, data, length);
return write_packet_TCP_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
}
@ -519,19 +519,19 @@ void oob_data_handler(TCP_Client_Connection *con, int (*oob_data_callback)(void
* return 0 if could not send packet.
* return -1 on failure (connection must be killed).
*/
static int send_disconnect_notification(TCP_Client_Connection *con, uint8_t id)
static int client_send_disconnect_notification(TCP_Client_Connection *con, uint8_t id)
{
uint8_t packet[1 + 1];
packet[0] = TCP_PACKET_DISCONNECT_NOTIFICATION;
packet[1] = id;
return write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1);
return write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1);
}
/* return 1 on success.
* return 0 if could not send packet.
* return -1 on failure (connection must be killed).
*/
static int send_ping_request(TCP_Client_Connection *con)
static int tcp_send_ping_request(TCP_Client_Connection *con)
{
if (!con->ping_request_id) {
return 1;
@ -542,7 +542,7 @@ static int send_ping_request(TCP_Client_Connection *con)
memcpy(packet + 1, &con->ping_request_id, sizeof(uint64_t));
int ret;
if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
if ((ret = write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
con->ping_request_id = 0;
}
@ -553,7 +553,7 @@ static int send_ping_request(TCP_Client_Connection *con)
* return 0 if could not send packet.
* return -1 on failure (connection must be killed).
*/
static int send_ping_response(TCP_Client_Connection *con)
static int tcp_send_ping_response(TCP_Client_Connection *con)
{
if (!con->ping_response_id) {
return 1;
@ -564,7 +564,7 @@ static int send_ping_response(TCP_Client_Connection *con)
memcpy(packet + 1, &con->ping_response_id, sizeof(uint64_t));
int ret;
if ((ret = write_packet_TCP_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
if ((ret = write_packet_TCP_client_secure_connection(con, packet, sizeof(packet), 1)) == 1) {
con->ping_response_id = 0;
}
@ -583,7 +583,7 @@ int send_disconnect_request(TCP_Client_Connection *con, uint8_t con_id)
con->connections[con_id].status = 0;
con->connections[con_id].number = 0;
return send_disconnect_notification(con, con_id + NUM_RESERVED_PORTS);
return client_send_disconnect_notification(con, con_id + NUM_RESERVED_PORTS);
}
/* return 1 on success.
@ -595,7 +595,7 @@ int send_onion_request(TCP_Client_Connection *con, const uint8_t *data, uint16_t
VLA(uint8_t, packet, 1 + length);
packet[0] = TCP_PACKET_ONION_REQUEST;
memcpy(packet + 1, data, length);
return write_packet_TCP_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
return write_packet_TCP_client_secure_connection(con, packet, SIZEOF_VLA(packet), 0);
}
void onion_response_handler(TCP_Client_Connection *con, int (*onion_callback)(void *object, const uint8_t *data,
@ -692,7 +692,7 @@ TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public
/* return 0 on success
* return -1 on failure
*/
static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, uint16_t length, void *userdata)
static int handle_TCP_client_packet(TCP_Client_Connection *conn, const uint8_t *data, uint16_t length, void *userdata)
{
if (length <= 1) {
return -1;
@ -787,7 +787,7 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
uint64_t ping_id;
memcpy(&ping_id, data + 1, sizeof(uint64_t));
conn->ping_response_id = ping_id;
send_ping_response(conn);
tcp_send_ping_response(conn);
return 0;
}
@ -847,9 +847,9 @@ static int handle_TCP_packet(TCP_Client_Connection *conn, const uint8_t *data, u
static int do_confirmed_TCP(TCP_Client_Connection *conn, void *userdata)
{
send_pending_data(conn);
send_ping_response(conn);
send_ping_request(conn);
client_send_pending_data(conn);
tcp_send_ping_response(conn);
tcp_send_ping_request(conn);
uint8_t packet[MAX_PACKET_SIZE];
int len;
@ -862,7 +862,7 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn, void *userdata)
}
conn->ping_request_id = conn->ping_id = ping_id;
send_ping_request(conn);
tcp_send_ping_request(conn);
conn->last_pinged = unix_time();
}
@ -878,7 +878,7 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn, void *userdata)
break;
}
if (handle_TCP_packet(conn, packet, len, userdata) == -1) {
if (handle_TCP_client_packet(conn, packet, len, userdata) == -1) {
conn->status = TCP_CLIENT_DISCONNECTED;
break;
}
@ -898,7 +898,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
}
if (TCP_connection->status == TCP_CLIENT_PROXY_HTTP_CONNECTING) {
if (send_pending_data(TCP_connection) == 0) {
if (client_send_pending_data(TCP_connection) == 0) {
int ret = proxy_http_read_connection_response(TCP_connection);
if (ret == -1) {
@ -914,7 +914,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
}
if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_CONNECTING) {
if (send_pending_data(TCP_connection) == 0) {
if (client_send_pending_data(TCP_connection) == 0) {
int ret = socks5_read_handshake_response(TCP_connection);
if (ret == -1) {
@ -930,7 +930,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
}
if (TCP_connection->status == TCP_CLIENT_PROXY_SOCKS5_UNCONFIRMED) {
if (send_pending_data(TCP_connection) == 0) {
if (client_send_pending_data(TCP_connection) == 0) {
int ret = proxy_socks5_read_connection_response(TCP_connection);
if (ret == -1) {
@ -946,7 +946,7 @@ void do_TCP_connection(TCP_Client_Connection *TCP_connection, void *userdata)
}
if (TCP_connection->status == TCP_CLIENT_CONNECTING) {
if (send_pending_data(TCP_connection) == 0) {
if (client_send_pending_data(TCP_connection) == 0) {
TCP_connection->status = TCP_CLIENT_UNCONFIRMED;
}
}

14
toxcore/TCP_connection.c
View File

@ -973,8 +973,8 @@ static int tcp_status_callback(void *object, uint32_t number, uint8_t connection
return 0;
}
static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data, uint16_t length,
void *userdata)
static int tcp_conn_data_callback(void *object, uint32_t number, uint8_t connection_id, const uint8_t *data,
uint16_t length, void *userdata)
{
if (length == 0) {
return -1;
@ -1003,8 +1003,8 @@ static int tcp_data_callback(void *object, uint32_t number, uint8_t connection_i
return 0;
}
static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length,
void *userdata)
static int tcp_conn_oob_callback(void *object, const uint8_t *public_key, const uint8_t *data, uint16_t length,
void *userdata)
{
if (length == 0) {
return -1;
@ -1026,7 +1026,7 @@ static int tcp_oob_callback(void *object, const uint8_t *public_key, const uint8
TCP_Connection_to *con_to = get_connection(tcp_c, connections_number);
if (con_to && tcp_connection_in_conn(con_to, tcp_connections_number)) {
return tcp_data_callback(object, connections_number, 0, data, length, userdata);
return tcp_conn_data_callback(object, connections_number, 0, data, length, userdata);
}
if (tcp_c->tcp_oob_callback) {
@ -1067,8 +1067,8 @@ static int tcp_relay_set_callbacks(TCP_Connections *tcp_c, int tcp_connections_n
onion_response_handler(con, &tcp_onion_callback, tcp_c);
routing_response_handler(con, &tcp_response_callback, con);
routing_status_handler(con, &tcp_status_callback, con);
routing_data_handler(con, &tcp_data_callback, con);
oob_data_handler(con, &tcp_oob_callback, con);
routing_data_handler(con, &tcp_conn_data_callback, con);
oob_data_handler(con, &tcp_conn_oob_callback, con);
return 0;
}

48
toxcore/TCP_server.c
View File

@ -45,9 +45,9 @@ struct TCP_Server {
uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
uint8_t secret_key[CRYPTO_SECRET_KEY_SIZE];
TCP_Secure_Connection incomming_connection_queue[MAX_INCOMMING_CONNECTIONS];
uint16_t incomming_connection_queue_index;
TCP_Secure_Connection unconfirmed_connection_queue[MAX_INCOMMING_CONNECTIONS];
TCP_Secure_Connection incoming_connection_queue[MAX_INCOMING_CONNECTIONS];
uint16_t incoming_connection_queue_index;
TCP_Secure_Connection unconfirmed_connection_queue[MAX_INCOMING_CONNECTIONS];
uint16_t unconfirmed_connection_queue_index;
TCP_Secure_Connection *accepted_connection_array;
@ -477,7 +477,7 @@ static int write_packet_TCP_secure_connection(TCP_Secure_Connection *con, const
/* Kill a TCP_Secure_Connection
*/
static void kill_TCP_connection(TCP_Secure_Connection *con)
static void kill_TCP_secure_connection(TCP_Secure_Connection *con)
{
kill_sock(con->sock);
crypto_memzero(con, sizeof(TCP_Secure_Connection));
@ -927,7 +927,7 @@ static int confirm_TCP_connection(TCP_Server *TCP_server, TCP_Secure_Connection
int index = add_accepted(TCP_server, con);
if (index == -1) {
kill_TCP_connection(con);
kill_TCP_secure_connection(con);
return -1;
}
@ -960,19 +960,19 @@ static int accept_connection(TCP_Server *TCP_server, Socket sock)
return -1;
}
uint16_t index = TCP_server->incomming_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
uint16_t index = TCP_server->incoming_connection_queue_index % MAX_INCOMING_CONNECTIONS;
TCP_Secure_Connection *conn = &TCP_server->incomming_connection_queue[index];
TCP_Secure_Connection *conn = &TCP_server->incoming_connection_queue[index];
if (conn->status != TCP_STATUS_NO_STATUS) {
kill_TCP_connection(conn);
kill_TCP_secure_connection(conn);
}
conn->status = TCP_STATUS_CONNECTED;
conn->sock = sock;
conn->next_packet_length = 0;
++TCP_server->incomming_connection_queue_index;
++TCP_server->incoming_connection_queue_index;
return index;
}
@ -1107,21 +1107,21 @@ static void do_TCP_accept_new(TCP_Server *TCP_server)
static int do_incoming(TCP_Server *TCP_server, uint32_t i)
{
if (TCP_server->incomming_connection_queue[i].status != TCP_STATUS_CONNECTED) {
if (TCP_server->incoming_connection_queue[i].status != TCP_STATUS_CONNECTED) {
return -1;
}
int ret = read_connection_handshake(&TCP_server->incomming_connection_queue[i], TCP_server->secret_key);
int ret = read_connection_handshake(&TCP_server->incoming_connection_queue[i], TCP_server->secret_key);
if (ret == -1) {
kill_TCP_connection(&TCP_server->incomming_connection_queue[i]);
kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[i]);
} else if (ret == 1) {
int index_new = TCP_server->unconfirmed_connection_queue_index % MAX_INCOMMING_CONNECTIONS;
TCP_Secure_Connection *conn_old = &TCP_server->incomming_connection_queue[i];
int index_new = TCP_server->unconfirmed_connection_queue_index % MAX_INCOMING_CONNECTIONS;
TCP_Secure_Connection *conn_old = &TCP_server->incoming_connection_queue[i];
TCP_Secure_Connection *conn_new = &TCP_server->unconfirmed_connection_queue[index_new];
if (conn_new->status != TCP_STATUS_NO_STATUS) {
kill_TCP_connection(conn_new);
kill_TCP_secure_connection(conn_new);
}
memcpy(conn_new, conn_old, sizeof(TCP_Secure_Connection));
@ -1151,7 +1151,7 @@ static int do_unconfirmed(TCP_Server *TCP_server, uint32_t i)
}
if (len == -1) {
kill_TCP_connection(conn);
kill_TCP_secure_connection(conn);
return -1;
}
@ -1179,11 +1179,11 @@ static void do_confirmed_recv(TCP_Server *TCP_server, uint32_t i)
}
}
static void do_TCP_incomming(TCP_Server *TCP_server)
static void do_TCP_incoming(TCP_Server *TCP_server)
{
uint32_t i;
for (i = 0; i < MAX_INCOMMING_CONNECTIONS; ++i) {
for (i = 0; i < MAX_INCOMING_CONNECTIONS; ++i) {
do_incoming(TCP_server, i);
}
}
@ -1192,7 +1192,7 @@ static void do_TCP_unconfirmed(TCP_Server *TCP_server)
{
uint32_t i;
for (i = 0; i < MAX_INCOMMING_CONNECTIONS; ++i) {
for (i = 0; i < MAX_INCOMING_CONNECTIONS; ++i) {
do_unconfirmed(TCP_server, i);
}
}
@ -1276,12 +1276,12 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
}
case TCP_SOCKET_INCOMING: {
kill_TCP_connection(&TCP_server->incomming_connection_queue[index]);
kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[index]);
break;
}
case TCP_SOCKET_UNCONFIRMED: {
kill_TCP_connection(&TCP_server->unconfirmed_connection_queue[index]);
kill_TCP_secure_connection(&TCP_server->unconfirmed_connection_queue[index]);
break;
}
@ -1324,7 +1324,7 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
};
if (epoll_ctl(TCP_server->efd, EPOLL_CTL_ADD, sock_new, &ev) == -1) {
kill_TCP_connection(&TCP_server->incomming_connection_queue[index_new]);
kill_TCP_secure_connection(&TCP_server->incoming_connection_queue[index_new]);
continue;
}
}
@ -1340,7 +1340,7 @@ static void do_TCP_epoll(TCP_Server *TCP_server)
events[n].data.u64 = sock | ((uint64_t)TCP_SOCKET_UNCONFIRMED << 32) | ((uint64_t)index_new << 40);
if (epoll_ctl(TCP_server->efd, EPOLL_CTL_MOD, sock, &events[n]) == -1) {
kill_TCP_connection(&TCP_server->unconfirmed_connection_queue[index_new]);
kill_TCP_secure_connection(&TCP_server->unconfirmed_connection_queue[index_new]);
break;
}
}
@ -1386,7 +1386,7 @@ void do_TCP_server(TCP_Server *TCP_server)
#else
do_TCP_accept_new(TCP_server);
do_TCP_incomming(TCP_server);
do_TCP_incoming(TCP_server);
do_TCP_unconfirmed(TCP_server);
#endif

4
toxcore/TCP_server.h
View File

@ -36,9 +36,9 @@
#define MSG_NOSIGNAL 0
#endif
#define MAX_INCOMMING_CONNECTIONS 256
#define MAX_INCOMING_CONNECTIONS 256
#define TCP_MAX_BACKLOG MAX_INCOMMING_CONNECTIONS
#define TCP_MAX_BACKLOG MAX_INCOMING_CONNECTIONS
#define MAX_PACKET_SIZE 2048

8
toxcore/group.c
View File

@ -659,7 +659,7 @@ static void set_conns_status_groups(Group_Chats *g_c, int friendcon_id, uint8_t
}
}
static int handle_status(void *object, int friendcon_id, uint8_t status, void *userdata)
static int g_handle_status(void *object, int friendcon_id, uint8_t status, void *userdata)
{
Group_Chats *g_c = (Group_Chats *)object;
@ -673,7 +673,7 @@ static int handle_status(void *object, int friendcon_id, uint8_t status, void *u
return 0;
}
static int handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
static int g_handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata);
/* Add friend to group chat.
@ -715,7 +715,7 @@ static int add_conn_to_groupchat(Group_Chats *g_c, int friendcon_id, int groupnu
g->close[ind].number = friendcon_id;
g->close[ind].closest = closest;
// TODO(irungentoo):
friend_connection_callbacks(g_c->m->fr_c, friendcon_id, GROUPCHAT_CALLBACK_INDEX, &handle_status, &handle_packet,
friend_connection_callbacks(g_c->m->fr_c, friendcon_id, GROUPCHAT_CALLBACK_INDEX, &g_handle_status, &g_handle_packet,
&handle_lossy, g_c, friendcon_id);
return ind;
@ -2124,7 +2124,7 @@ static void handle_message_packet_group(Group_Chats *g_c, int groupnumber, const
send_message_all_close(g_c, groupnumber, data, length, -1/* TODO(irungentoo) close_index */);
}
static int handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata)
static int g_handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata)
{
Group_Chats *g_c = (Group_Chats *)object;

14
toxcore/onion_client.c
View File

@ -474,13 +474,13 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, IP_
typedef struct {
const uint8_t *base_public_key;
Onion_Node entry;
} Cmp_data;
} Onion_Client_Cmp_data;
static int cmp_entry(const void *a, const void *b)
static int onion_client_cmp_entry(const void *a, const void *b)
{
Cmp_data cmp1, cmp2;
memcpy(&cmp1, a, sizeof(Cmp_data));
memcpy(&cmp2, b, sizeof(Cmp_data));
Onion_Client_Cmp_data cmp1, cmp2;
memcpy(&cmp1, a, sizeof(Onion_Client_Cmp_data));
memcpy(&cmp2, b, sizeof(Onion_Client_Cmp_data));
Onion_Node entry1 = cmp1.entry;
Onion_Node entry2 = cmp2.entry;
const uint8_t *cmp_public_key = cmp1.base_public_key;
@ -517,14 +517,14 @@ static void sort_onion_node_list(Onion_Node *list, unsigned int length, const ui
{
// Pass comp_public_key to qsort with each Client_data entry, so the
// comparison function can use it as the base of comparison.
VLA(Cmp_data, cmp_list, length);
VLA(Onion_Client_Cmp_data, cmp_list, length);
for (uint32_t i = 0; i < length; i++) {
cmp_list[i].base_public_key = comp_public_key;
cmp_list[i].entry = list[i];
}
qsort(cmp_list, length, sizeof(Cmp_data), cmp_entry);
qsort(cmp_list, length, sizeof(Onion_Client_Cmp_data), onion_client_cmp_entry);
for (uint32_t i = 0; i < length; i++) {
list[i] = cmp_list[i].entry;