diff options
31 files changed, 484 insertions, 406 deletions
diff --git a/protocols/Tox/libtox/docs/CHANGELOG.md b/protocols/Tox/libtox/docs/CHANGELOG.md index 8973c4ee69..0412d1977b 100644 --- a/protocols/Tox/libtox/docs/CHANGELOG.md +++ b/protocols/Tox/libtox/docs/CHANGELOG.md @@ -1,12 +1,72 @@ +## v0.2.13 + +### Merged PRs: + +- [#1725](https://github.com/TokTok/c-toxcore/pull/1725) cleanup: add some missing null checks +- [#1723](https://github.com/TokTok/c-toxcore/pull/1723) chore: Run infer static analyser on circle ci builds. +- [#1718](https://github.com/TokTok/c-toxcore/pull/1718) fix: Sec/fix crypto size compute +- [#1716](https://github.com/TokTok/c-toxcore/pull/1716) chore: Use toktok-stack docker image with built third_party. +- [#1713](https://github.com/TokTok/c-toxcore/pull/1713) test: Add some unit tests for important internal DHT functions. +- [#1708](https://github.com/TokTok/c-toxcore/pull/1708) perf: reduce calling into Mono_Time in DHT +- [#1706](https://github.com/TokTok/c-toxcore/pull/1706) chore: Enable cimple tests on cirrus build. +- [#1705](https://github.com/TokTok/c-toxcore/pull/1705) fix: issue with save_load autotest +- [#1703](https://github.com/TokTok/c-toxcore/pull/1703) chore: Upgrade to toktok-stack:0.0.11. +- [#1699](https://github.com/TokTok/c-toxcore/pull/1699) fix: some friend connection issues +- [#1698](https://github.com/TokTok/c-toxcore/pull/1698) fix: bug causing API to report wrong self connection status +- [#1693](https://github.com/TokTok/c-toxcore/pull/1693) chore: Update IRC info +- [#1691](https://github.com/TokTok/c-toxcore/pull/1691) chore: Fix Appveyor and add workarounds for Cirrus CI +- [#1686](https://github.com/TokTok/c-toxcore/pull/1686) chore: Enable c-toxcore conan packaging +- [#1684](https://github.com/TokTok/c-toxcore/pull/1684) cleanup: Update INSTALL.md instructions +- [#1679](https://github.com/TokTok/c-toxcore/pull/1679) cleanup: Trivial cleanup +- [#1674](https://github.com/TokTok/c-toxcore/pull/1674) cleanup: filetransfer code +- [#1672](https://github.com/TokTok/c-toxcore/pull/1672) docs: Add instructions for building unit tests to INSTALL.md +- [#1667](https://github.com/TokTok/c-toxcore/pull/1667) chore: Update tox-bootstrapd checksum due to newer packages in Alpine +- [#1664](https://github.com/TokTok/c-toxcore/pull/1664) cleanup: use heap memory instead of stack for large variables +- [#1663](https://github.com/TokTok/c-toxcore/pull/1663) fix: Fix file tests on windows +- [#1633](https://github.com/TokTok/c-toxcore/pull/1633) fix: AppVeyor failing due to conan remote being added twice +- [#1602](https://github.com/TokTok/c-toxcore/pull/1602) fix: Fix buffer over-read when a peer leaves a conference +- [#1586](https://github.com/TokTok/c-toxcore/pull/1586) test: Fix tcp_relay_test by adding a second bootstrap node. +- [#1580](https://github.com/TokTok/c-toxcore/pull/1580) style: Format comments according to tokstyle's requirements. +- [#1557](https://github.com/TokTok/c-toxcore/pull/1557) chore: Add conan support +- [#1537](https://github.com/TokTok/c-toxcore/pull/1537) chore: Cygwin build +- [#1516](https://github.com/TokTok/c-toxcore/pull/1516) cleanup: Make pylint and mypy happy with bootstrap_node_info.py. +- [#1515](https://github.com/TokTok/c-toxcore/pull/1515) style: Run restyled on Travis and Circle CI scripts. +- [#1514](https://github.com/TokTok/c-toxcore/pull/1514) refactor: Remove multi-declarators entirely. +- [#1513](https://github.com/TokTok/c-toxcore/pull/1513) refactor: Disallow multiple initialised declarators per decl. +- [#1510](https://github.com/TokTok/c-toxcore/pull/1510) chore: Don't build pushes to branches, only to tags. +- [#1504](https://github.com/TokTok/c-toxcore/pull/1504) chore: Remove release-drafter configuration in favour of global one. +- [#1498](https://github.com/TokTok/c-toxcore/pull/1498) refactor: Limit scope of loop iterators. +- [#1497](https://github.com/TokTok/c-toxcore/pull/1497) refactor: Use bash arrays instead of strings for static analysis scripts. +- [#1496](https://github.com/TokTok/c-toxcore/pull/1496) cleanup: Stop hard-coding packet IDs in tests. +- [#1495](https://github.com/TokTok/c-toxcore/pull/1495) chore: Exclude imported libsodium sources from restyled. +- [#1493](https://github.com/TokTok/c-toxcore/pull/1493) feat: Add logging to TCP and onion client. +- [#1489](https://github.com/TokTok/c-toxcore/pull/1489) cleanup: `NAC_LIBS` -> `NACL_LIBS`. +- [#1487](https://github.com/TokTok/c-toxcore/pull/1487) chore: Add autotools build to localbuild docker images. +- [#1473](https://github.com/TokTok/c-toxcore/pull/1473) chore: Add a script to run Travis CI locally. +- [#1467](https://github.com/TokTok/c-toxcore/pull/1467) fix: Fix a bug in savedata loading when malloc fails. +- [#1464](https://github.com/TokTok/c-toxcore/pull/1464) fix: Fix errors on error paths found by oomer. +- [#1463](https://github.com/TokTok/c-toxcore/pull/1463) cleanup: Add a check that we don't have any unused functions. +- [#1462](https://github.com/TokTok/c-toxcore/pull/1462) cleanup: Include `<string.h>` for `explicit_bzero`. +- [#1436](https://github.com/TokTok/c-toxcore/pull/1436) chore: Enable cimple tests by default but allow disabling them. + +### Closed issues: + +- [#1598](https://github.com/TokTok/c-toxcore/issues/1598) ERROR: heap-buffer-overflow in group.c found with AddressSanitizer +- [#1326](https://github.com/TokTok/c-toxcore/issues/1326) the cause is great, but this thing is completely unusable +- [#1319](https://github.com/TokTok/c-toxcore/issues/1319) Is this new application is safe & trusted ?? +- [#1236](https://github.com/TokTok/c-toxcore/issues/1236) Ruby Extension? +- [#1149](https://github.com/TokTok/c-toxcore/issues/1149) uTox aborts on toxcore restart +- [#886](https://github.com/TokTok/c-toxcore/issues/886) Maybe need to set the stacksize for musl-libc + ## v0.2.12 ### Merged PRs: +- [#1458](https://github.com/TokTok/c-toxcore/pull/1458) Release 0.2.12 - [#1457](https://github.com/TokTok/c-toxcore/pull/1457) Disable non-hermetic tests by default. - [#1456](https://github.com/TokTok/c-toxcore/pull/1456) Limit the number of friends you can have to ~4 billion. - [#1452](https://github.com/TokTok/c-toxcore/pull/1452) Add execution trace option for debugging. -- [#1447](https://github.com/TokTok/c-toxcore/pull/1447) Udp dht group chats - [#1444](https://github.com/TokTok/c-toxcore/pull/1444) Set up release-drafter to automatically draft the next release. - [#1443](https://github.com/TokTok/c-toxcore/pull/1443) Allow test coverage to fluctuate 2% up and down, but not below 80%. - [#1442](https://github.com/TokTok/c-toxcore/pull/1442) Add CODEOWNERS and settings.yml files. diff --git a/protocols/Tox/libtox/docs/README.md b/protocols/Tox/libtox/docs/README.md index 8e45ec00d7..5bb3a157b6 100644 --- a/protocols/Tox/libtox/docs/README.md +++ b/protocols/Tox/libtox/docs/README.md @@ -5,7 +5,7 @@ [**Website**](https://tox.chat) **|** [**Wiki**](https://wiki.tox.chat/) **|** [**Blog**](https://blog.tox.chat/) **|** [**FAQ**](https://wiki.tox.chat/doku.php?id=users:faq) **|** [**Binaries/Downloads**](https://wiki.tox.chat/Binaries) **|** [**Clients**](https://wiki.tox.chat/doku.php?id=clients) **|** [**Compiling**](/INSTALL.md) **|** [**Toxcore's Projects**](https://github.com/TokTok/c-toxcore/projects) -**IRC Channels:** Users: [#tox@freenode](https://webchat.freenode.net/?channels=tox), Developers: [#toktok@freenode](https://webchat.freenode.net/?channels=toktok) +**IRC Channels:** Users: [#tox@libera.chat](https://web.libera.chat/#tox), Developers: [#toktok@libera.chat](https://web.libera.chat/#toktok) ## What is Tox diff --git a/protocols/Tox/libtox/src/toxcore/DHT.c b/protocols/Tox/libtox/src/toxcore/DHT.c index b3017259b2..267d46881e 100644 --- a/protocols/Tox/libtox/src/toxcore/DHT.c +++ b/protocols/Tox/libtox/src/toxcore/DHT.c @@ -173,9 +173,9 @@ const uint8_t *dht_get_friend_public_key(const DHT *dht, uint32_t friend_num) return dht->friends_list[friend_num].public_key; } -static bool assoc_timeout(const Mono_Time *mono_time, const IPPTsPng *assoc) +static bool assoc_timeout(uint64_t cur_time, const IPPTsPng *assoc) { - return mono_time_is_timeout(mono_time, assoc->timestamp, BAD_NODE_TIMEOUT); + return (assoc->timestamp + BAD_NODE_TIMEOUT) <= cur_time; } /* Compares pk1 and pk2 with pk. @@ -295,7 +295,7 @@ void dht_get_shared_key_sent(DHT *dht, uint8_t *shared_key, const uint8_t *publi get_shared_key(dht->mono_time, &dht->shared_keys_sent, shared_key, dht->self_secret_key, public_key); } -#define CRYPTO_SIZE 1 + CRYPTO_PUBLIC_KEY_SIZE * 2 + CRYPTO_NONCE_SIZE +#define CRYPTO_SIZE (1 + CRYPTO_PUBLIC_KEY_SIZE * 2 + CRYPTO_NONCE_SIZE) /* Create a request to peer. * send_public_key and send_secret_key are the pub/secret keys of the sender. @@ -583,7 +583,8 @@ int pack_nodes(uint8_t *data, uint16_t length, const Node_format *nodes, uint16_ int unpack_nodes(Node_format *nodes, uint16_t max_num_nodes, uint16_t *processed_data_len, const uint8_t *data, uint16_t length, bool tcp_enabled) { - uint32_t num = 0, len_processed = 0; + uint32_t num = 0; + uint32_t len_processed = 0; while (num < max_num_nodes && len_processed < length) { const int ipp_size = unpack_ip_port(&nodes[num].ip_port, data + len_processed, length - len_processed, tcp_enabled); @@ -787,7 +788,7 @@ static uint8_t hardening_correct(const Hardening *h) /* * helper for get_close_nodes(). argument list is a monster :D */ -static void get_close_nodes_inner(const Mono_Time *mono_time, const uint8_t *public_key, Node_format *nodes_list, +static void get_close_nodes_inner(uint64_t cur_time, const uint8_t *public_key, Node_format *nodes_list, Family sa_family, const Client_data *client_list, uint32_t client_list_length, uint32_t *num_nodes_ptr, bool is_LAN, uint8_t want_good) { @@ -818,7 +819,7 @@ static void get_close_nodes_inner(const Mono_Time *mono_time, const uint8_t *pub } /* node not in a good condition? */ - if (assoc_timeout(mono_time, ipptp)) { + if (assoc_timeout(cur_time, ipptp)) { continue; } @@ -856,7 +857,7 @@ static int get_somewhat_close_nodes(const DHT *dht, const uint8_t *public_key, N Family sa_family, bool is_LAN, uint8_t want_good) { uint32_t num_nodes = 0; - get_close_nodes_inner(dht->mono_time, public_key, nodes_list, sa_family, + get_close_nodes_inner(dht->last_run, public_key, nodes_list, sa_family, dht->close_clientlist, LCLIENT_LIST, &num_nodes, is_LAN, 0); /* TODO(irungentoo): uncomment this when hardening is added to close friend clients */ @@ -871,7 +872,7 @@ static int get_somewhat_close_nodes(const DHT *dht, const uint8_t *public_key, N #endif for (uint32_t i = 0; i < dht->num_friends; ++i) { - get_close_nodes_inner(dht->mono_time, public_key, nodes_list, sa_family, + get_close_nodes_inner(dht->last_run, public_key, nodes_list, sa_family, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, &num_nodes, is_LAN, 0); } @@ -887,7 +888,7 @@ int get_close_nodes(const DHT *dht, const uint8_t *public_key, Node_format *node } typedef struct DHT_Cmp_data { - const Mono_Time *mono_time; + uint64_t cur_time; const uint8_t *base_public_key; Client_data entry; } DHT_Cmp_data; @@ -899,15 +900,16 @@ static bool incorrect_hardening(const IPPTsPng *assoc) static int cmp_dht_entry(const void *a, const void *b) { - DHT_Cmp_data cmp1, cmp2; + DHT_Cmp_data cmp1; + DHT_Cmp_data cmp2; memcpy(&cmp1, a, sizeof(DHT_Cmp_data)); memcpy(&cmp2, b, sizeof(DHT_Cmp_data)); const Client_data entry1 = cmp1.entry; const Client_data entry2 = cmp2.entry; const uint8_t *cmp_public_key = cmp1.base_public_key; - bool t1 = assoc_timeout(cmp1.mono_time, &entry1.assoc4) && assoc_timeout(cmp1.mono_time, &entry1.assoc6); - bool t2 = assoc_timeout(cmp2.mono_time, &entry2.assoc4) && assoc_timeout(cmp2.mono_time, &entry2.assoc6); + bool t1 = assoc_timeout(cmp1.cur_time, &entry1.assoc4) && assoc_timeout(cmp1.cur_time, &entry1.assoc6); + bool t2 = assoc_timeout(cmp2.cur_time, &entry2.assoc4) && assoc_timeout(cmp2.cur_time, &entry2.assoc6); if (t1 && t2) { return 0; @@ -950,15 +952,15 @@ static int cmp_dht_entry(const void *a, const void *b) * return 0 if node can't be stored. * return 1 if it can. */ -static unsigned int store_node_ok(const Client_data *client, const Mono_Time *mono_time, const uint8_t *public_key, +static unsigned int store_node_ok(const Client_data *client, uint64_t cur_time, const uint8_t *public_key, const uint8_t *comp_public_key) { - return (assoc_timeout(mono_time, &client->assoc4) - && assoc_timeout(mono_time, &client->assoc6)) + return (assoc_timeout(cur_time, &client->assoc4) + && assoc_timeout(cur_time, &client->assoc6)) || id_closest(comp_public_key, client->public_key, public_key) == 2; } -static void sort_client_list(Client_data *list, const Mono_Time *mono_time, unsigned int length, +static void sort_client_list(Client_data *list, uint64_t cur_time, unsigned int length, const uint8_t *comp_public_key) { // Pass comp_public_key to qsort with each Client_data entry, so the @@ -966,7 +968,7 @@ static void sort_client_list(Client_data *list, const Mono_Time *mono_time, unsi VLA(DHT_Cmp_data, cmp_list, length); for (uint32_t i = 0; i < length; ++i) { - cmp_list[i].mono_time = mono_time; + cmp_list[i].cur_time = cur_time; cmp_list[i].base_public_key = comp_public_key; cmp_list[i].entry = list[i]; } @@ -1015,7 +1017,7 @@ static void update_client_with_reset(const Mono_Time *mono_time, Client_data *cl * than public_key. * * returns true when the item was stored, false otherwise */ -static bool replace_all(const Mono_Time *mono_time, +static bool replace_all(const DHT *dht, Client_data *list, uint16_t length, const uint8_t *public_key, @@ -1026,17 +1028,17 @@ static bool replace_all(const Mono_Time *mono_time, return false; } - if (!store_node_ok(&list[1], mono_time, public_key, comp_public_key) && - !store_node_ok(&list[0], mono_time, public_key, comp_public_key)) { + if (!store_node_ok(&list[1], dht->last_run, public_key, comp_public_key) && + !store_node_ok(&list[0], dht->last_run, public_key, comp_public_key)) { return false; } - sort_client_list(list, mono_time, length, comp_public_key); + sort_client_list(list, dht->last_run, length, comp_public_key); Client_data *const client = &list[0]; id_copy(client->public_key, public_key); - update_client_with_reset(mono_time, client, &ip_port); + update_client_with_reset(dht->mono_time, client, &ip_port); return true; } @@ -1060,8 +1062,8 @@ static int add_to_close(DHT *dht, const uint8_t *public_key, IP_Port ip_port, bo * index is left as >= LCLIENT_LENGTH */ Client_data *const client = &dht->close_clientlist[(index * LCLIENT_NODES) + i]; - if (!assoc_timeout(dht->mono_time, &client->assoc4) || - !assoc_timeout(dht->mono_time, &client->assoc6)) { + if (!assoc_timeout(dht->last_run, &client->assoc4) || + !assoc_timeout(dht->last_run, &client->assoc6)) { continue; } @@ -1084,7 +1086,7 @@ bool node_addable_to_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_ return add_to_close(dht, public_key, ip_port, 1) == 0; } -static bool is_pk_in_client_list(const Client_data *list, unsigned int client_list_length, const Mono_Time *mono_time, +static bool is_pk_in_client_list(const Client_data *list, unsigned int client_list_length, uint64_t cur_time, const uint8_t *public_key, IP_Port ip_port) { const uint32_t index = index_of_client_pk(list, client_list_length, public_key); @@ -1097,7 +1099,7 @@ static bool is_pk_in_client_list(const Client_data *list, unsigned int client_li ? &list[index].assoc4 : &list[index].assoc6; - return !assoc_timeout(mono_time, assoc); + return !assoc_timeout(cur_time, assoc); } static bool is_pk_in_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_port) @@ -1108,7 +1110,7 @@ static bool is_pk_in_close_list(DHT *dht, const uint8_t *public_key, IP_Port ip_ index = LCLIENT_LENGTH - 1; } - return is_pk_in_client_list(dht->close_clientlist + index * LCLIENT_NODES, LCLIENT_NODES, dht->mono_time, public_key, + return is_pk_in_client_list(dht->close_clientlist + index * LCLIENT_NODES, LCLIENT_NODES, dht->last_run, public_key, ip_port); } @@ -1148,17 +1150,17 @@ static bool ping_node_from_getnodes_ok(DHT *dht, const uint8_t *public_key, IP_P bool store_ok = false; - if (store_node_ok(&dht_friend->client_list[1], dht->mono_time, public_key, dht_friend->public_key)) { + if (store_node_ok(&dht_friend->client_list[1], dht->last_run, public_key, dht_friend->public_key)) { store_ok = true; } - if (store_node_ok(&dht_friend->client_list[0], dht->mono_time, public_key, dht_friend->public_key)) { + if (store_node_ok(&dht_friend->client_list[0], dht->last_run, public_key, dht_friend->public_key)) { store_ok = true; } unsigned int *const friend_num = &dht_friend->num_to_bootstrap; const uint32_t index = index_of_node_pk(dht_friend->to_bootstrap, *friend_num, public_key); - const bool pk_in_list = is_pk_in_client_list(dht_friend->client_list, MAX_FRIEND_CLIENTS, dht->mono_time, public_key, + const bool pk_in_list = is_pk_in_client_list(dht_friend->client_list, MAX_FRIEND_CLIENTS, dht->last_run, public_key, ip_port); if (store_ok && index == UINT32_MAX && !pk_in_list) { @@ -1212,7 +1214,7 @@ uint32_t addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key) /* replace_all should be called only if !in_list (don't extract to variable) */ if (in_list - || replace_all(dht->mono_time, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, public_key, ip_port, + || replace_all(dht, dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS, public_key, ip_port, dht->friends_list[i].public_key)) { DHT_Friend *dht_friend = &dht->friends_list[i]; @@ -1292,7 +1294,7 @@ static void returnedip_ports(DHT *dht, IP_Port ip_port, const uint8_t *public_ke } /* Send a getnodes request. - sendback_node is the node that it will send back the response to (set to NULL to disable this) */ + * sendback_node is the node that it will send back the response to (set to NULL to disable this) */ static int getnodes(DHT *dht, IP_Port ip_port, const uint8_t *public_key, const uint8_t *client_id, const Node_format *sendback_node) { @@ -1425,7 +1427,7 @@ static int handle_getnodes(void *object, IP_Port source, const uint8_t *packet, } /* return false if no - return true if yes */ + * return true if yes */ static bool sent_getnode_to_node(DHT *dht, const uint8_t *public_key, IP_Port node_ip_port, uint64_t ping_id, Node_format *sendback_node) { @@ -1676,7 +1678,7 @@ int dht_getfriendip(const DHT *dht, const uint8_t *public_key, IP_Port *ip_port) for (const IPPTsPng * const *it = assocs; *it; ++it) { const IPPTsPng *const assoc = *it; - if (!assoc_timeout(dht->mono_time, assoc)) { + if (!assoc_timeout(dht->last_run, assoc)) { *ip_port = assoc->ip_port; return 1; } @@ -1717,7 +1719,7 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co } /* If node is good. */ - if (!assoc_timeout(dht->mono_time, assoc)) { + if (!assoc_timeout(dht->last_run, assoc)) { client_list[num_nodes] = client; assoc_list[num_nodes] = assoc; ++num_nodes; @@ -1734,7 +1736,7 @@ static uint8_t do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, co } if (sortable && sort_ok) { - sort_client_list(list, dht->mono_time, list_count, public_key); + sort_client_list(list, dht->last_run, list_count, public_key); } if ((num_nodes != 0) && (mono_time_is_timeout(dht->mono_time, *lastgetnode, GET_NODE_INTERVAL) @@ -1918,8 +1920,8 @@ static int friend_iplist(const DHT *dht, IP_Port *ip_portlist, uint16_t friend_n } if (id_equal(client->public_key, dht_friend->public_key)) { - if (!assoc_timeout(dht->mono_time, &client->assoc6) - || !assoc_timeout(dht->mono_time, &client->assoc4)) { + if (!assoc_timeout(dht->last_run, &client->assoc6) + || !assoc_timeout(dht->last_run, &client->assoc4)) { return 0; /* direct connectivity */ } } @@ -2389,7 +2391,7 @@ static uint32_t have_nodes_closelist(DHT *dht, Node_format *nodes, uint16_t num) const IPPTsPng *const temp = get_closelist_IPPTsPng(dht, nodes[i].public_key, nodes[i].ip_port.ip.family); if (temp) { - if (!assoc_timeout(dht->mono_time, temp)) { + if (!assoc_timeout(dht->last_run, temp)) { ++counter; } } @@ -2417,7 +2419,8 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_ return 1; } - Node_format node, tocheck_node; + Node_format node; + Node_format tocheck_node; node.ip_port = source; memcpy(node.public_key, source_pubkey, CRYPTO_PUBLIC_KEY_SIZE); memcpy(&tocheck_node, packet + 1, sizeof(Node_format)); @@ -2444,7 +2447,7 @@ static int handle_hardening(void *object, IP_Port source, const uint8_t *source_ length_nodes, 0); /* TODO(irungentoo): MAX_SENT_NODES nodes should be returned at all times - (right now we have a small network size so it could cause problems for testing and etc..) */ + * (right now we have a small network size so it could cause problems for testing and etc..) */ if (num_nodes <= 0) { return 1; } @@ -2508,7 +2511,7 @@ static Node_format random_node(DHT *dht, Family sa_family) * * return the number of nodes. */ -static uint16_t list_nodes(Client_data *list, size_t length, const Mono_Time *mono_time, Node_format *nodes, +static uint16_t list_nodes(Client_data *list, size_t length, uint64_t cur_time, Node_format *nodes, uint16_t max_num) { if (max_num == 0) { @@ -2520,11 +2523,11 @@ static uint16_t list_nodes(Client_data *list, size_t length, const Mono_Time *mo for (size_t i = length; i != 0; --i) { const IPPTsPng *assoc = nullptr; - if (!assoc_timeout(mono_time, &list[i - 1].assoc4)) { + if (!assoc_timeout(cur_time, &list[i - 1].assoc4)) { assoc = &list[i - 1].assoc4; } - if (!assoc_timeout(mono_time, &list[i - 1].assoc6)) { + if (!assoc_timeout(cur_time, &list[i - 1].assoc6)) { if (assoc == nullptr) { assoc = &list[i - 1].assoc6; } else if (random_u08() % 2) { @@ -2560,7 +2563,7 @@ uint16_t randfriends_nodes(DHT *dht, Node_format *nodes, uint16_t max_num) const uint32_t r = random_u32(); for (size_t i = 0; i < DHT_FAKE_FRIEND_NUMBER; ++i) { - count += list_nodes(dht->friends_list[(i + r) % DHT_FAKE_FRIEND_NUMBER].client_list, MAX_FRIEND_CLIENTS, dht->mono_time, + count += list_nodes(dht->friends_list[(i + r) % DHT_FAKE_FRIEND_NUMBER].client_list, MAX_FRIEND_CLIENTS, dht->last_run, nodes + count, max_num - count); if (count >= max_num) { @@ -2577,7 +2580,7 @@ uint16_t randfriends_nodes(DHT *dht, Node_format *nodes, uint16_t max_num) */ uint16_t closelist_nodes(DHT *dht, Node_format *nodes, uint16_t max_num) { - return list_nodes(dht->close_clientlist, LCLIENT_LIST, dht->mono_time, nodes, max_num); + return list_nodes(dht->close_clientlist, LCLIENT_LIST, dht->last_run, nodes, max_num); } #if DHT_HARDENING @@ -2698,6 +2701,7 @@ DHT *new_dht(const Logger *log, Mono_Time *mono_time, Networking_Core *net, bool } dht->mono_time = mono_time; + dht->last_run = mono_time_get(mono_time); dht->log = log; dht->net = net; @@ -2743,10 +2747,14 @@ DHT *new_dht(const Logger *log, Mono_Time *mono_time, Networking_Core *net, bool void do_dht(DHT *dht) { - if (dht->last_run == mono_time_get(dht->mono_time)) { + const uint64_t cur_time = mono_time_get(dht->mono_time); + + if (dht->last_run == cur_time) { return; } + dht->last_run = cur_time; + // Load friends/clients if first call to do_dht if (dht->loaded_num_nodes) { dht_connect_after_load(dht); @@ -2759,7 +2767,6 @@ void do_dht(DHT *dht) #if DHT_HARDENING do_hardening(dht); #endif - dht->last_run = mono_time_get(dht->mono_time); } void kill_dht(DHT *dht) @@ -2827,7 +2834,12 @@ void dht_save(const DHT *dht, uint8_t *data) /* get right offset. we write the actual header later. */ data = state_write_section_header(data, DHT_STATE_COOKIE_TYPE, 0, 0); - Node_format clients[MAX_SAVED_DHT_NODES]; + Node_format *clients = (Node_format *)malloc(MAX_SAVED_DHT_NODES * sizeof(Node_format)); + + if (clients == nullptr) { + LOGGER_ERROR(dht->log, "could not allocate %u nodes", MAX_SAVED_DHT_NODES); + return; + } uint32_t num = 0; @@ -2870,6 +2882,8 @@ void dht_save(const DHT *dht, uint8_t *data) state_write_section_header(old_data, DHT_STATE_COOKIE_TYPE, pack_nodes(data, sizeof(Node_format) * num, clients, num), DHT_STATE_TYPE_NODES); + + free(clients); } /* Bootstrap from this number of nodes every time dht_connect_after_load() is called */ @@ -2917,6 +2931,12 @@ static State_Load_Status dht_load_state_callback(void *outer, const uint8_t *dat // Copy to loaded_clients_list dht->loaded_nodes_list = (Node_format *)calloc(MAX_SAVED_DHT_NODES, sizeof(Node_format)); + if (dht->loaded_nodes_list == nullptr) { + LOGGER_ERROR(dht->log, "could not allocate %u nodes", MAX_SAVED_DHT_NODES); + dht->loaded_num_nodes = 0; + break; + } + const int num = unpack_nodes(dht->loaded_nodes_list, MAX_SAVED_DHT_NODES, nullptr, data, length, 0); if (num > 0) { @@ -2967,8 +2987,8 @@ bool dht_isconnected(const DHT *dht) for (uint32_t i = 0; i < LCLIENT_LIST; ++i) { const Client_data *const client = &dht->close_clientlist[i]; - if (!assoc_timeout(dht->mono_time, &client->assoc4) || - !assoc_timeout(dht->mono_time, &client->assoc6)) { + if (!assoc_timeout(dht->last_run, &client->assoc4) || + !assoc_timeout(dht->last_run, &client->assoc6)) { return true; } } @@ -2984,12 +3004,12 @@ bool dht_non_lan_connected(const DHT *dht) for (uint32_t i = 0; i < LCLIENT_LIST; ++i) { const Client_data *const client = &dht->close_clientlist[i]; - if (!assoc_timeout(dht->mono_time, &client->assoc4) + if (!assoc_timeout(dht->last_run, &client->assoc4) && !ip_is_lan(client->assoc4.ip_port.ip)) { return true; } - if (!assoc_timeout(dht->mono_time, &client->assoc6) + if (!assoc_timeout(dht->last_run, &client->assoc6) && !ip_is_lan(client->assoc6.ip_port.ip)) { return true; } diff --git a/protocols/Tox/libtox/src/toxcore/DHT.h b/protocols/Tox/libtox/src/toxcore/DHT.h index 13f7ce20ed..fcc67251f6 100644 --- a/protocols/Tox/libtox/src/toxcore/DHT.h +++ b/protocols/Tox/libtox/src/toxcore/DHT.h @@ -17,10 +17,14 @@ #include <stdbool.h> +#ifdef __cplusplus +extern "C" { +#endif + /* Maximum number of clients stored per friend. */ #define MAX_FRIEND_CLIENTS 8 -#define LCLIENT_NODES (MAX_FRIEND_CLIENTS) +#define LCLIENT_NODES MAX_FRIEND_CLIENTS #define LCLIENT_LENGTH 128 /* A list of the clients mathematically closest to ours. */ @@ -69,9 +73,9 @@ int create_request(const uint8_t *send_public_key, const uint8_t *send_secret_ke const uint8_t *recv_public_key, const uint8_t *data, uint32_t length, uint8_t request_id); /* puts the senders public key in the request in public_key, the data from the request - in data if a friend or ping request was sent to us and returns the length of the data. - packet is the request packet and length is its length - return -1 if not valid request. */ + * in data if a friend or ping request was sent to us and returns the length of the data. + * packet is the request packet and length is its length + * return -1 if not valid request. */ int handle_request(const uint8_t *self_public_key, const uint8_t *self_secret_key, uint8_t *public_key, uint8_t *data, uint8_t *request_id, const uint8_t *packet, uint16_t length); @@ -405,4 +409,8 @@ bool dht_non_lan_connected(const DHT *dht); uint32_t addto_lists(DHT *dht, IP_Port ip_port, const uint8_t *public_key); +#ifdef __cplusplus +} // extern "C" +#endif + #endif diff --git a/protocols/Tox/libtox/src/toxcore/LAN_discovery.c b/protocols/Tox/libtox/src/toxcore/LAN_discovery.c index c3d060145f..3f6951fcc7 100644 --- a/protocols/Tox/libtox/src/toxcore/LAN_discovery.c +++ b/protocols/Tox/libtox/src/toxcore/LAN_discovery.c @@ -70,14 +70,16 @@ static void fetch_broadcast_info(uint16_t port) IP_ADAPTER_INFO *pAdapter = pAdapterInfo; while (pAdapter) { - IP gateway = {0}, subnet_mask = {0}; + IP gateway = {0}; + IP subnet_mask = {0}; if (addr_parse_ip(pAdapter->IpAddressList.IpMask.String, &subnet_mask) && addr_parse_ip(pAdapter->GatewayList.IpAddress.String, &gateway)) { if (net_family_is_ipv4(gateway.family) && net_family_is_ipv4(subnet_mask.family)) { IP_Port *ip_port = &ip_ports[count]; ip_port->ip.family = net_family_ipv4; - uint32_t gateway_ip = net_ntohl(gateway.ip.v4.uint32), subnet_ip = net_ntohl(subnet_mask.ip.v4.uint32); + uint32_t gateway_ip = net_ntohl(gateway.ip.v4.uint32); + uint32_t subnet_ip = net_ntohl(subnet_mask.ip.v4.uint32); uint32_t broadcast_ip = gateway_ip + ~subnet_ip - 1; ip_port->ip.ip.v4.uint32 = net_htonl(broadcast_ip); ip_port->port = port; @@ -329,7 +331,7 @@ bool ip_is_lan(IP ip) if (net_family_is_ipv6(ip.family)) { /* autogenerated for each interface: `FE80::*` (up to `FEBF::*`) - `FF02::1` is - according to RFC 4291 - multicast all-nodes link-local */ + * `FF02::1` is - according to RFC 4291 - multicast all-nodes link-local */ if (((ip.ip.v6.uint8[0] == 0xFF) && (ip.ip.v6.uint8[1] < 3) && (ip.ip.v6.uint8[15] == 1)) || ((ip.ip.v6.uint8[0] == 0xFE) && ((ip.ip.v6.uint8[1] & 0xC0) == 0x80))) { return true; diff --git a/protocols/Tox/libtox/src/toxcore/Messenger.c b/protocols/Tox/libtox/src/toxcore/Messenger.c index 556acc272f..22c3e9e856 100644 --- a/protocols/Tox/libtox/src/toxcore/Messenger.c +++ b/protocols/Tox/libtox/src/toxcore/Messenger.c @@ -239,7 +239,8 @@ int32_t m_addfriend(Messenger *m, const uint8_t *address, const uint8_t *data, u return FAERR_BADCHECKSUM; } - uint16_t check, checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum)); + uint16_t check; + uint16_t checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum)); memcpy(&check, address + CRYPTO_PUBLIC_KEY_SIZE + sizeof(uint32_t), sizeof(check)); if (check != checksum) { @@ -443,26 +444,31 @@ int m_get_friend_connectionstatus(const Messenger *m, int32_t friendnumber) return -1; } - if (m->friendlist[friendnumber].status == FRIEND_ONLINE) { - bool direct_connected = 0; - unsigned int num_online_relays = 0; - int crypt_conn_id = friend_connection_crypt_connection_id(m->fr_c, m->friendlist[friendnumber].friendcon_id); + if (m->friendlist[friendnumber].status != FRIEND_ONLINE) { + return CONNECTION_NONE; + } - // FIXME(sudden6): handle return value - crypto_connection_status(m->net_crypto, crypt_conn_id, &direct_connected, &num_online_relays); + bool direct_connected = 0; + unsigned int num_online_relays = 0; + int crypt_conn_id = friend_connection_crypt_connection_id(m->fr_c, m->friendlist[friendnumber].friendcon_id); - if (direct_connected) { - return CONNECTION_UDP; - } + if (!crypto_connection_status(m->net_crypto, crypt_conn_id, &direct_connected, &num_online_relays)) { + return CONNECTION_NONE; + } - if (num_online_relays) { - return CONNECTION_TCP; - } + if (direct_connected) { + return CONNECTION_UDP; + } - return CONNECTION_UNKNOWN; + if (num_online_relays) { + return CONNECTION_TCP; } - return CONNECTION_NONE; + /* if we have a valid friend connection but do not have an established connection + * we leave the connection status unchanged until the friend connection is either + * established or dropped. + */ + return m->friendlist[friendnumber].last_connection_udp_tcp; } int m_friend_exists(const Messenger *m, int32_t friendnumber) @@ -898,21 +904,13 @@ static void check_friend_tcp_udp(Messenger *m, int32_t friendnumber, void *userd return; } - if (ret == CONNECTION_UNKNOWN) { - if (last_connection_udp_tcp == CONNECTION_UDP) { - return; - } - - ret = CONNECTION_TCP; - } - if (last_connection_udp_tcp != ret) { if (m->friend_connectionstatuschange) { m->friend_connectionstatuschange(m, friendnumber, ret, userdata); } } - m->friendlist[friendnumber].last_connection_udp_tcp = ret; + m->friendlist[friendnumber].last_connection_udp_tcp = (Connection_Status)ret; } static void break_files(const Messenger *m, int32_t friendnumber); @@ -1046,7 +1044,8 @@ int file_get_id(const Messenger *m, int32_t friendnumber, uint32_t filenumber, u } uint32_t temp_filenum; - uint8_t send_receive, file_number; + uint8_t send_receive; + uint8_t file_number; if (filenumber >= (1 << 16)) { send_receive = 1; @@ -1154,8 +1153,6 @@ long int new_filesender(const Messenger *m, int32_t friendnumber, uint32_t file_ ft->requested = 0; - ft->slots_allocated = 0; - ft->paused = FILE_PAUSE_NOT; memcpy(ft->id, file_id, FILE_ID_LENGTH); @@ -1208,7 +1205,8 @@ int file_control(const Messenger *m, int32_t friendnumber, uint32_t filenumber, } uint32_t temp_filenum; - uint8_t send_receive, file_number; + uint8_t send_receive; + uint8_t file_number; if (filenumber >= (1 << 16)) { send_receive = 1; @@ -1435,10 +1433,6 @@ int file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin // TODO(irungentoo): record packet ids to check if other received complete file. ft->transferred += length; - if (ft->slots_allocated) { - --ft->slots_allocated; - } - if (length != MAX_FILE_DATA_SIZE || ft->size == ft->transferred) { ft->status = FILESTATUS_FINISHED; ft->last_packet_number = ret; @@ -1461,52 +1455,46 @@ int file_data(const Messenger *m, int32_t friendnumber, uint32_t filenumber, uin * @param userdata The client userdata to pass along to chunk request callbacks. * @param free_slots A pointer to the number of free send queue slots in the * crypto connection. + * @return true if there's still work to do, false otherwise. * - * @return true if there are still file transfers ongoing, false if all file - * transfers are complete. */ static bool do_all_filetransfers(Messenger *m, int32_t friendnumber, void *userdata, uint32_t *free_slots) { Friend *const friendcon = &m->friendlist[friendnumber]; - uint32_t num = friendcon->num_sending_files; - - bool any_active_fts = false; - // Iterate over all file transfers, including inactive ones. I.e. we always - // iterate exactly MAX_CONCURRENT_FILE_PIPES times. + // Iterate over file transfers as long as we're sending files for (uint32_t i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) { - struct File_Transfers *const ft = &friendcon->file_sending[i]; + if (friendcon->num_sending_files == 0) { + // no active file transfers anymore + return false; + } - // Any status other than NONE means the file transfer is active. - if (ft->status != FILESTATUS_NONE) { - any_active_fts = true; - --num; + if (*free_slots == 0) { + // send buffer full enough + return false; + } - // If the file transfer is complete, we request a chunk of size 0. - if (ft->status == FILESTATUS_FINISHED && friend_received_packet(m, friendnumber, ft->last_packet_number) == 0) { - if (m->file_reqchunk) { - m->file_reqchunk(m, friendnumber, i, ft->transferred, 0, userdata); - } + if (max_speed_reached(m->net_crypto, friend_connection_crypt_connection_id( + m->fr_c, friendcon->friendcon_id))) { + LOGGER_TRACE(m->log, "Maximum connection speed reached"); + // connection doesn't support any more data + return false; + } - // Now it's inactive, we're no longer sending this. - ft->status = FILESTATUS_NONE; - --friendcon->num_sending_files; + struct File_Transfers *const ft = &friendcon->file_sending[i]; + + // If the file transfer is complete, we request a chunk of size 0. + if (ft->status == FILESTATUS_FINISHED && friend_received_packet(m, friendnumber, ft->last_packet_number) == 0) { + if (m->file_reqchunk) { + m->file_reqchunk(m, friendnumber, i, ft->transferred, 0, userdata); } - // Decrease free slots by the number of slots this FT uses. - *free_slots = max_s32(0, (int32_t) * free_slots - ft->slots_allocated); + // Now it's inactive, we're no longer sending this. + ft->status = FILESTATUS_NONE; + --friendcon->num_sending_files; } if (ft->status == FILESTATUS_TRANSFERRING && ft->paused == FILE_PAUSE_NOT) { - if (max_speed_reached(m->net_crypto, friend_connection_crypt_connection_id( - m->fr_c, friendcon->friendcon_id))) { - *free_slots = 0; - } - - if (*free_slots == 0) { - continue; - } - if (ft->size == 0) { /* Send 0 data to friend if file is 0 length. */ file_data(m, friendnumber, i, 0, nullptr, 0); @@ -1518,9 +1506,6 @@ static bool do_all_filetransfers(Messenger *m, int32_t friendnumber, void *userd continue; } - // Allocate 1 slot to this file transfer. - ++ft->slots_allocated; - const uint16_t length = min_u64(ft->size - ft->requested, MAX_FILE_DATA_SIZE); const uint64_t position = ft->requested; ft->requested += length; @@ -1532,13 +1517,9 @@ static bool do_all_filetransfers(Messenger *m, int32_t friendnumber, void *userd // The allocated slot is no longer free. --*free_slots; } - - if (num == 0) { - continue; - } } - return any_active_fts; + return true; } static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber, void *userdata) @@ -1560,19 +1541,22 @@ static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber, void *userdat // transfers might block other traffic for a long time. free_slots = max_s32(0, (int32_t)free_slots - MIN_SLOTS_FREE); - bool any_active_fts = true; - uint32_t loop_counter = 0; // Maximum number of outer loops below. If the client doesn't send file // chunks from within the chunk request callback handler, we never realise // that the file transfer has finished and may end up in an infinite loop. // - // TODO(zoff99): Fix this to exit the loop properly when we're done - // requesting all chunks for all file transfers. + // Request up to that number of chunks per file from the client const uint32_t max_ft_loops = 16; - while (((free_slots > 0) || loop_counter == 0) && any_active_fts && (loop_counter < max_ft_loops)) { - any_active_fts = do_all_filetransfers(m, friendnumber, userdata, &free_slots); - ++loop_counter; + for (uint32_t i = 0; i < max_ft_loops; ++i) { + if (!do_all_filetransfers(m, friendnumber, userdata, &free_slots)) { + break; + } + + if (free_slots == 0) { + // stop when the buffer is full enough + break; + } } } @@ -1977,8 +1961,8 @@ Messenger *new_messenger(Mono_Time *mono_time, Messenger_Options *options, unsig m->onion = new_onion(m->mono_time, m->dht); m->onion_a = new_onion_announce(m->mono_time, m->dht); - m->onion_c = new_onion_client(m->mono_time, m->net_crypto); - m->fr_c = new_friend_connections(m->mono_time, m->onion_c, options->local_discovery_enabled); + m->onion_c = new_onion_client(m->log, m->mono_time, m->net_crypto); + m->fr_c = new_friend_connections(m->log, m->mono_time, m->onion_c, options->local_discovery_enabled); if (!(m->onion && m->onion_a && m->onion_c && m->fr_c)) { kill_friend_connections(m->fr_c); @@ -1995,8 +1979,8 @@ Messenger *new_messenger(Mono_Time *mono_time, Messenger_Options *options, unsig } if (options->tcp_server_port) { - m->tcp_server = new_TCP_server(options->ipv6enabled, 1, &options->tcp_server_port, dht_get_self_secret_key(m->dht), - m->onion); + m->tcp_server = new_TCP_server(m->log, options->ipv6enabled, 1, &options->tcp_server_port, + dht_get_self_secret_key(m->dht), m->onion); if (m->tcp_server == nullptr) { kill_friend_connections(m->fr_c); @@ -2507,7 +2491,7 @@ static char *id_to_string(const uint8_t *pk, char *id_str, size_t length) } /* Minimum messenger run interval in ms - TODO(mannol): A/V */ + * TODO(mannol): A/V */ #define MIN_RUN_INTERVAL 50 /* Return the time in milliseconds before do_messenger() should be called again @@ -2567,9 +2551,9 @@ void do_messenger(Messenger *m, void *userdata) if (mono_time_get(m->mono_time) > m->lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) { m->lastdump = mono_time_get(m->mono_time); - uint32_t client, last_pinged; + uint32_t last_pinged; - for (client = 0; client < LCLIENT_LIST; ++client) { + for (uint32_t client = 0; client < LCLIENT_LIST; ++client) { const Client_data *cptr = dht_get_close_client(m->dht, client); const IPPTsPng *const assocs[] = { &cptr->assoc4, &cptr->assoc6, nullptr }; @@ -2594,14 +2578,12 @@ void do_messenger(Messenger *m, void *userdata) } - uint32_t friend_idx, dhtfriend; - /* dht contains additional "friends" (requests) */ uint32_t num_dhtfriends = dht_get_num_friends(m->dht); VLA(int32_t, m2dht, num_dhtfriends); VLA(int32_t, dht2m, num_dhtfriends); - for (friend_idx = 0; friend_idx < num_dhtfriends; ++friend_idx) { + for (uint32_t friend_idx = 0; friend_idx < num_dhtfriends; ++friend_idx) { m2dht[friend_idx] = -1; dht2m[friend_idx] = -1; @@ -2609,7 +2591,7 @@ void do_messenger(Messenger *m, void *userdata) continue; } - for (dhtfriend = 0; dhtfriend < dht_get_num_friends(m->dht); ++dhtfriend) { + for (uint32_t dhtfriend = 0; dhtfriend < dht_get_num_friends(m->dht); ++dhtfriend) { if (id_equal(m->friendlist[friend_idx].real_pk, dht_get_friend_public_key(m->dht, dhtfriend))) { m2dht[friend_idx] = dhtfriend; break; @@ -2617,7 +2599,7 @@ void do_messenger(Messenger *m, void *userdata) } } - for (friend_idx = 0; friend_idx < num_dhtfriends; ++friend_idx) { + for (uint32_t friend_idx = 0; friend_idx < num_dhtfriends; ++friend_idx) { if (m2dht[friend_idx] >= 0) { dht2m[m2dht[friend_idx]] = friend_idx; } @@ -2630,7 +2612,7 @@ void do_messenger(Messenger *m, void *userdata) Friend *msgfptr; DHT_Friend *dhtfptr; - for (friend_idx = 0; friend_idx < num_dhtfriends; ++friend_idx) { + for (uint32_t friend_idx = 0; friend_idx < num_dhtfriends; ++friend_idx) { if (dht2m[friend_idx] >= 0) { msgfptr = &m->friendlist[dht2m[friend_idx]]; } else { @@ -2650,7 +2632,7 @@ void do_messenger(Messenger *m, void *userdata) id_to_string(dht_friend_public_key(dhtfptr), id_str, sizeof(id_str))); } - for (client = 0; client < MAX_FRIEND_CLIENTS; ++client) { + for (uint32_t client = 0; client < MAX_FRIEND_CLIENTS; ++client) { const Client_data *cptr = dht_friend_client(dhtfptr, client); const IPPTsPng *const assocs[] = {&cptr->assoc4, &cptr->assoc6}; diff --git a/protocols/Tox/libtox/src/toxcore/Messenger.h b/protocols/Tox/libtox/src/toxcore/Messenger.h index 31526b631d..673fd425a2 100644 --- a/protocols/Tox/libtox/src/toxcore/Messenger.h +++ b/protocols/Tox/libtox/src/toxcore/Messenger.h @@ -109,7 +109,6 @@ typedef enum Connection_Status { CONNECTION_NONE, CONNECTION_TCP, CONNECTION_UDP, - CONNECTION_UNKNOWN, } Connection_Status; /* USERSTATUS - @@ -132,7 +131,6 @@ struct File_Transfers { uint8_t paused; /* 0: not paused, 1 = paused by us, 2 = paused by other, 3 = paused by both. */ uint32_t last_packet_number; /* number of the last packet sent. */ uint64_t requested; /* total data requested by the request chunk callback */ - unsigned int slots_allocated; /* number of slots allocated to this transfer. */ uint8_t id[FILE_ID_LENGTH]; }; typedef enum Filestatus { @@ -225,7 +223,7 @@ typedef struct Friend { uint32_t message_id; // a semi-unique id used in read receipts. uint32_t friendrequest_nospam; // The nospam number used in the friend request. uint64_t last_seen_time; - uint8_t last_connection_udp_tcp; + Connection_Status last_connection_udp_tcp; struct File_Transfers file_sending[MAX_CONCURRENT_FILE_PIPES]; uint32_t num_sending_files; struct File_Transfers file_receiving[MAX_CONCURRENT_FILE_PIPES]; @@ -360,7 +358,7 @@ int getfriendcon_id(const Messenger *m, int32_t friendnumber); */ int m_delfriend(Messenger *m, int32_t friendnumber); -/* Checks friend's connecting status. +/* Checks friend's connection status. * * return CONNECTION_UDP (2) if friend is directly connected to us (Online UDP). * return CONNECTION_TCP (1) if friend is connected to us (Online TCP). diff --git a/protocols/Tox/libtox/src/toxcore/TCP_client.c b/protocols/Tox/libtox/src/toxcore/TCP_client.c index 408ec4891a..1405d9b2c3 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_client.c +++ b/protocols/Tox/libtox/src/toxcore/TCP_client.c @@ -151,12 +151,12 @@ static int proxy_http_generate_connection_request(TCP_Client_Connection *tcp_con * return 0 if no data received. * return -1 on failure (connection refused). */ -static int proxy_http_read_connection_response(TCP_Client_Connection *tcp_conn) +static int proxy_http_read_connection_response(const Logger *logger, TCP_Client_Connection *tcp_conn) { char success[] = "200"; uint8_t data[16]; // draining works the best if the length is a power of 2 - int ret = read_TCP_packet(tcp_conn->sock, data, sizeof(data) - 1); + int ret = read_TCP_packet(logger, tcp_conn->sock, data, sizeof(data) - 1); if (ret == -1) { return 0; @@ -170,7 +170,7 @@ static int proxy_http_read_connection_response(TCP_Client_Connection *tcp_conn) if (data_left) { VLA(uint8_t, temp_data, data_left); - read_TCP_packet(tcp_conn->sock, temp_data, data_left); + read_TCP_packet(logger, tcp_conn->sock, temp_data, data_left); } return 1; @@ -193,10 +193,10 @@ static void proxy_socks5_generate_handshake(TCP_Client_Connection *tcp_conn) * return 0 if no data received. * return -1 on failure (connection refused). */ -static int socks5_read_handshake_response(TCP_Client_Connection *tcp_conn) +static int socks5_read_handshake_response(const Logger *logger, TCP_Client_Connection *tcp_conn) { uint8_t data[2]; - int ret = read_TCP_packet(tcp_conn->sock, data, sizeof(data)); + int ret = read_TCP_packet(logger, tcp_conn->sock, data, sizeof(data)); if (ret == -1) { return 0; @@ -239,11 +239,11 @@ static void proxy_socks5_generate_connection_request(TCP_Client_Connection *tcp_ * return 0 if no data received. * return -1 on failure (connection refused). */ -static int proxy_socks5_read_connection_response(TCP_Client_Connection *tcp_conn) +static int proxy_socks5_read_connection_response(const Logger *logger, TCP_Client_Connection *tcp_conn) { if (net_family_is_ipv4(tcp_conn->ip_port.ip.family)) { uint8_t data[4 + sizeof(IP4) + sizeof(uint16_t)]; - int ret = read_TCP_packet(tcp_conn->sock, data, sizeof(data)); + int ret = read_TCP_packet(logger, tcp_conn->sock, data, sizeof(data)); if (ret == -1) { return 0; @@ -254,7 +254,7 @@ static int proxy_socks5_read_connection_response(TCP_Client_Connection *tcp_conn } } else { uint8_t data[4 + sizeof(IP6) + sizeof(uint16_t)]; - int ret = read_TCP_packet(tcp_conn->sock, data, sizeof(data)); + int ret = read_TCP_packet(logger, tcp_conn->sock, data, sizeof(data)); if (ret == -1) { return 0; @@ -900,10 +900,10 @@ static int handle_TCP_client_packet(TCP_Client_Connection *conn, const uint8_t * return 0; } -static bool tcp_process_packet(TCP_Client_Connection *conn, void *userdata) +static bool tcp_process_packet(const Logger *logger, TCP_Client_Connection *conn, void *userdata) { uint8_t packet[MAX_PACKET_SIZE]; - const int len = read_packet_TCP_secure_connection(conn->sock, &conn->next_packet_length, conn->shared_key, + const int len = read_packet_TCP_secure_connection(logger, conn->sock, &conn->next_packet_length, conn->shared_key, conn->recv_nonce, packet, sizeof(packet)); if (len == 0) { @@ -923,7 +923,8 @@ static bool tcp_process_packet(TCP_Client_Connection *conn, void *userdata) return true; } -static int do_confirmed_TCP(TCP_Client_Connection *conn, const Mono_Time *mono_time, void *userdata) +static int do_confirmed_TCP(const Logger *logger, TCP_Client_Connection *conn, const Mono_Time *mono_time, + void *userdata) { client_send_pending_data(conn); tcp_send_ping_response(conn); @@ -947,7 +948,7 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn, const Mono_Time *mono_t return 0; } - while (tcp_process_packet(conn, userdata)) { + while (tcp_process_packet(logger, conn, userdata)) { // Keep reading until error or out of data. continue; } @@ -957,7 +958,8 @@ static int do_confirmed_TCP(TCP_Client_Connection *conn, const Mono_Time *mono_t /* Run the TCP connection */ -void do_TCP_connection(Mono_Time *mono_time, TCP_Client_Connection *tcp_connection, void *userdata) +void do_TCP_connection(const Logger *logger, Mono_Time *mono_time, TCP_Client_Connection *tcp_connection, + void *userdata) { if (tcp_connection->status == TCP_CLIENT_DISCONNECTED) { return; @@ -965,7 +967,7 @@ void do_TCP_connection(Mono_Time *mono_time, TCP_Client_Connection *tcp_connecti if (tcp_connection->status == TCP_CLIENT_PROXY_HTTP_CONNECTING) { if (client_send_pending_data(tcp_connection) == 0) { - int ret = proxy_http_read_connection_response(tcp_connection); + int ret = proxy_http_read_connection_response(logger, tcp_connection); if (ret == -1) { tcp_connection->kill_at = 0; @@ -981,7 +983,7 @@ void do_TCP_connection(Mono_Time *mono_time, TCP_Client_Connection *tcp_connecti if (tcp_connection->status == TCP_CLIENT_PROXY_SOCKS5_CONNECTING) { if (client_send_pending_data(tcp_connection) == 0) { - int ret = socks5_read_handshake_response(tcp_connection); + int ret = socks5_read_handshake_response(logger, tcp_connection); if (ret == -1) { tcp_connection->kill_at = 0; @@ -997,7 +999,7 @@ void do_TCP_connection(Mono_Time *mono_time, TCP_Client_Connection *tcp_connecti if (tcp_connection->status == TCP_CLIENT_PROXY_SOCKS5_UNCONFIRMED) { if (client_send_pending_data(tcp_connection) == 0) { - int ret = proxy_socks5_read_connection_response(tcp_connection); + int ret = proxy_socks5_read_connection_response(logger, tcp_connection); if (ret == -1) { tcp_connection->kill_at = 0; @@ -1019,7 +1021,7 @@ void do_TCP_connection(Mono_Time *mono_time, TCP_Client_Connection *tcp_connecti if (tcp_connection->status == TCP_CLIENT_UNCONFIRMED) { uint8_t data[TCP_SERVER_HANDSHAKE_SIZE]; - int len = read_TCP_packet(tcp_connection->sock, data, sizeof(data)); + int len = read_TCP_packet(logger, tcp_connection->sock, data, sizeof(data)); if (sizeof(data) == len) { if (handle_handshake(tcp_connection, data) == 0) { @@ -1033,7 +1035,7 @@ void do_TCP_connection(Mono_Time *mono_time, TCP_Client_Connection *tcp_connecti } if (tcp_connection->status == TCP_CLIENT_CONFIRMED) { - do_confirmed_TCP(tcp_connection, mono_time, userdata); + do_confirmed_TCP(logger, tcp_connection, mono_time, userdata); } if (tcp_connection->kill_at <= mono_time_get(mono_time)) { diff --git a/protocols/Tox/libtox/src/toxcore/TCP_client.h b/protocols/Tox/libtox/src/toxcore/TCP_client.h index cecf5a6d5f..ed4304cb00 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_client.h +++ b/protocols/Tox/libtox/src/toxcore/TCP_client.h @@ -54,7 +54,8 @@ TCP_Client_Connection *new_TCP_connection(const Mono_Time *mono_time, IP_Port ip /* Run the TCP connection */ -void do_TCP_connection(Mono_Time *mono_time, TCP_Client_Connection *tcp_connection, void *userdata); +void do_TCP_connection(const Logger *logger, Mono_Time *mono_time, TCP_Client_Connection *tcp_connection, + void *userdata); /* Kill the TCP connection */ diff --git a/protocols/Tox/libtox/src/toxcore/TCP_connection.c b/protocols/Tox/libtox/src/toxcore/TCP_connection.c index adef31751f..ac933cc3cc 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_connection.c +++ b/protocols/Tox/libtox/src/toxcore/TCP_connection.c @@ -125,7 +125,7 @@ static bool connections_number_is_valid(const TCP_Connections *tcp_c, int connec */ static bool tcp_connections_number_is_valid(const TCP_Connections *tcp_c, int tcp_connections_number) { - if ((unsigned int)tcp_connections_number >= tcp_c->tcp_connections_length) { + if ((uint32_t)tcp_connections_number >= tcp_c->tcp_connections_length) { return false; } @@ -173,9 +173,7 @@ static int create_connection(TCP_Connections *tcp_c) */ static int create_tcp_connection(TCP_Connections *tcp_c) { - uint32_t i; - - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { if (tcp_c->tcp_connections[i].status == TCP_CONN_NONE) { return i; } @@ -231,9 +229,10 @@ static int wipe_tcp_connection(TCP_Connections *tcp_c, int tcp_connections_numbe return -1; } - uint32_t i; memset(&tcp_c->tcp_connections[tcp_connections_number], 0, sizeof(TCP_con)); + uint32_t i; + for (i = tcp_c->tcp_connections_length; i != 0; --i) { if (tcp_c->tcp_connections[i - 1].status != TCP_CONN_NONE) { break; @@ -375,7 +374,7 @@ int get_random_tcp_onion_conn_number(TCP_Connections *tcp_c) * return 0 on success. * return -1 on failure. */ -int tcp_send_onion_request(TCP_Connections *tcp_c, unsigned int tcp_connections_number, const uint8_t *data, +int tcp_send_onion_request(TCP_Connections *tcp_c, uint32_t tcp_connections_number, const uint8_t *data, uint16_t length) { if (tcp_connections_number >= tcp_c->tcp_connections_length) { @@ -474,9 +473,7 @@ static int find_tcp_connection_to(TCP_Connections *tcp_c, const uint8_t *public_ */ static int find_tcp_connection_relay(TCP_Connections *tcp_c, const uint8_t *relay_pk) { - unsigned int i; - - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { TCP_con *tcp_con = get_tcp_connection(tcp_c, i); if (tcp_con) { @@ -695,9 +692,9 @@ static int rm_tcp_connection_from_conn(TCP_Connection_to *con_to, unsigned int t */ static unsigned int online_tcp_connection_from_conn(TCP_Connection_to *con_to) { - unsigned int i, count = 0; + unsigned int count = 0; - for (i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) { + for (unsigned int i = 0; i < MAX_FRIEND_TCP_CONNECTIONS; ++i) { if (con_to->connections[i].tcp_connection) { if (con_to->connections[i].status == TCP_CONNECTIONS_STATUS_ONLINE) { ++count; @@ -1089,9 +1086,9 @@ static int tcp_relay_on_online(TCP_Connections *tcp_c, int tcp_connections_numbe return -1; } - unsigned int i, sent = 0; + unsigned int sent = 0; - for (i = 0; i < tcp_c->connections_length; ++i) { + for (unsigned int i = 0; i < tcp_c->connections_length; ++i) { TCP_Connection_to *con_to = get_connection(tcp_c, i); if (con_to) { @@ -1314,9 +1311,7 @@ int set_tcp_onion_status(TCP_Connections *tcp_c, bool status) } if (status) { - unsigned int i; - - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { TCP_con *tcp_con = get_tcp_connection(tcp_c, i); if (tcp_con) { @@ -1334,7 +1329,7 @@ int set_tcp_onion_status(TCP_Connections *tcp_c, bool status) if (tcp_c->onion_num_conns < NUM_ONION_TCP_CONNECTIONS) { unsigned int wakeup = NUM_ONION_TCP_CONNECTIONS - tcp_c->onion_num_conns; - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { TCP_con *tcp_con = get_tcp_connection(tcp_c, i); if (tcp_con) { @@ -1351,9 +1346,7 @@ int set_tcp_onion_status(TCP_Connections *tcp_c, bool status) tcp_c->onion_status = 1; } else { - unsigned int i; - - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { TCP_con *tcp_con = get_tcp_connection(tcp_c, i); if (tcp_con) { @@ -1398,48 +1391,48 @@ TCP_Connections *new_tcp_connections(Mono_Time *mono_time, const uint8_t *secret return temp; } -static void do_tcp_conns(TCP_Connections *tcp_c, void *userdata) +static void do_tcp_conns(const Logger *logger, TCP_Connections *tcp_c, void *userdata) { - unsigned int i; - - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { TCP_con *tcp_con = get_tcp_connection(tcp_c, i); - if (tcp_con) { - if (tcp_con->status != TCP_CONN_SLEEPING) { - do_TCP_connection(tcp_c->mono_time, tcp_con->connection, userdata); + if (tcp_con == nullptr) { + continue; + } - /* callbacks can change TCP connection address. */ - tcp_con = get_tcp_connection(tcp_c, i); + if (tcp_con->status != TCP_CONN_SLEEPING) { + do_TCP_connection(logger, tcp_c->mono_time, tcp_con->connection, userdata); - // Make sure the TCP connection wasn't dropped in any of the callbacks. - assert(tcp_con != nullptr); + /* callbacks can change TCP connection address. */ + tcp_con = get_tcp_connection(tcp_c, i); - if (tcp_con_status(tcp_con->connection) == TCP_CLIENT_DISCONNECTED) { - if (tcp_con->status == TCP_CONN_CONNECTED) { - reconnect_tcp_relay_connection(tcp_c, i); - } else { - kill_tcp_relay_connection(tcp_c, i); - } + // Make sure the TCP connection wasn't dropped in any of the callbacks. + assert(tcp_con != nullptr); - continue; + if (tcp_con_status(tcp_con->connection) == TCP_CLIENT_DISCONNECTED) { + if (tcp_con->status == TCP_CONN_CONNECTED) { + reconnect_tcp_relay_connection(tcp_c, i); + } else { + kill_tcp_relay_connection(tcp_c, i); } - if (tcp_con->status == TCP_CONN_VALID && tcp_con_status(tcp_con->connection) == TCP_CLIENT_CONFIRMED) { - tcp_relay_on_online(tcp_c, i); - } + continue; + } - if (tcp_con->status == TCP_CONN_CONNECTED && !tcp_con->onion && tcp_con->lock_count - && tcp_con->lock_count == tcp_con->sleep_count - && mono_time_is_timeout(tcp_c->mono_time, tcp_con->connected_time, TCP_CONNECTION_ANNOUNCE_TIMEOUT)) { - sleep_tcp_relay_connection(tcp_c, i); - } + if (tcp_con->status == TCP_CONN_VALID && tcp_con_status(tcp_con->connection) == TCP_CLIENT_CONFIRMED) { + tcp_relay_on_online(tcp_c, i); } - if (tcp_con->status == TCP_CONN_SLEEPING && tcp_con->unsleep) { - unsleep_tcp_relay_connection(tcp_c, i); + if (tcp_con->status == TCP_CONN_CONNECTED && !tcp_con->onion && tcp_con->lock_count + && tcp_con->lock_count == tcp_con->sleep_count + && mono_time_is_timeout(tcp_c->mono_time, tcp_con->connected_time, TCP_CONNECTION_ANNOUNCE_TIMEOUT)) { + sleep_tcp_relay_connection(tcp_c, i); } } + + if (tcp_con->status == TCP_CONN_SLEEPING && tcp_con->unsleep) { + unsleep_tcp_relay_connection(tcp_c, i); + } } } @@ -1449,12 +1442,11 @@ static void kill_nonused_tcp(TCP_Connections *tcp_c) return; } - unsigned int i; - unsigned int num_online = 0; - unsigned int num_kill = 0; + uint32_t num_online = 0; + uint32_t num_kill = 0; VLA(unsigned int, to_kill, tcp_c->tcp_connections_length); - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { TCP_con *tcp_con = get_tcp_connection(tcp_c, i); if (tcp_con) { @@ -1474,28 +1466,26 @@ static void kill_nonused_tcp(TCP_Connections *tcp_c) return; } - unsigned int n = num_online - RECOMMENDED_FRIEND_TCP_CONNECTIONS; + uint32_t n = num_online - RECOMMENDED_FRIEND_TCP_CONNECTIONS; if (n < num_kill) { num_kill = n; } - for (i = 0; i < num_kill; ++i) { + for (uint32_t i = 0; i < num_kill; ++i) { kill_tcp_relay_connection(tcp_c, to_kill[i]); } } -void do_tcp_connections(TCP_Connections *tcp_c, void *userdata) +void do_tcp_connections(const Logger *logger, TCP_Connections *tcp_c, void *userdata) { - do_tcp_conns(tcp_c, userdata); + do_tcp_conns(logger, tcp_c, userdata); kill_nonused_tcp(tcp_c); } void kill_tcp_connections(TCP_Connections *tcp_c) { - unsigned int i; - - for (i = 0; i < tcp_c->tcp_connections_length; ++i) { + for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) { kill_TCP_connection(tcp_c->tcp_connections[i].connection); } diff --git a/protocols/Tox/libtox/src/toxcore/TCP_connection.h b/protocols/Tox/libtox/src/toxcore/TCP_connection.h index a8e522d343..0ae3304541 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_connection.h +++ b/protocols/Tox/libtox/src/toxcore/TCP_connection.h @@ -27,10 +27,10 @@ #define MAX_FRIEND_TCP_CONNECTIONS 6 /* Time until connection to friend gets killed (if it doesn't get locked within that time) */ -#define TCP_CONNECTION_ANNOUNCE_TIMEOUT (TCP_CONNECTION_TIMEOUT) +#define TCP_CONNECTION_ANNOUNCE_TIMEOUT TCP_CONNECTION_TIMEOUT /* The amount of recommended connections for each friend - NOTE: Must be at most (MAX_FRIEND_TCP_CONNECTIONS / 2) */ + * NOTE: Must be at most (MAX_FRIEND_TCP_CONNECTIONS / 2) */ #define RECOMMENDED_FRIEND_TCP_CONNECTIONS (MAX_FRIEND_TCP_CONNECTIONS / 2) /* Number of TCP connections used for onion purposes. */ @@ -206,7 +206,8 @@ uint32_t tcp_copy_connected_relays(TCP_Connections *tcp_c, Node_format *tcp_rela */ TCP_Connections *new_tcp_connections(Mono_Time *mono_time, const uint8_t *secret_key, TCP_Proxy_Info *proxy_info); -void do_tcp_connections(TCP_Connections *tcp_c, void *userdata); +void do_tcp_connections(const Logger *logger, TCP_Connections *tcp_c, void *userdata); + void kill_tcp_connections(TCP_Connections *tcp_c); #endif diff --git a/protocols/Tox/libtox/src/toxcore/TCP_server.c b/protocols/Tox/libtox/src/toxcore/TCP_server.c index b22bdb8084..79a9e560c3 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_server.c +++ b/protocols/Tox/libtox/src/toxcore/TCP_server.c @@ -12,7 +12,6 @@ #include "TCP_server.h" -#include <stdio.h> #include <stdlib.h> #include <string.h> #if !defined(_WIN32) && !defined(__WIN32__) && !defined (WIN32) @@ -66,6 +65,7 @@ typedef struct TCP_Secure_Connection { struct TCP_Server { + const Logger *logger; Onion *onion; #ifdef TCP_SERVER_USE_EPOLL @@ -220,7 +220,7 @@ static int add_accepted(TCP_Server *tcp_server, const Mono_Time *mono_time, TCP_ } if (index == -1) { - fprintf(stderr, "FAIL index is -1\n"); + LOGGER_ERROR(tcp_server->logger, "FAIL index is -1"); return -1; } @@ -275,7 +275,7 @@ static int del_accepted(TCP_Server *tcp_server, int index) * return 0 if nothing has been read from socket. * return -1 on failure. */ -uint16_t read_TCP_length(Socket sock) +uint16_t read_TCP_length(const Logger *logger, Socket sock) { const unsigned int count = net_socket_data_recv_buffer(sock); @@ -284,7 +284,7 @@ uint16_t read_TCP_length(Socket sock) const int len = net_recv(sock, &length, sizeof(uint16_t)); if (len != sizeof(uint16_t)) { - fprintf(stderr, "FAIL recv packet\n"); + LOGGER_ERROR(logger, "FAIL recv packet"); return 0; } @@ -305,7 +305,7 @@ uint16_t read_TCP_length(Socket sock) * return length on success * return -1 on failure/no data in buffer. */ -int read_TCP_packet(Socket sock, uint8_t *data, uint16_t length) +int read_TCP_packet(const Logger *logger, Socket sock, uint8_t *data, uint16_t length) { unsigned int count = net_socket_data_recv_buffer(sock); @@ -313,7 +313,7 @@ int read_TCP_packet(Socket sock, uint8_t *data, uint16_t length) const int len = net_recv(sock, data, length); if (len != length) { - fprintf(stderr, "FAIL recv packet\n"); + LOGGER_ERROR(logger, "FAIL recv packet"); return -1; } @@ -327,11 +327,11 @@ int read_TCP_packet(Socket sock, uint8_t *data, uint16_t length) * return 0 if could not read any packet. * return -1 on failure (connection must be killed). */ -int read_packet_TCP_secure_connection(Socket sock, uint16_t *next_packet_length, const uint8_t *shared_key, - uint8_t *recv_nonce, uint8_t *data, uint16_t max_len) +int read_packet_TCP_secure_connection(const Logger *logger, Socket sock, uint16_t *next_packet_length, + const uint8_t *shared_key, uint8_t *recv_nonce, uint8_t *data, uint16_t max_len) { if (*next_packet_length == 0) { - uint16_t len = read_TCP_length(sock); + uint16_t len = read_TCP_length(logger, sock); if (len == (uint16_t) -1) { return -1; @@ -349,7 +349,7 @@ int read_packet_TCP_secure_connection(Socket sock, uint16_t *next_packet_length, } VLA(uint8_t, data_encrypted, *next_packet_length); - int len_packet = read_TCP_packet(sock, data_encrypted, *next_packet_length); + int len_packet = read_TCP_packet(logger, sock, data_encrypted, *next_packet_length); if (len_packet != *next_packet_length) { return 0; @@ -617,10 +617,10 @@ static int handle_TCP_handshake(TCP_Secure_Connection *con, const uint8_t *data, * return 0 if we didn't get it yet. * return -1 if the connection must be killed. */ -static int read_connection_handshake(TCP_Secure_Connection *con, const uint8_t *self_secret_key) +static int read_connection_handshake(const Logger *logger, TCP_Secure_Connection *con, const uint8_t *self_secret_key) { uint8_t data[TCP_CLIENT_HANDSHAKE_SIZE]; - const int len = read_TCP_packet(con->sock, data, TCP_CLIENT_HANDSHAKE_SIZE); + const int len = read_TCP_packet(logger, con->sock, data, TCP_CLIENT_HANDSHAKE_SIZE); if (len != -1) { return handle_TCP_handshake(con, data, len, self_secret_key); @@ -1055,8 +1055,8 @@ static Socket new_listening_TCP_socket(Family family, uint16_t port) return sock; } -TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, const uint8_t *secret_key, - Onion *onion) +TCP_Server *new_TCP_server(const Logger *logger, uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, + const uint8_t *secret_key, Onion *onion) { if (num_sockets == 0 || ports == nullptr) { return nullptr; @@ -1072,6 +1072,8 @@ TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uin return nullptr; } + temp->logger = logger; + temp->socks_listening = (Socket *)calloc(num_sockets, sizeof(Socket)); if (temp->socks_listening == nullptr) { @@ -1156,7 +1158,8 @@ static int do_incoming(TCP_Server *tcp_server, uint32_t i) return -1; } - int ret = read_connection_handshake(&tcp_server->incoming_connection_queue[i], tcp_server->secret_key); + int ret = read_connection_handshake(tcp_server->logger, &tcp_server->incoming_connection_queue[i], + tcp_server->secret_key); if (ret == -1) { kill_TCP_secure_connection(&tcp_server->incoming_connection_queue[i]); @@ -1187,8 +1190,8 @@ static int do_unconfirmed(TCP_Server *tcp_server, const Mono_Time *mono_time, ui } uint8_t packet[MAX_PACKET_SIZE]; - int len = read_packet_TCP_secure_connection(conn->sock, &conn->next_packet_length, conn->shared_key, conn->recv_nonce, - packet, sizeof(packet)); + int len = read_packet_TCP_secure_connection(tcp_server->logger, conn->sock, &conn->next_packet_length, conn->shared_key, + conn->recv_nonce, packet, sizeof(packet)); if (len == 0) { return -1; @@ -1207,7 +1210,7 @@ static bool tcp_process_secure_packet(TCP_Server *tcp_server, uint32_t i) TCP_Secure_Connection *const conn = &tcp_server->accepted_connection_array[i]; uint8_t packet[MAX_PACKET_SIZE]; - int len = read_packet_TCP_secure_connection(conn->sock, &conn->next_packet_length, conn->shared_key, + int len = read_packet_TCP_secure_connection(tcp_server->logger, conn->sock, &conn->next_packet_length, conn->shared_key, conn->recv_nonce, packet, sizeof(packet)); if (len == 0) { diff --git a/protocols/Tox/libtox/src/toxcore/TCP_server.h b/protocols/Tox/libtox/src/toxcore/TCP_server.h index 5862a4733f..46dd03304f 100644 --- a/protocols/Tox/libtox/src/toxcore/TCP_server.h +++ b/protocols/Tox/libtox/src/toxcore/TCP_server.h @@ -69,8 +69,8 @@ size_t tcp_server_listen_count(const TCP_Server *tcp_server); /* Create new TCP server instance. */ -TCP_Server *new_TCP_server(uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, const uint8_t *secret_key, - Onion *onion); +TCP_Server *new_TCP_server(const Logger *logger, uint8_t ipv6_enabled, uint16_t num_sockets, const uint16_t *ports, + const uint8_t *secret_key, Onion *onion); /* Run the TCP_server */ @@ -87,21 +87,21 @@ void kill_TCP_server(TCP_Server *tcp_server); * return 0 if nothing has been read from socket. * return -1 on failure. */ -uint16_t read_TCP_length(Socket sock); +uint16_t read_TCP_length(const Logger *logger, Socket sock); /* Read length bytes from socket. * * return length on success * return -1 on failure/no data in buffer. */ -int read_TCP_packet(Socket sock, uint8_t *data, uint16_t length); +int read_TCP_packet(const Logger *logger, Socket sock, uint8_t *data, uint16_t length); /* return length of received packet on success. * return 0 if could not read any packet. * return -1 on failure (connection must be killed). */ -int read_packet_TCP_secure_connection(Socket sock, uint16_t *next_packet_length, const uint8_t *shared_key, - uint8_t *recv_nonce, uint8_t *data, uint16_t max_len); +int read_packet_TCP_secure_connection(const Logger *logger, Socket sock, uint16_t *next_packet_length, + const uint8_t *shared_key, uint8_t *recv_nonce, uint8_t *data, uint16_t max_len); #endif diff --git a/protocols/Tox/libtox/src/toxcore/ccompat.h b/protocols/Tox/libtox/src/toxcore/ccompat.h index 8ff6563d9e..34def21bf9 100644 --- a/protocols/Tox/libtox/src/toxcore/ccompat.h +++ b/protocols/Tox/libtox/src/toxcore/ccompat.h @@ -42,6 +42,9 @@ #if !defined(__cplusplus) || __cplusplus < 201103L #define nullptr NULL +#ifndef static_assert +#define static_assert(cond, msg) extern int unused_for_static_assert +#endif #endif #ifdef __GNUC__ diff --git a/protocols/Tox/libtox/src/toxcore/crypto_core.c b/protocols/Tox/libtox/src/toxcore/crypto_core.c index 2fa4750ff4..35e3a60307 100644 --- a/protocols/Tox/libtox/src/toxcore/crypto_core.c +++ b/protocols/Tox/libtox/src/toxcore/crypto_core.c @@ -33,41 +33,26 @@ #define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES) #endif -#if CRYPTO_PUBLIC_KEY_SIZE != crypto_box_PUBLICKEYBYTES -#error "CRYPTO_PUBLIC_KEY_SIZE should be equal to crypto_box_PUBLICKEYBYTES" -#endif - -#if CRYPTO_SECRET_KEY_SIZE != crypto_box_SECRETKEYBYTES -#error "CRYPTO_SECRET_KEY_SIZE should be equal to crypto_box_SECRETKEYBYTES" -#endif - -#if CRYPTO_SHARED_KEY_SIZE != crypto_box_BEFORENMBYTES -#error "CRYPTO_SHARED_KEY_SIZE should be equal to crypto_box_BEFORENMBYTES" -#endif - -#if CRYPTO_SYMMETRIC_KEY_SIZE != crypto_box_BEFORENMBYTES -#error "CRYPTO_SYMMETRIC_KEY_SIZE should be equal to crypto_box_BEFORENMBYTES" -#endif - -#if CRYPTO_MAC_SIZE != crypto_box_MACBYTES -#error "CRYPTO_MAC_SIZE should be equal to crypto_box_MACBYTES" -#endif - -#if CRYPTO_NONCE_SIZE != crypto_box_NONCEBYTES -#error "CRYPTO_NONCE_SIZE should be equal to crypto_box_NONCEBYTES" -#endif - -#if CRYPTO_SHA256_SIZE != crypto_hash_sha256_BYTES -#error "CRYPTO_SHA256_SIZE should be equal to crypto_hash_sha256_BYTES" -#endif - -#if CRYPTO_SHA512_SIZE != crypto_hash_sha512_BYTES -#error "CRYPTO_SHA512_SIZE should be equal to crypto_hash_sha512_BYTES" -#endif - -#if CRYPTO_PUBLIC_KEY_SIZE != 32 -#error "CRYPTO_PUBLIC_KEY_SIZE is required to be 32 bytes for public_key_cmp to work," -#endif +//!TOKSTYLE- +static_assert(CRYPTO_PUBLIC_KEY_SIZE == crypto_box_PUBLICKEYBYTES, + "CRYPTO_PUBLIC_KEY_SIZE should be equal to crypto_box_PUBLICKEYBYTES"); +static_assert(CRYPTO_SECRET_KEY_SIZE == crypto_box_SECRETKEYBYTES, + "CRYPTO_SECRET_KEY_SIZE should be equal to crypto_box_SECRETKEYBYTES"); +static_assert(CRYPTO_SHARED_KEY_SIZE == crypto_box_BEFORENMBYTES, + "CRYPTO_SHARED_KEY_SIZE should be equal to crypto_box_BEFORENMBYTES"); +static_assert(CRYPTO_SYMMETRIC_KEY_SIZE == crypto_box_BEFORENMBYTES, + "CRYPTO_SYMMETRIC_KEY_SIZE should be equal to crypto_box_BEFORENMBYTES"); +static_assert(CRYPTO_MAC_SIZE == crypto_box_MACBYTES, + "CRYPTO_MAC_SIZE should be equal to crypto_box_MACBYTES"); +static_assert(CRYPTO_NONCE_SIZE == crypto_box_NONCEBYTES, + "CRYPTO_NONCE_SIZE should be equal to crypto_box_NONCEBYTES"); +static_assert(CRYPTO_SHA256_SIZE == crypto_hash_sha256_BYTES, + "CRYPTO_SHA256_SIZE should be equal to crypto_hash_sha256_BYTES"); +static_assert(CRYPTO_SHA512_SIZE == crypto_hash_sha512_BYTES, + "CRYPTO_SHA512_SIZE should be equal to crypto_hash_sha512_BYTES"); +static_assert(CRYPTO_PUBLIC_KEY_SIZE == 32, + "CRYPTO_PUBLIC_KEY_SIZE is required to be 32 bytes for public_key_cmp to work"); +//!TOKSTYLE+ static uint8_t *crypto_malloc(size_t bytes) { diff --git a/protocols/Tox/libtox/src/toxcore/friend_connection.c b/protocols/Tox/libtox/src/toxcore/friend_connection.c index af5d09e370..496b83b505 100644 --- a/protocols/Tox/libtox/src/toxcore/friend_connection.c +++ b/protocols/Tox/libtox/src/toxcore/friend_connection.c @@ -12,7 +12,6 @@ #include "friend_connection.h" -#include <stdio.h> #include <stdlib.h> #include <string.h> @@ -60,6 +59,7 @@ typedef struct Friend_Conn { struct Friend_Connections { const Mono_Time *mono_time; + const Logger *logger; Net_Crypto *net_crypto; DHT *dht; Onion_Client *onion_c; @@ -273,7 +273,7 @@ static unsigned int send_relays(Friend_Connections *fr_c, int friendcon_id) for (int i = 0; i < n; ++i) { /* Associated the relays being sent with this connection. - On receiving the peer will do the same which will establish the connection. */ + * On receiving the peer will do the same which will establish the connection. */ friend_add_tcp_relay(fr_c, friendcon_id, nodes[i].ip_port, nodes[i].public_key); } @@ -348,7 +348,7 @@ static void change_dht_pk(Friend_Connections *fr_c, int friendcon_id, const uint if (friend_con->dht_lock) { if (dht_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock) != 0) { - printf("a. Could not delete dht peer. Please report this.\n"); + LOGGER_ERROR(fr_c->logger, "a. Could not delete dht peer. Please report this."); return; } @@ -848,7 +848,7 @@ int send_friend_request_packet(Friend_Connections *fr_c, int friendcon_id, uint3 } /* Create new friend_connections instance. */ -Friend_Connections *new_friend_connections(const Mono_Time *mono_time, Onion_Client *onion_c, +Friend_Connections *new_friend_connections(const Logger *logger, const Mono_Time *mono_time, Onion_Client *onion_c, bool local_discovery_enabled) { if (onion_c == nullptr) { @@ -862,6 +862,7 @@ Friend_Connections *new_friend_connections(const Mono_Time *mono_time, Onion_Cli } temp->mono_time = mono_time; + temp->logger = logger; temp->dht = onion_get_dht(onion_c); temp->net_crypto = onion_get_net_crypto(onion_c); temp->onion_c = onion_c; diff --git a/protocols/Tox/libtox/src/toxcore/friend_connection.h b/protocols/Tox/libtox/src/toxcore/friend_connection.h index 92e3870345..fecd745565 100644 --- a/protocols/Tox/libtox/src/toxcore/friend_connection.h +++ b/protocols/Tox/libtox/src/toxcore/friend_connection.h @@ -34,7 +34,7 @@ #define FRIEND_MAX_STORED_TCP_RELAYS (MAX_FRIEND_TCP_CONNECTIONS * 4) /* Max number of tcp relays sent to friends */ -#define MAX_SHARED_RELAYS (RECOMMENDED_FRIEND_TCP_CONNECTIONS) +#define MAX_SHARED_RELAYS RECOMMENDED_FRIEND_TCP_CONNECTIONS /* Interval between the sending of tcp relay information */ #define SHARE_RELAYS_INTERVAL (5 * 60) @@ -148,7 +148,7 @@ typedef int fr_request_cb(void *object, const uint8_t *source_pubkey, const uint void set_friend_request_callback(Friend_Connections *fr_c, fr_request_cb *fr_request_callback, void *object); /* Create new friend_connections instance. */ -Friend_Connections *new_friend_connections(const Mono_Time *mono_time, Onion_Client *onion_c, +Friend_Connections *new_friend_connections(const Logger *logger, const Mono_Time *mono_time, Onion_Client *onion_c, bool local_discovery_enabled); /* main friend_connections loop. */ diff --git a/protocols/Tox/libtox/src/toxcore/group.c b/protocols/Tox/libtox/src/toxcore/group.c index a946e7b8e7..4b331f986e 100644 --- a/protocols/Tox/libtox/src/toxcore/group.c +++ b/protocols/Tox/libtox/src/toxcore/group.c @@ -242,7 +242,8 @@ static int get_peer_index(const Group_c *g, uint16_t peer_number) static uint64_t calculate_comp_value(const uint8_t *pk1, const uint8_t *pk2) { - uint64_t cmp1 = 0, cmp2 = 0; + uint64_t cmp1 = 0; + uint64_t cmp2 = 0; for (size_t i = 0; i < sizeof(uint64_t); ++i) { cmp1 = (cmp1 << 8) + (uint64_t)pk1[i]; @@ -1541,6 +1542,10 @@ static bool send_invite_response(Group_Chats *g_c, int groupnumber, uint32_t fri { Group_c *g = get_group_c(g_c, groupnumber); + if (g == nullptr) { + return false; + } + const bool member = (g->status == GROUPCHAT_STATUS_CONNECTED); VLA(uint8_t, response, member ? INVITE_MEMBER_PACKET_SIZE : INVITE_ACCEPT_PACKET_SIZE); @@ -1932,7 +1937,8 @@ static void handle_friend_invite_packet(Messenger *m, uint32_t friendnumber, con return; } - uint16_t other_groupnum, groupnum; + uint16_t other_groupnum; + uint16_t groupnum; net_unpack_u16(data + 1, &other_groupnum); net_unpack_u16(data + 1 + sizeof(uint16_t), &groupnum); @@ -1979,7 +1985,8 @@ static void handle_friend_invite_packet(Messenger *m, uint32_t friendnumber, con return; } - uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE], temp_pk[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t temp_pk[CRYPTO_PUBLIC_KEY_SIZE]; get_friendcon_public_keys(real_pk, temp_pk, g_c->fr_c, friendcon_id); addpeer(g_c, groupnum, real_pk, temp_pk, peer_number, userdata, true, true); @@ -2097,7 +2104,8 @@ static int handle_packet_online(Group_Chats *g_c, int friendcon_id, const uint8_ send_packet_online(g_c->fr_c, friendcon_id, groupnumber, g->type, g->id); if (g->connections[index].reasons & GROUPCHAT_CONNECTION_REASON_INTRODUCING) { - uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE], temp_pk[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t temp_pk[CRYPTO_PUBLIC_KEY_SIZE]; get_friendcon_public_keys(real_pk, temp_pk, g_c->fr_c, friendcon_id); const int peer_index = peer_in_group(g, real_pk); @@ -2129,7 +2137,8 @@ static int handle_packet_rejoin(Group_Chats *g_c, int friendcon_id, const uint8_ return -1; } - uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE], temp_pk[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE]; + uint8_t temp_pk[CRYPTO_PUBLIC_KEY_SIZE]; get_friendcon_public_keys(real_pk, temp_pk, g_c->fr_c, friendcon_id); uint16_t peer_number; @@ -2366,7 +2375,9 @@ static unsigned int send_lossy_all_connections(const Group_Chats *g_c, const Gro uint16_t length, int receiver) { - unsigned int sent = 0, num_connected_closest = 0, connected_closest[DESIRED_CLOSEST]; + unsigned int sent = 0; + unsigned int num_connected_closest = 0; + unsigned int connected_closest[DESIRED_CLOSEST]; for (unsigned int i = 0; i < MAX_GROUP_CONNECTIONS; ++i) { if (g->connections[i].type != GROUPCHAT_CONNECTION_ONLINE) { @@ -2656,6 +2667,10 @@ static void handle_message_packet_group(Group_Chats *g_c, uint32_t groupnumber, return; } + uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE]; + get_friendcon_public_keys(real_pk, nullptr, g_c->fr_c, g->connections[connection_index].number); + const bool direct_from_sender = id_equal(g->group[index].real_pk, real_pk); + switch (message_id) { case GROUP_MESSAGE_PING_ID: break; @@ -2752,11 +2767,7 @@ static void handle_message_packet_group(Group_Chats *g_c, uint32_t groupnumber, * back. When the sender only has one group connection (e.g. because there * are only two peers in the group), this is the only way for them to * receive their own message. */ - uint8_t real_pk[CRYPTO_PUBLIC_KEY_SIZE]; - get_friendcon_public_keys(real_pk, nullptr, g_c->fr_c, g->connections[connection_index].number); - bool relay_back = id_equal(g->group[index].real_pk, real_pk); - - send_message_all_connections(g_c, g, data, length, relay_back ? -1 : connection_index); + send_message_all_connections(g_c, g, data, length, direct_from_sender ? -1 : connection_index); } static int g_handle_packet(void *object, int friendcon_id, const uint8_t *data, uint16_t length, void *userdata) @@ -2877,7 +2888,9 @@ static int handle_lossy(void *object, int friendcon_id, const uint8_t *data, uin return -1; } - uint16_t groupnumber, peer_number, message_number; + uint16_t groupnumber; + uint16_t peer_number; + uint16_t message_number; memcpy(&groupnumber, data + 1, sizeof(uint16_t)); memcpy(&peer_number, data + 1 + sizeof(uint16_t), sizeof(uint16_t)); memcpy(&message_number, data + 1 + sizeof(uint16_t) * 2, sizeof(uint16_t)); diff --git a/protocols/Tox/libtox/src/toxcore/net_crypto.c b/protocols/Tox/libtox/src/toxcore/net_crypto.c index 2851053bbf..97383a059a 100644 --- a/protocols/Tox/libtox/src/toxcore/net_crypto.c +++ b/protocols/Tox/libtox/src/toxcore/net_crypto.c @@ -617,7 +617,8 @@ static IP_Port return_ip_port_connection(Net_Crypto *c, int crypt_connection_id) } const uint64_t current_time = mono_time_get(c->mono_time); - bool v6 = 0, v4 = 0; + bool v6 = 0; + bool v4 = 0; if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev4) > current_time) { v4 = 1; @@ -932,9 +933,9 @@ static int generate_request_packet(const Logger *log, uint8_t *data, uint16_t le return cur_len; } - uint32_t i, n = 1; + uint32_t n = 1; - for (i = recv_array->buffer_start; i != recv_array->buffer_end; ++i) { + for (uint32_t i = recv_array->buffer_start; i != recv_array->buffer_end; ++i) { uint32_t num = i % CRYPTO_PACKET_BUFFER_SIZE; if (!recv_array->buffer[num]) { @@ -1118,7 +1119,7 @@ static int reset_max_speed_reached(Net_Crypto *c, int crypt_connection_id) } /* If last packet send failed, try to send packet again. - If sending it fails we won't be able to send the new packet. */ + * If sending it fails we won't be able to send the new packet. */ if (conn->maximum_speed_reached) { Packet_Data *dt = nullptr; const uint32_t packet_num = conn->send_array.buffer_end - 1; @@ -1156,7 +1157,7 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, cons } /* If last packet send failed, try to send packet again. - If sending it fails we won't be able to send the new packet. */ + * If sending it fails we won't be able to send the new packet. */ reset_max_speed_reached(c, crypt_connection_id); if (conn->maximum_speed_reached && congestion_control) { @@ -1290,9 +1291,10 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint32 } const uint64_t temp_time = current_time_monotonic(c->mono_time); - uint32_t i, num_sent = 0, array_size = num_packets_array(&conn->send_array); + const uint32_t array_size = num_packets_array(&conn->send_array); + uint32_t num_sent = 0; - for (i = 0; i < array_size; ++i) { + for (uint32_t i = 0; i < array_size; ++i) { Packet_Data *dt; const uint32_t packet_num = i + conn->send_array.buffer_start; const int ret = get_data_pointer(c->log, &conn->send_array, &dt, packet_num); @@ -1510,7 +1512,8 @@ static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const return -1; } - uint32_t buffer_start, num; + uint32_t buffer_start; + uint32_t num; memcpy(&buffer_start, data, sizeof(uint32_t)); memcpy(&num, data + sizeof(uint32_t), sizeof(uint32_t)); buffer_start = net_ntohl(buffer_start); @@ -2281,12 +2284,10 @@ unsigned int copy_connected_tcp_relays(Net_Crypto *c, Node_format *tcp_relays, u static void do_tcp(Net_Crypto *c, void *userdata) { pthread_mutex_lock(&c->tcp_mutex); - do_tcp_connections(c->tcp_c, userdata); + do_tcp_connections(c->log, c->tcp_c, userdata); pthread_mutex_unlock(&c->tcp_mutex); - uint32_t i; - - for (i = 0; i < c->crypto_connections_length; ++i) { + for (uint32_t i = 0; i < c->crypto_connections_length; ++i) { Crypto_Connection *conn = get_crypto_connection(c, i); if (conn == nullptr) { @@ -2297,21 +2298,15 @@ static void do_tcp(Net_Crypto *c, void *userdata) continue; } - bool direct_connected = 0; + bool direct_connected = false; if (!crypto_connection_status(c, i, &direct_connected, nullptr)) { continue; } - if (direct_connected) { - pthread_mutex_lock(&c->tcp_mutex); - set_tcp_connection_to_status(c->tcp_c, conn->connection_number_tcp, 0); - pthread_mutex_unlock(&c->tcp_mutex); - } else { - pthread_mutex_lock(&c->tcp_mutex); - set_tcp_connection_to_status(c->tcp_c, conn->connection_number_tcp, 1); - pthread_mutex_unlock(&c->tcp_mutex); - } + pthread_mutex_lock(&c->tcp_mutex); + set_tcp_connection_to_status(c->tcp_c, conn->connection_number_tcp, !direct_connected); + pthread_mutex_unlock(&c->tcp_mutex); } } @@ -2477,7 +2472,7 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet } /* The dT for the average packet receiving rate calculations. - Also used as the */ + * Also used as the */ #define PACKET_COUNTER_AVERAGE_INTERVAL 50 /* Ratio of recv queue size / recv packet rate (in seconds) times @@ -2563,7 +2558,7 @@ static void send_crypto_packets(Net_Crypto *c) conn->packets_resent = 0; /* conjestion control - calculate a new value of conn->packet_send_rate based on some data + * calculate a new value of conn->packet_send_rate based on some data */ unsigned int pos = conn->last_sendqueue_counter % CONGESTION_QUEUE_ARRAY_SIZE; @@ -2586,7 +2581,8 @@ static void send_crypto_packets(Net_Crypto *c) /* When switching from TCP to UDP, don't change the packet send rate for CONGESTION_EVENT_TIMEOUT ms. */ if (!(direct_connected && conn->last_tcp_sent + CONGESTION_EVENT_TIMEOUT > temp_time)) { - long signed int total_sent = 0, total_resent = 0; + long signed int total_sent = 0; + long signed int total_resent = 0; // TODO(irungentoo): use real delay unsigned int delay = (unsigned int)((conn->rtt_time / PACKET_COUNTER_AVERAGE_INTERVAL) + 0.5); @@ -2925,9 +2921,7 @@ bool crypto_connection_status(const Net_Crypto *c, int crypt_connection_id, bool if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev4) > current_time) { *direct_connected = 1; - } - - if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev6) > current_time) { + } else if ((UDP_DIRECT_TIMEOUT + conn->direct_lastrecv_timev6) > current_time) { *direct_connected = 1; } } diff --git a/protocols/Tox/libtox/src/toxcore/net_crypto.h b/protocols/Tox/libtox/src/toxcore/net_crypto.h index 3885a1ba5f..33275708af 100644 --- a/protocols/Tox/libtox/src/toxcore/net_crypto.h +++ b/protocols/Tox/libtox/src/toxcore/net_crypto.h @@ -87,7 +87,7 @@ #define CRYPTO_SEND_PACKET_INTERVAL 1000 /* The maximum number of times we try to send the cookie request and handshake - before giving up. */ + * before giving up. */ #define MAX_NUM_SENDPACKET_TRIES 8 /* The timeout of no received UDP packets before the direct UDP connection is considered dead. */ @@ -100,7 +100,7 @@ #define CRYPTO_MAX_PADDING 8 /* Base current transfer speed on last CONGESTION_QUEUE_ARRAY_SIZE number of points taken - at the dT defined in net_crypto.c */ + * at the dT defined in net_crypto.c */ #define CONGESTION_QUEUE_ARRAY_SIZE 12 #define CONGESTION_LAST_SENT_ARRAY_SIZE (CONGESTION_QUEUE_ARRAY_SIZE * 2) diff --git a/protocols/Tox/libtox/src/toxcore/network.c b/protocols/Tox/libtox/src/toxcore/network.c index e5a5833109..3efa3283e9 100644 --- a/protocols/Tox/libtox/src/toxcore/network.c +++ b/protocols/Tox/libtox/src/toxcore/network.c @@ -310,7 +310,7 @@ IP6 get_ip6_loopback(void) } #ifndef OS_WIN32 -#define INVALID_SOCKET -1 +#define INVALID_SOCKET (-1) #endif const Socket net_invalid_socket = { (int)INVALID_SOCKET }; @@ -1532,7 +1532,8 @@ size_t net_unpack_u16(const uint8_t *bytes, uint16_t *v) size_t net_unpack_u32(const uint8_t *bytes, uint32_t *v) { const uint8_t *p = bytes; - uint16_t lo, hi; + uint16_t hi; + uint16_t lo; p += net_unpack_u16(p, &hi); p += net_unpack_u16(p, &lo); *v = ((uint32_t)hi << 16) | lo; @@ -1542,7 +1543,8 @@ size_t net_unpack_u32(const uint8_t *bytes, uint32_t *v) size_t net_unpack_u64(const uint8_t *bytes, uint64_t *v) { const uint8_t *p = bytes; - uint32_t lo, hi; + uint32_t hi; + uint32_t lo; p += net_unpack_u32(p, &hi); p += net_unpack_u32(p, &lo); *v = ((uint64_t)hi << 32) | lo; diff --git a/protocols/Tox/libtox/src/toxcore/onion_announce.c b/protocols/Tox/libtox/src/toxcore/onion_announce.c index 6d38012aa7..0a04a4b834 100644 --- a/protocols/Tox/libtox/src/toxcore/onion_announce.c +++ b/protocols/Tox/libtox/src/toxcore/onion_announce.c @@ -259,7 +259,8 @@ typedef struct Cmp_data { static int cmp_entry(const void *a, const void *b) { - Cmp_data cmp1, cmp2; + Cmp_data cmp1; + Cmp_data cmp2; memcpy(&cmp1, a, sizeof(Cmp_data)); memcpy(&cmp2, b, sizeof(Cmp_data)); Onion_Announce_Entry entry1 = cmp1.entry; diff --git a/protocols/Tox/libtox/src/toxcore/onion_client.c b/protocols/Tox/libtox/src/toxcore/onion_client.c index e161928bae..d3a56af73b 100644 --- a/protocols/Tox/libtox/src/toxcore/onion_client.c +++ b/protocols/Tox/libtox/src/toxcore/onion_client.c @@ -21,7 +21,7 @@ #include "util.h" /* defines for the array size and - timeout for onion announce packets. */ + * timeout for onion announce packets. */ #define ANNOUNCE_ARRAY_SIZE 256 #define ANNOUNCE_TIMEOUT 10 @@ -97,6 +97,7 @@ typedef struct Onion_Data_Handler { struct Onion_Client { Mono_Time *mono_time; + const Logger *logger; DHT *dht; Net_Crypto *c; @@ -610,7 +611,8 @@ typedef struct Onion_Client_Cmp_data { static int onion_client_cmp_entry(const void *a, const void *b) { - Onion_Client_Cmp_data cmp1, cmp2; + Onion_Client_Cmp_data cmp1; + Onion_Client_Cmp_data cmp2; memcpy(&cmp1, a, sizeof(Onion_Client_Cmp_data)); memcpy(&cmp2, b, sizeof(Onion_Client_Cmp_data)); Onion_Node entry1 = cmp1.entry; @@ -700,7 +702,8 @@ static int client_add_to_list(Onion_Client *onion_c, uint32_t num, const uint8_t sort_onion_node_list(list_nodes, list_length, onion_c->mono_time, reference_id); - int index = -1, stored = 0; + int index = -1; + int stored = 0; unsigned int i; if (onion_node_timed_out(&list_nodes[0], onion_c->mono_time) @@ -1045,10 +1048,12 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data, return -1; } - unsigned int i, good_nodes[MAX_ONION_CLIENTS], num_good = 0, num_nodes = 0; + unsigned int good_nodes[MAX_ONION_CLIENTS]; + unsigned int num_good = 0; + unsigned int num_nodes = 0; Onion_Node *list_nodes = onion_c->friends_list[friend_num].clients_list; - for (i = 0; i < MAX_ONION_CLIENTS; ++i) { + for (unsigned int i = 0; i < MAX_ONION_CLIENTS; ++i) { if (onion_node_timed_out(&list_nodes[i], onion_c->mono_time)) { continue; } @@ -1080,7 +1085,7 @@ int send_onion_data(Onion_Client *onion_c, int friend_num, const uint8_t *data, unsigned int good = 0; - for (i = 0; i < num_good; ++i) { + for (unsigned int i = 0; i < num_good; ++i) { Onion_Path path; if (random_path(onion_c, &onion_c->onion_paths_friends, -1, &path) == -1) { @@ -1209,7 +1214,8 @@ static int send_dhtpk_announce(Onion_Client *onion_c, uint16_t friend_num, uint8 } } - int num1 = -1, num2 = -1; + int num1 = -1; + int num2 = -1; if (onion_dht_both != 1) { num1 = send_onion_data(onion_c, friend_num, data, DHTPK_DATA_MIN_LENGTH + nodes_len); @@ -1288,9 +1294,9 @@ int onion_addfriend(Onion_Client *onion_c, const uint8_t *public_key) return num; } - unsigned int i, index = -1; + unsigned int index = -1; - for (i = 0; i < onion_c->num_friends; ++i) { + for (unsigned int i = 0; i < onion_c->num_friends; ++i) { if (onion_c->friends_list[i].status == 0) { index = i; break; @@ -1658,10 +1664,10 @@ void oniondata_registerhandler(Onion_Client *onion_c, uint8_t byte, oniondata_ha static void do_announce(Onion_Client *onion_c) { - unsigned int i, count = 0; + unsigned int count = 0; Onion_Node *list_nodes = onion_c->clients_announce_list; - for (i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) { + for (unsigned int i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) { if (onion_node_timed_out(&list_nodes[i], onion_c->mono_time)) { continue; } @@ -1734,7 +1740,7 @@ static void do_announce(Onion_Client *onion_c) if (count <= random_u32() % MAX_ONION_CLIENTS_ANNOUNCE) { if (num_nodes != 0) { - for (i = 0; i < (MAX_ONION_CLIENTS_ANNOUNCE / 2); ++i) { + for (unsigned int i = 0; i < (MAX_ONION_CLIENTS_ANNOUNCE / 2); ++i) { const uint32_t num = random_u32() % num_nodes; client_send_announce_request(onion_c, 0, path_nodes[num].ip_port, path_nodes[num].public_key, nullptr, -1); } @@ -1748,7 +1754,8 @@ static void do_announce(Onion_Client *onion_c) */ static int onion_isconnected(const Onion_Client *onion_c) { - unsigned int i, num = 0, announced = 0; + unsigned int num = 0; + unsigned int announced = 0; if (mono_time_is_timeout(onion_c->mono_time, onion_c->last_packet_recv, ONION_OFFLINE_TIMEOUT)) { return 0; @@ -1758,7 +1765,7 @@ static int onion_isconnected(const Onion_Client *onion_c) return 0; } - for (i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) { + for (unsigned int i = 0; i < MAX_ONION_CLIENTS_ANNOUNCE; ++i) { if (!onion_node_timed_out(&onion_c->clients_announce_list[i], onion_c->mono_time)) { ++num; @@ -1775,7 +1782,7 @@ static int onion_isconnected(const Onion_Client *onion_c) } /* Consider ourselves online if we are announced to half or more nodes - we are connected to */ + * we are connected to */ if (num && announced) { if ((num / 2) <= announced && (pnodes / 2) <= num) { return 1; @@ -1827,15 +1834,12 @@ void do_onion_client(Onion_Client *onion_c) } } - bool udp_connected = dht_non_lan_connected(onion_c->dht); + onion_c->udp_connected = dht_non_lan_connected(onion_c->dht); if (mono_time_is_timeout(onion_c->mono_time, onion_c->first_run, ONION_CONNECTION_SECONDS * 2)) { - set_tcp_onion_status(nc_get_tcp_c(onion_c->c), !udp_connected); + set_tcp_onion_status(nc_get_tcp_c(onion_c->c), !onion_c->udp_connected); } - onion_c->udp_connected = udp_connected - || get_random_tcp_onion_conn_number(nc_get_tcp_c(onion_c->c)) == -1; /* Check if connected to any TCP relays. */ - if (onion_connection_status(onion_c)) { for (unsigned i = 0; i < onion_c->num_friends; ++i) { do_friend(onion_c, i); @@ -1849,7 +1853,7 @@ void do_onion_client(Onion_Client *onion_c) onion_c->last_run = mono_time_get(onion_c->mono_time); } -Onion_Client *new_onion_client(Mono_Time *mono_time, Net_Crypto *c) +Onion_Client *new_onion_client(const Logger *logger, Mono_Time *mono_time, Net_Crypto *c) { if (c == nullptr) { return nullptr; @@ -1869,6 +1873,7 @@ Onion_Client *new_onion_client(Mono_Time *mono_time, Net_Crypto *c) } onion_c->mono_time = mono_time; + onion_c->logger = logger; onion_c->dht = nc_get_dht(c); onion_c->net = dht_get_net(onion_c->dht); onion_c->c = c; diff --git a/protocols/Tox/libtox/src/toxcore/onion_client.h b/protocols/Tox/libtox/src/toxcore/onion_client.h index 5b6bea659a..c0f8f52c8b 100644 --- a/protocols/Tox/libtox/src/toxcore/onion_client.h +++ b/protocols/Tox/libtox/src/toxcore/onion_client.h @@ -26,7 +26,7 @@ #define NUMBER_ONION_PATHS 6 /* The timeout the first time the path is added and - then for all the next consecutive times */ + * then for all the next consecutive times */ #define ONION_PATH_FIRST_TIMEOUT 4 #define ONION_PATH_TIMEOUT 10 #define ONION_PATH_MAX_LIFETIME 1200 @@ -171,7 +171,7 @@ void oniondata_registerhandler(Onion_Client *onion_c, uint8_t byte, oniondata_ha void do_onion_client(Onion_Client *onion_c); -Onion_Client *new_onion_client(Mono_Time *mono_time, Net_Crypto *c); +Onion_Client *new_onion_client(const Logger *logger, Mono_Time *mono_time, Net_Crypto *c); void kill_onion_client(Onion_Client *onion_c); diff --git a/protocols/Tox/libtox/src/toxcore/tox.api.h b/protocols/Tox/libtox/src/toxcore/tox.api.h index 3655617181..90a6ffc8f8 100644 --- a/protocols/Tox/libtox/src/toxcore/tox.api.h +++ b/protocols/Tox/libtox/src/toxcore/tox.api.h @@ -169,7 +169,7 @@ const VERSION_MINOR = 2; * The patch or revision number. Incremented when bugfixes are applied without * changing any functionality or API or ABI. */ -const VERSION_PATCH = 12; +const VERSION_PATCH = 13; /** * A macro to check at preprocessing time whether the client code is compatible diff --git a/protocols/Tox/libtox/src/toxcore/tox.c b/protocols/Tox/libtox/src/toxcore/tox.c index d2d3ed344f..780d913667 100644 --- a/protocols/Tox/libtox/src/toxcore/tox.c +++ b/protocols/Tox/libtox/src/toxcore/tox.c @@ -400,7 +400,8 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error) Messenger_Options m_options = {0}; - bool load_savedata_sk = false, load_savedata_tox = false; + bool load_savedata_sk = false; + bool load_savedata_tox = false; struct Tox_Options *default_options = nullptr; diff --git a/protocols/Tox/libtox/src/toxcore/tox.h b/protocols/Tox/libtox/src/toxcore/tox.h index c9c0967a7f..ab71986e9e 100644 --- a/protocols/Tox/libtox/src/toxcore/tox.h +++ b/protocols/Tox/libtox/src/toxcore/tox.h @@ -170,7 +170,7 @@ uint32_t tox_version_minor(void); * The patch or revision number. Incremented when bugfixes are applied without * changing any functionality or API or ABI. */ -#define TOX_VERSION_PATCH 12 +#define TOX_VERSION_PATCH 13 uint32_t tox_version_patch(void); diff --git a/protocols/Tox/libtox/src/toxcore/util.c b/protocols/Tox/libtox/src/toxcore/util.c index 58b75763e5..2f00adacb1 100644 --- a/protocols/Tox/libtox/src/toxcore/util.c +++ b/protocols/Tox/libtox/src/toxcore/util.c @@ -17,12 +17,12 @@ #include "util.h" -#include "crypto_core.h" /* for CRYPTO_PUBLIC_KEY_SIZE */ - #include <stdlib.h> #include <string.h> #include <time.h> +#include "crypto_core.h" /* for CRYPTO_PUBLIC_KEY_SIZE */ + /* id functions */ bool id_equal(const uint8_t *dest, const uint8_t *src) diff --git a/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.api.h b/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.api.h index b1068c5079..df5d1136f3 100644 --- a/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.api.h +++ b/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.api.h @@ -10,6 +10,8 @@ #ifndef C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H #define C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H +//!TOKSTYLE- + #ifdef __cplusplus extern "C" { #endif @@ -303,5 +305,7 @@ typedef TOX_ERR_ENCRYPTION Tox_Err_Encryption; typedef TOX_ERR_DECRYPTION Tox_Err_Decryption; typedef TOX_ERR_GET_SALT Tox_Err_Get_Salt; +//!TOKSTYLE+ + #endif // C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H %} diff --git a/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.c b/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.c index 70aa3746e4..be4bcaf26c 100644 --- a/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.c +++ b/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.c @@ -28,17 +28,15 @@ #include <stdlib.h> #include <string.h> -#if TOX_PASS_SALT_LENGTH != crypto_pwhash_scryptsalsa208sha256_SALTBYTES -#error TOX_PASS_SALT_LENGTH is assumed to be equal to crypto_pwhash_scryptsalsa208sha256_SALTBYTES -#endif - -#if TOX_PASS_KEY_LENGTH != CRYPTO_SHARED_KEY_SIZE -#error TOX_PASS_KEY_LENGTH is assumed to be equal to CRYPTO_SHARED_KEY_SIZE -#endif - -#if TOX_PASS_ENCRYPTION_EXTRA_LENGTH != (crypto_box_MACBYTES + crypto_box_NONCEBYTES + crypto_pwhash_scryptsalsa208sha256_SALTBYTES + TOX_ENC_SAVE_MAGIC_LENGTH) -#error TOX_PASS_ENCRYPTION_EXTRA_LENGTH is assumed to be equal to (crypto_box_MACBYTES + crypto_box_NONCEBYTES + crypto_pwhash_scryptsalsa208sha256_SALTBYTES + TOX_ENC_SAVE_MAGIC_LENGTH) -#endif +//!TOKSTYLE- +static_assert(TOX_PASS_SALT_LENGTH == crypto_pwhash_scryptsalsa208sha256_SALTBYTES, + "TOX_PASS_SALT_LENGTH is assumed to be equal to crypto_pwhash_scryptsalsa208sha256_SALTBYTES"); +static_assert(TOX_PASS_KEY_LENGTH == CRYPTO_SHARED_KEY_SIZE, + "TOX_PASS_KEY_LENGTH is assumed to be equal to CRYPTO_SHARED_KEY_SIZE"); +static_assert(TOX_PASS_ENCRYPTION_EXTRA_LENGTH == (crypto_box_MACBYTES + crypto_box_NONCEBYTES + + crypto_pwhash_scryptsalsa208sha256_SALTBYTES + TOX_ENC_SAVE_MAGIC_LENGTH), + "TOX_PASS_ENCRYPTION_EXTRA_LENGTH is assumed to be equal to (crypto_box_MACBYTES + crypto_box_NONCEBYTES + crypto_pwhash_scryptsalsa208sha256_SALTBYTES + TOX_ENC_SAVE_MAGIC_LENGTH)"); +//!TOKSTYLE+ uint32_t tox_pass_salt_length(void) { @@ -109,7 +107,7 @@ Tox_Pass_Key *tox_pass_key_derive(const uint8_t *passphrase, size_t pplength, Tox_Err_Key_Derivation *error) { uint8_t salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES]; - random_bytes(salt, sizeof salt); + random_bytes(salt, sizeof(salt)); return tox_pass_key_derive_with_salt(passphrase, pplength, salt, error); } @@ -129,10 +127,10 @@ Tox_Pass_Key *tox_pass_key_derive_with_salt(const uint8_t *passphrase, size_t pp uint8_t key[CRYPTO_SHARED_KEY_SIZE]; - /* Derive a key from the password */ - /* http://doc.libsodium.org/key_derivation/README.html */ - /* note that, according to the documentation, a generic pwhash interface will be created - * once the pwhash competition (https://password-hashing.net/) is over */ + // Derive a key from the password + // http://doc.libsodium.org/key_derivation/README.html + // note that, according to the documentation, a generic pwhash interface will be created + // once the pwhash competition (https://password-hashing.net/) is over */ if (crypto_pwhash_scryptsalsa208sha256( key, sizeof(key), (char *)passkey, sizeof(passkey), salt, crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE * 2, /* slightly stronger */ @@ -157,7 +155,8 @@ Tox_Pass_Key *tox_pass_key_derive_with_salt(const uint8_t *passphrase, size_t pp return out_key; } -/* Encrypt arbitrary with a key produced by tox_derive_key_*. The output +/** + * Encrypt arbitrary with a key produced by `tox_derive_key_*`. The output * array must be at least data_len + TOX_PASS_ENCRYPTION_EXTRA_LENGTH bytes long. * key must be TOX_PASS_KEY_LENGTH bytes. * If you already have a symmetric key from somewhere besides this module, simply @@ -173,13 +172,12 @@ bool tox_pass_key_encrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t d return 0; } - /* the output data consists of, in order: - * salt, nonce, mac, enc_data - * where the mac is automatically prepended by the encrypt() - * the salt+nonce is called the prefix - * I'm not sure what else I'm supposed to do with the salt and nonce, since we - * need them to decrypt the data - */ + // the output data consists of, in order: + // salt, nonce, mac, enc_data + // where the mac is automatically prepended by the encrypt() + // the salt+nonce is called the prefix + // I'm not sure what else I'm supposed to do with the salt and nonce, since we + // need them to decrypt the data /* first add the magic number */ memcpy(out, TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH); @@ -214,13 +212,13 @@ bool tox_pass_key_encrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t d bool tox_pass_encrypt(const uint8_t *data, size_t data_len, const uint8_t *passphrase, size_t pplength, uint8_t *out, Tox_Err_Encryption *error) { - Tox_Err_Key_Derivation _error; - Tox_Pass_Key *key = tox_pass_key_derive(passphrase, pplength, &_error); + Tox_Err_Key_Derivation err; + Tox_Pass_Key *key = tox_pass_key_derive(passphrase, pplength, &err); if (!key) { - if (_error == TOX_ERR_KEY_DERIVATION_NULL) { + if (err == TOX_ERR_KEY_DERIVATION_NULL) { SET_ERROR_PARAMETER(error, TOX_ERR_ENCRYPTION_NULL); - } else if (_error == TOX_ERR_KEY_DERIVATION_FAILED) { + } else if (err == TOX_ERR_KEY_DERIVATION_FAILED) { SET_ERROR_PARAMETER(error, TOX_ERR_ENCRYPTION_KEY_DERIVATION_FAILED); } diff --git a/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.h b/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.h index 34287a1ac9..4b58165e7d 100644 --- a/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.h +++ b/protocols/Tox/libtox/src/toxencryptsave/toxencryptsave.h @@ -9,6 +9,8 @@ #ifndef C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H #define C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H +//!TOKSTYLE- + #ifdef __cplusplus extern "C" { #endif @@ -365,4 +367,6 @@ typedef TOX_ERR_ENCRYPTION Tox_Err_Encryption; typedef TOX_ERR_DECRYPTION Tox_Err_Decryption; typedef TOX_ERR_GET_SALT Tox_Err_Get_Salt; +//!TOKSTYLE+ + #endif // C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H |