mirror of
https://github.com/TokTok/c-toxcore
synced 2026-06-05 05:52:35 +00:00
Merge remote-tracking branch 'upstream/master' into new_api
This commit is contained in:
mannol
+1
-1
@@ -32,7 +32,7 @@ before_script:
|
||||
- sudo make install > /dev/null
|
||||
- cd ..
|
||||
#installing vpx
|
||||
- git clone http://git.chromium.org/webm/libvpx.git > /dev/null
|
||||
- git clone https://chromium.googlesource.com/webm/libvpx > /dev/null
|
||||
- cd libvpx
|
||||
- ./configure --enable-shared > /dev/null
|
||||
- make -j3 >/dev/null
|
||||
|
||||
@@ -3,8 +3,8 @@
|
||||
|
||||
With the rise of governmental monitoring programs, Tox, a FOSS initiative, aims to be an easy to use, all-in-one communication platform that ensures their users full privacy and secure message delivery.<br /> <br />
|
||||
|
||||
[**Website**](https://tox.im) **|** [**Wiki**](https://wiki.tox.im/) **|** [**Blog**](https://blog.tox.im/) **|** [**FAQ**](https://wiki.tox.im/FAQ) **|** [**Binaries/Downloads**](https://wiki.tox.im/Binaries) **|** [**Clients**](https://wiki.tox.im/Client) **|** [**Compiling**](/INSTALL.md) **|**
|
||||
[**API**](https://libtoxcore.so/) **|** [**Bugs**](http://tox.lighthouseapp.com/) **|** [**Help and Suggestions**](http://support.libtoxcore.so) **|** **IRC Channel:** [#tox@freenode](https://webchat.freenode.net/?channels=tox)
|
||||
[**Website**](http://utox.org) **|** [**Wiki**](https://wiki.tox.im/) **|** [**Blog**](https://blog.tox.im/) **|** [**FAQ**](https://wiki.tox.im/FAQ) **|** [**Binaries/Downloads**](https://wiki.tox.im/Binaries) **|** [**Clients**](https://wiki.tox.im/Client) **|** [**Compiling**](/INSTALL.md) **|**
|
||||
[**API**](https://libtoxcore.so/) **|** **IRC Channel:** [#tox@freenode](https://webchat.freenode.net/?channels=tox)
|
||||
|
||||
|
||||
## The Complex Stuff:
|
||||
@@ -39,5 +39,3 @@ The goal of this project is to create a configuration-free P2P Skype replacement
|
||||
- [Crypto](/docs/updates/Crypto.md)<br />
|
||||
|
||||
Additional developer documentation can be found at [Libtoxcore.so](https://libtoxcore.so/)
|
||||
|
||||
[String]: https://en.wikipedia.org/wiki/String_(computer_science)
|
||||
|
||||
+63
-1
@@ -286,6 +286,16 @@ void tox_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *use
|
||||
|
||||
START_TEST(test_one)
|
||||
{
|
||||
{
|
||||
TOX_ERR_OPTIONS_NEW o_err;
|
||||
struct Tox_Options *o1 = tox_options_new(&o_err);
|
||||
struct Tox_Options o2;
|
||||
tox_options_default(&o2);
|
||||
ck_assert_msg(o_err == TOX_ERR_OPTIONS_NEW_OK, "tox_options_new wrong error");
|
||||
ck_assert_msg(memcmp(o1, &o2, sizeof(struct Tox_Options)) == 0, "tox_options_new error");
|
||||
tox_options_free(o1);
|
||||
}
|
||||
|
||||
Tox *tox1 = tox_new(0, 0);
|
||||
Tox *tox2 = tox_new(0, 0);
|
||||
|
||||
@@ -468,6 +478,44 @@ START_TEST(test_few_clients)
|
||||
|
||||
printf("tox clients messaging succeeded\n");
|
||||
|
||||
unsigned int save_size1 = tox_get_savedata_size(tox2);
|
||||
ck_assert_msg(save_size1 != 0 && save_size1 < 4096, "save is invalid size %u", save_size1);
|
||||
printf("%u\n", save_size1);
|
||||
uint8_t save1[save_size1];
|
||||
tox_get_savedata(tox2, save1);
|
||||
tox_kill(tox2);
|
||||
|
||||
struct Tox_Options options;
|
||||
tox_options_default(&options);
|
||||
options.savedata_type = TOX_SAVEDATA_TYPE_TOX_SAVE;
|
||||
options.savedata_data = save1;
|
||||
options.savedata_length = save_size1;
|
||||
tox2 = tox_new(&options, NULL);
|
||||
cur_time = time(NULL);
|
||||
off = 1;
|
||||
|
||||
while (1) {
|
||||
tox_iterate(tox1);
|
||||
tox_iterate(tox2);
|
||||
tox_iterate(tox3);
|
||||
|
||||
if (tox_self_get_connection_status(tox1) && tox_self_get_connection_status(tox2)
|
||||
&& tox_self_get_connection_status(tox3)) {
|
||||
if (off) {
|
||||
printf("Toxes are online again after reloading, took %llu seconds\n", time(NULL) - cur_time);
|
||||
con_time = time(NULL);
|
||||
off = 0;
|
||||
}
|
||||
|
||||
if (tox_friend_get_connection_status(tox2, 0, 0) == TOX_CONNECTION_UDP
|
||||
&& tox_friend_get_connection_status(tox3, 0, 0) == TOX_CONNECTION_UDP)
|
||||
break;
|
||||
}
|
||||
|
||||
c_sleep(50);
|
||||
}
|
||||
|
||||
printf("tox clients connected took %llu seconds\n", time(NULL) - con_time);
|
||||
tox_callback_friend_name(tox3, print_nickchange, &to_compare);
|
||||
TOX_ERR_SET_INFO err_n;
|
||||
bool succ = tox_self_set_name(tox2, (uint8_t *)"Gentoo", sizeof("Gentoo"), &err_n);
|
||||
@@ -785,6 +833,14 @@ START_TEST(test_many_clients)
|
||||
|
||||
uint8_t address[TOX_ADDRESS_SIZE];
|
||||
|
||||
unsigned int num_f = 0;
|
||||
|
||||
for (i = 0; i < NUM_TOXES; ++i) {
|
||||
num_f += tox_self_get_friend_list_size(toxes[i]);
|
||||
}
|
||||
|
||||
ck_assert_msg(num_f == 0, "bad num friends: %u", num_f);
|
||||
|
||||
for (i = 0; i < NUM_FRIENDS; ++i) {
|
||||
loop_top:
|
||||
pairs[i].tox1 = rand() % NUM_TOXES;
|
||||
@@ -807,6 +863,12 @@ loop_top:
|
||||
ck_assert_msg(num != UINT32_MAX && test == TOX_ERR_FRIEND_ADD_OK, "Failed to add friend error code: %i", test);
|
||||
}
|
||||
|
||||
for (i = 0; i < NUM_TOXES; ++i) {
|
||||
num_f += tox_self_get_friend_list_size(toxes[i]);
|
||||
}
|
||||
|
||||
ck_assert_msg(num_f == NUM_FRIENDS, "bad num friends: %u", num_f);
|
||||
|
||||
while (1) {
|
||||
uint16_t counter = 0;
|
||||
|
||||
@@ -1210,7 +1272,7 @@ Suite *tox_suite(void)
|
||||
Suite *s = suite_create("Tox");
|
||||
|
||||
DEFTESTCASE(one);
|
||||
DEFTESTCASE_SLOW(few_clients, 50);
|
||||
DEFTESTCASE_SLOW(few_clients, 80);
|
||||
DEFTESTCASE_SLOW(many_clients, 80);
|
||||
DEFTESTCASE_SLOW(many_clients_tcp, 20);
|
||||
DEFTESTCASE_SLOW(many_clients_tcp_b, 20);
|
||||
|
||||
+45
-7
@@ -1,11 +1,49 @@
|
||||
This folder contains the input file that can be used to generate the tox.h api
|
||||
with: https://github.com/iphydf/apidsl
|
||||
This folder contains the input file (``tox.in.h``) that has to be used to generate the ``tox.h`` api with: https://github.com/iphydf/apidsl
|
||||
|
||||
You can also use the following command if you can't install it:
|
||||
# Minimal requirements
|
||||
|
||||
```
|
||||
curl -X POST --data-binary @- https://criticism.herokuapp.com/apidsl < tox.in.h > tox.h
|
||||
There are some minimal requirements to contribute to ``tox.h``:
|
||||
* unix environment
|
||||
* ``astyle`` ``>=2.03``
|
||||
* [``apidsl``](https://github.com/iphydf/apidsl) (you can use provided service with curl instead)
|
||||
|
||||
## Quick way
|
||||
|
||||
If you want to do it quickly and you don't have time for anything other than copypasting commands, you should have ``curl`` installed.
|
||||
|
||||
|
||||
1. Make sure that you have ``curl`` and ``>=astyle-2.03`` installed
|
||||
2. Modify [``tox.in.h``](/other/apidsl/tox.in.h)
|
||||
3. Run command below ↓
|
||||
|
||||
Command to run from ``toxcore`` directory (quick way, involves using curl):
|
||||
```bash
|
||||
rm toxcore/tox.h && \
|
||||
( curl -X POST --data-binary @- https://criticism.herokuapp.com/apidsl < ./other/apidsl/tox.in.h > ./toxcore/tox.h ) && \
|
||||
astyle --options=./other/astyle/astylerc ./toxcore/tox.h
|
||||
```
|
||||
|
||||
Note that the output must be passed through astyle with the config in
|
||||
other/astyle/astylerc to generate the exact same file.
|
||||
When formatting will be complete, you should see output like:
|
||||
```
|
||||
Formatted ./toxcore/tox.h
|
||||
```
|
||||
|
||||
You may want to make sure with ``git diff`` that changes made in ``tox.h`` reflect changes in ``tox.in.h``.
|
||||
|
||||
And you're done.
|
||||
|
||||
|
||||
## Manually
|
||||
|
||||
If you prefer to have more control over what is happening, there are steps below:
|
||||
|
||||
1. Install [``apidsl``](https://github.com/iphydf/apidsl)
|
||||
2. Install ``astyle``, version 2.03 or later.
|
||||
3. Modify [``tox.in.h``](/other/apidsl/tox.in.h)
|
||||
4. Use ``apidsl`` ``??``
|
||||
5. Parse generated ``tox.h`` with astyle, minimal command for it would be:
|
||||
```bash
|
||||
astyle --options=./other/astyle/astylerc ./toxcore/tox.h
|
||||
```
|
||||
|
||||
**Always pass output from ``apidsl`` through astyle.**
|
||||
+17
-1
@@ -34,6 +34,14 @@ extern "C" {
|
||||
#endif
|
||||
%}
|
||||
|
||||
|
||||
/*****************************************************************************
|
||||
* `tox.h` SHOULD *NOT* BE EDITED MANUALLY – any changes should be made to *
|
||||
* `tox.in.h`, located in `other/apidsl/`. For instructions on how to *
|
||||
* generate `tox.h` from `tox.in.h` please refer to `other/apidsl/README.md` *
|
||||
*****************************************************************************/
|
||||
|
||||
|
||||
/** \page core Public core API for Tox clients.
|
||||
*
|
||||
* Every function that can fail takes a function-specific error code pointer
|
||||
@@ -431,7 +439,15 @@ static class options {
|
||||
uint16_t end_port;
|
||||
|
||||
/**
|
||||
* The port to use for the TCP server. If 0, the tcp server is disabled.
|
||||
* The port to use for the TCP server (relay). If 0, the TCP server is
|
||||
* disabled.
|
||||
*
|
||||
* Enabling it is not required for Tox to function properly.
|
||||
*
|
||||
* When enabled, your Tox instance can act as a TCP relay for other Tox
|
||||
* instance. This leads to increased traffic, thus when writing a client
|
||||
* it is recommended to enable TCP server only if the user has an option
|
||||
* to disable it.
|
||||
*/
|
||||
uint16_t tcp_port;
|
||||
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
This directory can house various tools and utilities.
|
||||
|
||||
astylerc
|
||||
- This file can be used in the precommit hook to try its best
|
||||
at making the code conform to the coding style document.
|
||||
|
||||
pre-commit (*NIX only at the moment)
|
||||
- Lints your file in adherence to the coding style doucment as
|
||||
best as possible in terms of spacing, indenting, etc.
|
||||
- Requires you to have astyle installed.
|
||||
- To use, copy this file to ProjectTox-Core/.git/hooks
|
||||
@@ -0,0 +1,32 @@
|
||||
This directory can house various tools and utilities.
|
||||
|
||||
# How to use astyle
|
||||
|
||||
## Manually
|
||||
|
||||
### For all files
|
||||
|
||||
Run from ``toxcore`` directory:
|
||||
```bash
|
||||
astyle --options=./other/astyle/astylerc ./toxcore/*.c ./toxcore/*.h ./toxdns/*.c ./toxdns/*.h ./testing/*.c ./toxav/*.c ./toxav/*.h ./other/*.c ./other/bootstrap_daemon/*.c ./toxencryptsave/*.c ./toxencryptsave/*.h ./auto_tests/*.c
|
||||
```
|
||||
|
||||
### For selected file
|
||||
|
||||
Run from ``toxcore`` directory, e.g. for [``tox.h``](/toxcore/tox.h) file:
|
||||
```bash
|
||||
astyle --options=./other/astyle/astylerc ./toxcore/tox.h
|
||||
```
|
||||
|
||||
|
||||
## Automatically, as pre-commit hook (*NIX only)
|
||||
|
||||
Copy [``astylerc``](/other/astyle/astylerc) to ``toxcore/.git/hooks``
|
||||
|
||||
|
||||
|
||||
# Why
|
||||
|
||||
``astylerc`` - this file can be used in the pre-commit hook to try its best at making the code conform to the coding style of toxcore.
|
||||
|
||||
Furthermore, it is being used to format ``tox.h`` after using [``apidsl``](/other/apidsl) to generate it.
|
||||
+84
-121
@@ -47,7 +47,7 @@
|
||||
#include "util.h"
|
||||
|
||||
/* The timeout after which a node is discarded completely. */
|
||||
#define KILL_NODE_TIMEOUT 300
|
||||
#define KILL_NODE_TIMEOUT (BAD_NODE_TIMEOUT + PING_INTERVAL)
|
||||
|
||||
/* Ping interval in seconds for each random sending of a get nodes request. */
|
||||
#define GET_NODE_INTERVAL 20
|
||||
@@ -2244,18 +2244,17 @@ DHT *new_DHT(Networking_Core *net)
|
||||
|
||||
void do_DHT(DHT *dht)
|
||||
{
|
||||
// Load friends/clients if first call to do_DHT
|
||||
if (dht->has_loaded_friends_clients == 0) {
|
||||
dht->has_loaded_friends_clients = 1;
|
||||
DHT_connect_after_load(dht);
|
||||
}
|
||||
|
||||
unix_time_update();
|
||||
|
||||
if (dht->last_run == unix_time()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Load friends/clients if first call to do_DHT
|
||||
if (dht->loaded_num_nodes) {
|
||||
DHT_connect_after_load(dht);
|
||||
}
|
||||
|
||||
do_Close(dht);
|
||||
do_DHT_friends(dht);
|
||||
do_NAT(dht);
|
||||
@@ -2282,33 +2281,37 @@ void kill_DHT(DHT *dht)
|
||||
ping_array_free_all(&dht->dht_harden_ping_array);
|
||||
kill_ping(dht->ping);
|
||||
free(dht->friends_list);
|
||||
free(dht->loaded_friends_list);
|
||||
free(dht->loaded_clients_list);
|
||||
free(dht->loaded_nodes_list);
|
||||
free(dht);
|
||||
}
|
||||
|
||||
/* new DHT format for load/save, more robust and forward compatible */
|
||||
|
||||
//TODO: Move this closer to Messenger.
|
||||
#define DHT_STATE_COOKIE_GLOBAL 0x159000d
|
||||
|
||||
#define DHT_STATE_COOKIE_TYPE 0x11ce
|
||||
#define DHT_STATE_TYPE_FRIENDS_ASSOC46 3
|
||||
#define DHT_STATE_TYPE_CLIENTS_ASSOC46 4
|
||||
#define DHT_STATE_TYPE_NODES 4
|
||||
|
||||
/* Get the size of the DHT (for saving). */
|
||||
uint32_t DHT_size(const DHT *dht)
|
||||
{
|
||||
uint32_t num = 0, i;
|
||||
uint32_t num = 0, i, j;
|
||||
|
||||
for (i = 0; i < LCLIENT_LIST; ++i)
|
||||
if ((dht->close_clientlist[i].assoc4.timestamp != 0) ||
|
||||
(dht->close_clientlist[i].assoc6.timestamp != 0))
|
||||
num++;
|
||||
for (i = 0; i < LCLIENT_LIST; ++i) {
|
||||
num += (dht->close_clientlist[i].assoc4.timestamp != 0) + (dht->close_clientlist[i].assoc6.timestamp != 0);
|
||||
}
|
||||
|
||||
for (i = 0; i < DHT_FAKE_FRIEND_NUMBER && i < dht->num_friends; ++i) {
|
||||
DHT_Friend *fr = &dht->friends_list[i];
|
||||
|
||||
for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
|
||||
num += (fr->client_list[j].assoc4.timestamp != 0) + (fr->client_list[j].assoc6.timestamp != 0);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t size32 = sizeof(uint32_t), sizesubhead = size32 * 2;
|
||||
return size32
|
||||
+ sizesubhead + sizeof(DHT_Friend) * dht->num_friends
|
||||
+ sizesubhead + sizeof(Client_data) * num;
|
||||
+ sizesubhead + sizeof(Node_format) * num;
|
||||
}
|
||||
|
||||
static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t type)
|
||||
@@ -2323,97 +2326,80 @@ static uint8_t *z_state_save_subheader(uint8_t *data, uint32_t len, uint16_t typ
|
||||
/* Save the DHT in data where data is an array of size DHT_size(). */
|
||||
void DHT_save(DHT *dht, uint8_t *data)
|
||||
{
|
||||
uint32_t len;
|
||||
uint16_t type;
|
||||
*(uint32_t *)data = DHT_STATE_COOKIE_GLOBAL;
|
||||
data += sizeof(uint32_t);
|
||||
|
||||
len = sizeof(DHT_Friend) * dht->num_friends;
|
||||
type = DHT_STATE_TYPE_FRIENDS_ASSOC46;
|
||||
data = z_state_save_subheader(data, len, type);
|
||||
memcpy(data, dht->friends_list, len);
|
||||
data += len;
|
||||
uint32_t num, i, j;
|
||||
|
||||
uint32_t num = 0, i;
|
||||
uint8_t *old_data = data;
|
||||
|
||||
for (i = 0; i < LCLIENT_LIST; ++i)
|
||||
if ((dht->close_clientlist[i].assoc4.timestamp != 0) ||
|
||||
(dht->close_clientlist[i].assoc6.timestamp != 0))
|
||||
num++;
|
||||
/* get right offset. we write the actual header later. */
|
||||
data = z_state_save_subheader(data, 0, 0);
|
||||
|
||||
len = num * sizeof(Client_data);
|
||||
type = DHT_STATE_TYPE_CLIENTS_ASSOC46;
|
||||
data = z_state_save_subheader(data, len, type);
|
||||
Node_format *clients = (Node_format *)data;
|
||||
|
||||
if (num) {
|
||||
Client_data *clients = (Client_data *)data;
|
||||
for (num = 0, i = 0; i < LCLIENT_LIST; ++i) {
|
||||
if (dht->close_clientlist[i].assoc4.timestamp != 0) {
|
||||
memcpy(clients[num].public_key, dht->close_clientlist[i].client_id, crypto_box_PUBLICKEYBYTES);
|
||||
clients[num].ip_port = dht->close_clientlist[i].assoc4.ip_port;
|
||||
++num;
|
||||
}
|
||||
|
||||
for (num = 0, i = 0; i < LCLIENT_LIST; ++i)
|
||||
if ((dht->close_clientlist[i].assoc4.timestamp != 0) ||
|
||||
(dht->close_clientlist[i].assoc6.timestamp != 0))
|
||||
memcpy(&clients[num++], &dht->close_clientlist[i], sizeof(Client_data));
|
||||
}
|
||||
}
|
||||
|
||||
static void DHT_bootstrap_loaded_clients(DHT *dht)
|
||||
{
|
||||
if (!dht->loaded_clients_list)
|
||||
return;
|
||||
|
||||
uint32_t i;
|
||||
|
||||
Client_data *client_list = dht->loaded_clients_list;
|
||||
uint32_t client_count = dht->loaded_num_clients;
|
||||
|
||||
for (i = 0; i < client_count; ++i) {
|
||||
if (client_list[i].assoc4.timestamp != 0)
|
||||
DHT_bootstrap(dht, client_list[i].assoc4.ip_port, client_list[i].client_id);
|
||||
|
||||
if (client_list[i].assoc6.timestamp != 0)
|
||||
DHT_bootstrap(dht, client_list[i].assoc6.ip_port, client_list[i].client_id);
|
||||
}
|
||||
}
|
||||
|
||||
static void getnodes_of_loaded_friend_clients(DHT *dht)
|
||||
{
|
||||
if (!dht->loaded_friends_list)
|
||||
return;
|
||||
|
||||
uint32_t i, j;
|
||||
|
||||
DHT_Friend *friend_list = dht->loaded_friends_list;
|
||||
uint32_t friend_count = dht->loaded_num_friends;
|
||||
|
||||
for (i = 0; i < friend_count; ++i) {
|
||||
for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
|
||||
Client_data *client = &friend_list[i].client_list[j];
|
||||
|
||||
if (client->assoc4.timestamp != 0)
|
||||
getnodes(dht, client->assoc4.ip_port, client->client_id, friend_list[i].client_id, NULL);
|
||||
|
||||
if (client->assoc6.timestamp != 0)
|
||||
getnodes(dht, client->assoc6.ip_port, client->client_id, friend_list[i].client_id, NULL);
|
||||
if (dht->close_clientlist[i].assoc6.timestamp != 0) {
|
||||
memcpy(clients[num].public_key, dht->close_clientlist[i].client_id, crypto_box_PUBLICKEYBYTES);
|
||||
clients[num].ip_port = dht->close_clientlist[i].assoc6.ip_port;
|
||||
++num;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < DHT_FAKE_FRIEND_NUMBER && i < dht->num_friends; ++i) {
|
||||
DHT_Friend *fr = &dht->friends_list[i];
|
||||
|
||||
for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
|
||||
if (fr->client_list[j].assoc4.timestamp != 0) {
|
||||
memcpy(clients[num].public_key, fr->client_list[j].client_id, crypto_box_PUBLICKEYBYTES);
|
||||
clients[num].ip_port = fr->client_list[j].assoc4.ip_port;
|
||||
++num;
|
||||
}
|
||||
|
||||
if (fr->client_list[j].assoc6.timestamp != 0) {
|
||||
memcpy(clients[num].public_key, fr->client_list[j].client_id, crypto_box_PUBLICKEYBYTES);
|
||||
clients[num].ip_port = fr->client_list[j].assoc6.ip_port;
|
||||
++num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
z_state_save_subheader(old_data, num * sizeof(Node_format), DHT_STATE_TYPE_NODES);
|
||||
}
|
||||
|
||||
/* Bootstrap from this number of nodes every time DHT_connect_after_load() is called */
|
||||
#define SAVE_BOOTSTAP_FREQUENCY 8
|
||||
|
||||
/* Start sending packets after DHT loaded_friends_list and loaded_clients_list are set */
|
||||
int DHT_connect_after_load(DHT *dht)
|
||||
{
|
||||
if (dht == NULL)
|
||||
return -1;
|
||||
|
||||
getnodes_of_loaded_friend_clients(dht);
|
||||
DHT_bootstrap_loaded_clients(dht);
|
||||
if (!dht->loaded_nodes_list)
|
||||
return -1;
|
||||
|
||||
// Loaded lists were allocd, free them
|
||||
free(dht->loaded_friends_list);
|
||||
dht->loaded_friends_list = NULL;
|
||||
dht->loaded_num_friends = 0;
|
||||
/* DHT is connected, stop. */
|
||||
if (DHT_non_lan_connected(dht)) {
|
||||
free(dht->loaded_nodes_list);
|
||||
dht->loaded_nodes_list = NULL;
|
||||
dht->loaded_num_nodes = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
free(dht->loaded_clients_list);
|
||||
dht->loaded_clients_list = NULL;
|
||||
dht->loaded_num_clients = 0;
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < dht->loaded_num_nodes && i < SAVE_BOOTSTAP_FREQUENCY; ++i) {
|
||||
unsigned int index = dht->loaded_nodes_index % dht->loaded_num_nodes;
|
||||
DHT_bootstrap(dht, dht->loaded_nodes_list[index].ip_port, dht->loaded_nodes_list[index].public_key);
|
||||
++dht->loaded_nodes_index;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -2424,46 +2410,23 @@ static int dht_load_state_callback(void *outer, const uint8_t *data, uint32_t le
|
||||
uint32_t num, i;
|
||||
|
||||
switch (type) {
|
||||
case DHT_STATE_TYPE_FRIENDS_ASSOC46:
|
||||
if (length % sizeof(DHT_Friend) != 0)
|
||||
case DHT_STATE_TYPE_NODES:
|
||||
if ((length % sizeof(Node_format)) != 0)
|
||||
break;
|
||||
|
||||
{ /* localize declarations */
|
||||
DHT_Friend *friend_list = (DHT_Friend *)data;
|
||||
num = length / sizeof(DHT_Friend);
|
||||
num = length / sizeof(Node_format);
|
||||
Node_format *client_list = (Node_format *)data;
|
||||
|
||||
free(dht->loaded_friends_list);
|
||||
// Copy to loaded_friends_list
|
||||
dht->loaded_friends_list = calloc(num, sizeof(DHT_Friend));
|
||||
|
||||
for (i = 0; i < num; i++)
|
||||
memcpy(&(dht->loaded_friends_list[i]), &(friend_list[i]), sizeof(DHT_Friend));
|
||||
|
||||
dht->loaded_num_friends = num;
|
||||
|
||||
dht->has_loaded_friends_clients = 1;
|
||||
} /* localize declarations */
|
||||
|
||||
break;
|
||||
|
||||
case DHT_STATE_TYPE_CLIENTS_ASSOC46:
|
||||
if ((length % sizeof(Client_data)) != 0)
|
||||
break;
|
||||
|
||||
{ /* localize declarations */
|
||||
num = length / sizeof(Client_data);
|
||||
Client_data *client_list = (Client_data *)data;
|
||||
|
||||
free(dht->loaded_clients_list);
|
||||
free(dht->loaded_nodes_list);
|
||||
// Copy to loaded_clients_list
|
||||
dht->loaded_clients_list = calloc(num, sizeof(Client_data));
|
||||
dht->loaded_nodes_list = calloc(num, sizeof(Node_format));
|
||||
|
||||
for (i = 0; i < num; i++)
|
||||
memcpy(&(dht->loaded_clients_list[i]), &(client_list[i]), sizeof(Client_data));
|
||||
memcpy(&(dht->loaded_nodes_list[i]), &(client_list[i]), sizeof(Node_format));
|
||||
|
||||
dht->loaded_num_clients = num;
|
||||
dht->loaded_num_nodes = num;
|
||||
|
||||
dht->has_loaded_friends_clients = 1;
|
||||
} /* localize declarations */
|
||||
|
||||
break;
|
||||
|
||||
+3
-7
@@ -211,13 +211,9 @@ typedef struct {
|
||||
DHT_Friend *friends_list;
|
||||
uint16_t num_friends;
|
||||
|
||||
// Used after loading of file (tox_load), but no longer needed after connect (tox_connect)
|
||||
// Unsure if friends_list and num_friends could just be used instead?
|
||||
int has_loaded_friends_clients; // Whether or not we have loaded on the first do_DHT
|
||||
DHT_Friend *loaded_friends_list;
|
||||
uint32_t loaded_num_friends;
|
||||
Client_data *loaded_clients_list;
|
||||
uint32_t loaded_num_clients;
|
||||
Node_format *loaded_nodes_list;
|
||||
uint32_t loaded_num_nodes;
|
||||
unsigned int loaded_nodes_index;
|
||||
|
||||
Shared_Keys shared_keys_recv;
|
||||
Shared_Keys shared_keys_sent;
|
||||
|
||||
+2
-2
@@ -1103,7 +1103,7 @@ long int new_filesender(const Messenger *m, int32_t friendnumber, uint32_t file_
|
||||
int send_file_control_packet(const Messenger *m, int32_t friendnumber, uint8_t send_receive, uint8_t filenumber,
|
||||
uint8_t control_type, uint8_t *data, uint16_t data_length)
|
||||
{
|
||||
if (1 + 3 + data_length > MAX_CRYPTO_DATA_SIZE)
|
||||
if ((unsigned int)(1 + 3 + data_length) > MAX_CRYPTO_DATA_SIZE)
|
||||
return -1;
|
||||
|
||||
uint8_t packet[3 + data_length];
|
||||
@@ -1435,7 +1435,7 @@ static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber)
|
||||
}
|
||||
|
||||
/* TODO: if file is too slow, switch to the next. */
|
||||
if (ft->slots_allocated > free_slots) {
|
||||
if (ft->slots_allocated > (unsigned int)free_slots) {
|
||||
free_slots = 0;
|
||||
} else {
|
||||
free_slots -= ft->slots_allocated;
|
||||
|
||||
@@ -691,7 +691,7 @@ static int reconnect_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connec
|
||||
uint8_t relay_pk[crypto_box_PUBLICKEYBYTES];
|
||||
memcpy(relay_pk, tcp_con->connection->public_key, crypto_box_PUBLICKEYBYTES);
|
||||
kill_TCP_connection(tcp_con->connection);
|
||||
tcp_con->connection = new_TCP_connection(ip_port, relay_pk, tcp_c->dht->self_public_key, tcp_c->dht->self_secret_key,
|
||||
tcp_con->connection = new_TCP_connection(ip_port, relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key,
|
||||
&tcp_c->proxy_info);
|
||||
|
||||
if (!tcp_con->connection) {
|
||||
@@ -776,8 +776,8 @@ static int unsleep_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connecti
|
||||
if (tcp_con->status != TCP_CONN_SLEEPING)
|
||||
return -1;
|
||||
|
||||
tcp_con->connection = new_TCP_connection(tcp_con->ip_port, tcp_con->relay_pk, tcp_c->dht->self_public_key,
|
||||
tcp_c->dht->self_secret_key, &tcp_c->proxy_info);
|
||||
tcp_con->connection = new_TCP_connection(tcp_con->ip_port, tcp_con->relay_pk, tcp_c->self_public_key,
|
||||
tcp_c->self_secret_key, &tcp_c->proxy_info);
|
||||
|
||||
if (!tcp_con->connection) {
|
||||
kill_tcp_relay_connection(tcp_c, tcp_connections_number);
|
||||
@@ -1025,7 +1025,7 @@ static int add_tcp_relay(TCP_Connections *tcp_c, IP_Port ip_port, const uint8_t
|
||||
TCP_con *tcp_con = &tcp_c->tcp_connections[tcp_connections_number];
|
||||
|
||||
|
||||
tcp_con->connection = new_TCP_connection(ip_port, relay_pk, tcp_c->dht->self_public_key, tcp_c->dht->self_secret_key,
|
||||
tcp_con->connection = new_TCP_connection(ip_port, relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key,
|
||||
&tcp_c->proxy_info);
|
||||
|
||||
if (!tcp_con->connection)
|
||||
@@ -1237,9 +1237,9 @@ int set_tcp_onion_status(TCP_Connections *tcp_c, _Bool status)
|
||||
return 0;
|
||||
}
|
||||
|
||||
TCP_Connections *new_tcp_connections(DHT *dht, TCP_Proxy_Info *proxy_info)
|
||||
TCP_Connections *new_tcp_connections(const uint8_t *secret_key, TCP_Proxy_Info *proxy_info)
|
||||
{
|
||||
if (dht == NULL)
|
||||
if (secret_key == NULL)
|
||||
return NULL;
|
||||
|
||||
TCP_Connections *temp = calloc(1, sizeof(TCP_Connections));
|
||||
@@ -1247,7 +1247,8 @@ TCP_Connections *new_tcp_connections(DHT *dht, TCP_Proxy_Info *proxy_info)
|
||||
if (temp == NULL)
|
||||
return NULL;
|
||||
|
||||
temp->dht = dht;
|
||||
memcpy(temp->self_secret_key, secret_key, crypto_box_SECRETKEYBYTES);
|
||||
crypto_scalarmult_curve25519_base(temp->self_public_key, temp->self_secret_key);
|
||||
temp->proxy_info = *proxy_info;
|
||||
|
||||
return temp;
|
||||
|
||||
@@ -81,6 +81,9 @@ typedef struct {
|
||||
typedef struct {
|
||||
DHT *dht;
|
||||
|
||||
uint8_t self_public_key[crypto_box_PUBLICKEYBYTES];
|
||||
uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
|
||||
|
||||
TCP_Connection_to *connections;
|
||||
uint32_t connections_length; /* Length of connections array. */
|
||||
|
||||
@@ -223,7 +226,7 @@ int add_tcp_relay_global(TCP_Connections *tcp_c, IP_Port ip_port, const uint8_t
|
||||
*/
|
||||
unsigned int tcp_copy_connected_relays(TCP_Connections *tcp_c, Node_format *tcp_relays, uint16_t max_num);
|
||||
|
||||
TCP_Connections *new_tcp_connections(DHT *dht, TCP_Proxy_Info *proxy_info);
|
||||
TCP_Connections *new_tcp_connections(const uint8_t *secret_key, TCP_Proxy_Info *proxy_info);
|
||||
void do_tcp_connections(TCP_Connections *tcp_c);
|
||||
void kill_tcp_connections(TCP_Connections *tcp_c);
|
||||
|
||||
|
||||
+19
-19
@@ -235,26 +235,26 @@ int create_request(const uint8_t *send_public_key, const uint8_t *send_secret_ke
|
||||
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)
|
||||
{
|
||||
if (length > crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES &&
|
||||
length <= MAX_CRYPTO_REQUEST_SIZE) {
|
||||
if (memcmp(packet + 1, self_public_key, crypto_box_PUBLICKEYBYTES) == 0) {
|
||||
memcpy(public_key, packet + 1 + crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
|
||||
uint8_t nonce[crypto_box_NONCEBYTES];
|
||||
uint8_t temp[MAX_CRYPTO_REQUEST_SIZE];
|
||||
memcpy(nonce, packet + 1 + crypto_box_PUBLICKEYBYTES * 2, crypto_box_NONCEBYTES);
|
||||
int len1 = decrypt_data(public_key, self_secret_key, nonce,
|
||||
packet + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES,
|
||||
length - (crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1), temp);
|
||||
if (length <= crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1 + crypto_box_MACBYTES ||
|
||||
length > MAX_CRYPTO_REQUEST_SIZE)
|
||||
return -1;
|
||||
|
||||
if (len1 == -1 || len1 == 0)
|
||||
return -1;
|
||||
if (memcmp(packet + 1, self_public_key, crypto_box_PUBLICKEYBYTES) != 0)
|
||||
return -1;
|
||||
|
||||
request_id[0] = temp[0];
|
||||
--len1;
|
||||
memcpy(data, temp + 1, len1);
|
||||
return len1;
|
||||
}
|
||||
}
|
||||
memcpy(public_key, packet + 1 + crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
|
||||
uint8_t nonce[crypto_box_NONCEBYTES];
|
||||
uint8_t temp[MAX_CRYPTO_REQUEST_SIZE];
|
||||
memcpy(nonce, packet + 1 + crypto_box_PUBLICKEYBYTES * 2, crypto_box_NONCEBYTES);
|
||||
int len1 = decrypt_data(public_key, self_secret_key, nonce,
|
||||
packet + 1 + crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES,
|
||||
length - (crypto_box_PUBLICKEYBYTES * 2 + crypto_box_NONCEBYTES + 1), temp);
|
||||
|
||||
return -1;
|
||||
if (len1 == -1 || len1 == 0)
|
||||
return -1;
|
||||
|
||||
request_id[0] = temp[0];
|
||||
--len1;
|
||||
memcpy(data, temp + 1, len1);
|
||||
return len1;
|
||||
}
|
||||
|
||||
@@ -220,7 +220,7 @@ static unsigned int send_relays(Friend_Connections *fr_c, int friendcon_id)
|
||||
|
||||
n = copy_connected_tcp_relays(fr_c->net_crypto, nodes, MAX_SHARED_RELAYS);
|
||||
|
||||
unsigned int i;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < n; ++i) {
|
||||
/* Associated the relays being sent with this connection.
|
||||
|
||||
+1
-1
@@ -1514,7 +1514,7 @@ static int handle_send_peers(Group_Chats *g_c, int groupnumber, const uint8_t *d
|
||||
|
||||
const uint8_t *d = data;
|
||||
|
||||
while ((length - (d - data)) >= sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2 + 1) {
|
||||
while ((unsigned int)(length - (d - data)) >= sizeof(uint16_t) + crypto_box_PUBLICKEYBYTES * 2 + 1) {
|
||||
uint16_t peer_num;
|
||||
memcpy(&peer_num, d, sizeof(peer_num));
|
||||
peer_num = ntohs(peer_num);
|
||||
|
||||
+37
-7
@@ -659,7 +659,8 @@ static int generate_request_packet(uint8_t *data, uint16_t length, const Packets
|
||||
* return -1 on failure.
|
||||
* return number of requested packets on success.
|
||||
*/
|
||||
static int handle_request_packet(Packets_Array *send_array, const uint8_t *data, uint16_t length)
|
||||
static int handle_request_packet(Packets_Array *send_array, const uint8_t *data, uint16_t length,
|
||||
uint64_t *latest_send_time, uint64_t rtt_time)
|
||||
{
|
||||
if (length < 1)
|
||||
return -1;
|
||||
@@ -677,6 +678,7 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
|
||||
uint32_t requested = 0;
|
||||
|
||||
uint64_t temp_time = current_time_monotonic();
|
||||
uint64_t l_sent_time = ~0;
|
||||
|
||||
for (i = send_array->buffer_start; i != send_array->buffer_end; ++i) {
|
||||
if (length == 0)
|
||||
@@ -688,7 +690,7 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
|
||||
if (send_array->buffer[num]) {
|
||||
uint64_t sent_time = send_array->buffer[num]->sent_time;
|
||||
|
||||
if ((sent_time + DEFAULT_PING_CONNECTION) < temp_time) {
|
||||
if ((sent_time + rtt_time) < temp_time) {
|
||||
send_array->buffer[num]->sent_time = 0;
|
||||
}
|
||||
}
|
||||
@@ -698,6 +700,11 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
|
||||
n = 0;
|
||||
++requested;
|
||||
} else {
|
||||
uint64_t sent_time = send_array->buffer[num]->sent_time;
|
||||
|
||||
if (l_sent_time < sent_time)
|
||||
l_sent_time = sent_time;
|
||||
|
||||
free(send_array->buffer[num]);
|
||||
send_array->buffer[num] = NULL;
|
||||
}
|
||||
@@ -715,6 +722,9 @@ static int handle_request_packet(Packets_Array *send_array, const uint8_t *data,
|
||||
}
|
||||
}
|
||||
|
||||
if (*latest_send_time < l_sent_time)
|
||||
*latest_send_time = l_sent_time;
|
||||
|
||||
return requested;
|
||||
}
|
||||
|
||||
@@ -1146,8 +1156,19 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
|
||||
buffer_start = ntohl(buffer_start);
|
||||
num = ntohl(num);
|
||||
|
||||
if (buffer_start != conn->send_array.buffer_start && clear_buffer_until(&conn->send_array, buffer_start) != 0)
|
||||
return -1;
|
||||
uint64_t rtt_calc_time = 0;
|
||||
|
||||
if (buffer_start != conn->send_array.buffer_start) {
|
||||
Packet_Data *packet_time;
|
||||
|
||||
if (get_data_pointer(&conn->send_array, &packet_time, conn->send_array.buffer_start) == 1) {
|
||||
rtt_calc_time = packet_time->sent_time;
|
||||
}
|
||||
|
||||
if (clear_buffer_until(&conn->send_array, buffer_start) != 0) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t *real_data = data + (sizeof(uint32_t) * 2);
|
||||
uint16_t real_length = len - (sizeof(uint32_t) * 2);
|
||||
@@ -1174,7 +1195,7 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
|
||||
}
|
||||
|
||||
if (real_data[0] == PACKET_ID_REQUEST) {
|
||||
int requested = handle_request_packet(&conn->send_array, real_data, real_length);
|
||||
int requested = handle_request_packet(&conn->send_array, real_data, real_length, &rtt_calc_time, conn->rtt_time);
|
||||
|
||||
if (requested == -1) {
|
||||
return -1;
|
||||
@@ -1226,6 +1247,13 @@ static int handle_data_packet_helper(Net_Crypto *c, int crypt_connection_id, con
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (rtt_calc_time != 0) {
|
||||
uint64_t rtt_time = current_time_monotonic() - rtt_calc_time;
|
||||
|
||||
if (rtt_time < conn->rtt_time)
|
||||
conn->rtt_time = rtt_time;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1580,6 +1608,7 @@ int accept_crypto_connection(Net_Crypto *c, New_Connection *n_c)
|
||||
memcpy(conn->dht_public_key, n_c->dht_public_key, crypto_box_PUBLICKEYBYTES);
|
||||
conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
|
||||
conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
|
||||
conn->rtt_time = DEFAULT_PING_CONNECTION;
|
||||
crypto_connection_add_source(c, crypt_connection_id, n_c->source);
|
||||
return crypt_connection_id;
|
||||
}
|
||||
@@ -1621,6 +1650,7 @@ int new_crypto_connection(Net_Crypto *c, const uint8_t *real_public_key, const u
|
||||
conn->status = CRYPTO_CONN_COOKIE_REQUESTING;
|
||||
conn->packet_send_rate = CRYPTO_PACKET_MIN_RATE;
|
||||
conn->packets_left = CRYPTO_MIN_QUEUE_LENGTH;
|
||||
conn->rtt_time = DEFAULT_PING_CONNECTION;
|
||||
memcpy(conn->dht_public_key, dht_public_key, crypto_box_PUBLICKEYBYTES);
|
||||
|
||||
conn->cookie_request_number = random_64b();
|
||||
@@ -2003,7 +2033,7 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet
|
||||
#define REQUEST_PACKETS_COMPARE_CONSTANT (0.125 * 100.0)
|
||||
|
||||
/* Multiplier for maximum allowed resends. */
|
||||
#define PACKET_RESEND_MULTIPLIER 2
|
||||
#define PACKET_RESEND_MULTIPLIER 3
|
||||
|
||||
/* Timeout for increasing speed after congestion event (in ms). */
|
||||
#define CONGESTION_EVENT_TIMEOUT 2000
|
||||
@@ -2392,7 +2422,7 @@ Net_Crypto *new_net_crypto(DHT *dht, TCP_Proxy_Info *proxy_info)
|
||||
if (temp == NULL)
|
||||
return NULL;
|
||||
|
||||
temp->tcp_c = new_tcp_connections(dht, proxy_info);
|
||||
temp->tcp_c = new_tcp_connections(dht->self_secret_key, proxy_info);
|
||||
|
||||
if (temp->tcp_c == NULL) {
|
||||
free(temp);
|
||||
|
||||
@@ -82,8 +82,8 @@
|
||||
at the dT defined in net_crypto.c */
|
||||
#define CONGESTION_QUEUE_ARRAY_SIZE 24
|
||||
|
||||
/* Connection ping in ms. TODO: calculate it per connection. */
|
||||
#define DEFAULT_PING_CONNECTION 50
|
||||
/* Default connection ping in ms. */
|
||||
#define DEFAULT_PING_CONNECTION 200
|
||||
|
||||
typedef struct {
|
||||
uint64_t sent_time;
|
||||
@@ -150,6 +150,7 @@ typedef struct {
|
||||
long signed int last_num_packets_sent[CONGESTION_QUEUE_ARRAY_SIZE];
|
||||
uint32_t packets_sent;
|
||||
uint64_t last_congestion_event;
|
||||
uint64_t rtt_time;
|
||||
|
||||
/* TCP_connection connection_number */
|
||||
unsigned int connection_number_tcp;
|
||||
|
||||
+26
-6
@@ -198,6 +198,16 @@ static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* is path timed out */
|
||||
static _Bool path_timed_out(Onion_Client_Paths *onion_paths, uint32_t pathnum)
|
||||
{
|
||||
pathnum = pathnum % NUMBER_ONION_PATHS;
|
||||
|
||||
return ((onion_paths->last_path_success[pathnum] + ONION_PATH_TIMEOUT < onion_paths->last_path_used[pathnum]
|
||||
&& onion_paths->last_path_used_times[pathnum] >= ONION_PATH_MAX_NO_RESPONSE_USES)
|
||||
|| is_timeout(onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME));
|
||||
}
|
||||
|
||||
/* Create a new path or use an old suitable one (if pathnum is valid)
|
||||
* or a random one from onion_paths.
|
||||
*
|
||||
@@ -209,12 +219,13 @@ static int is_path_used(const Onion_Client_Paths *onion_paths, const Node_format
|
||||
*/
|
||||
static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_paths, uint32_t pathnum, Onion_Path *path)
|
||||
{
|
||||
if (pathnum >= NUMBER_ONION_PATHS)
|
||||
if (pathnum == UINT32_MAX) {
|
||||
pathnum = rand() % NUMBER_ONION_PATHS;
|
||||
} else {
|
||||
pathnum = pathnum % NUMBER_ONION_PATHS;
|
||||
}
|
||||
|
||||
if ((onion_paths->last_path_success[pathnum] + ONION_PATH_TIMEOUT < onion_paths->last_path_used[pathnum]
|
||||
&& onion_paths->last_path_used_times[pathnum] >= ONION_PATH_MAX_NO_RESPONSE_USES)
|
||||
|| is_timeout(onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME)) {
|
||||
if (path_timed_out(onion_paths, pathnum)) {
|
||||
Node_format nodes[ONION_PATH_LENGTH];
|
||||
|
||||
if (random_nodes_path_onion(onion_c, nodes, ONION_PATH_LENGTH) != ONION_PATH_LENGTH)
|
||||
@@ -247,6 +258,15 @@ static int random_path(const Onion_Client *onion_c, Onion_Client_Paths *onion_pa
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Does path with path_num exist. */
|
||||
static _Bool path_exists(Onion_Client_Paths *onion_paths, uint32_t path_num)
|
||||
{
|
||||
if (path_timed_out(onion_paths, path_num))
|
||||
return 0;
|
||||
|
||||
return onion_paths->paths[path_num % NUMBER_ONION_PATHS].path_num == path_num;
|
||||
}
|
||||
|
||||
/* Set path timeouts, return the path number.
|
||||
*
|
||||
*/
|
||||
@@ -277,7 +297,7 @@ static uint32_t set_path_timeouts(Onion_Client *onion_c, uint32_t num, uint32_t
|
||||
}
|
||||
}
|
||||
|
||||
return path_num % NUMBER_ONION_PATHS;
|
||||
return path_num;
|
||||
}
|
||||
|
||||
return ~0;
|
||||
@@ -1315,7 +1335,7 @@ static void do_announce(Onion_Client *onion_c)
|
||||
|
||||
unsigned int interval = ANNOUNCE_INTERVAL_NOT_ANNOUNCED;
|
||||
|
||||
if (list_nodes[i].is_stored) {
|
||||
if (list_nodes[i].is_stored && path_exists(&onion_c->onion_paths_self, list_nodes[i].path_used)) {
|
||||
interval = ANNOUNCE_INTERVAL_ANNOUNCED;
|
||||
}
|
||||
|
||||
|
||||
+18
-1
@@ -32,6 +32,15 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
* `tox.h` SHOULD *NOT* BE EDITED MANUALLY – any changes should be made to *
|
||||
* `tox.in.h`, located in `other/apidsl/`. For instructions on how to *
|
||||
* generate `tox.h` from `tox.in.h` please refer to `other/apidsl/README.md` *
|
||||
******************************************************************************/
|
||||
|
||||
|
||||
|
||||
/** \page core Public core API for Tox clients.
|
||||
*
|
||||
* Every function that can fail takes a function-specific error code pointer
|
||||
@@ -451,7 +460,15 @@ struct Tox_Options {
|
||||
|
||||
|
||||
/**
|
||||
* The port to use for the TCP server. If 0, the tcp server is disabled.
|
||||
* The port to use for the TCP server (relay). If 0, the TCP server is
|
||||
* disabled.
|
||||
*
|
||||
* Enabling it is not required for Tox to function properly.
|
||||
*
|
||||
* When enabled, your Tox instance can act as a TCP relay for other Tox
|
||||
* instance. This leads to increased traffic, thus when writing a client
|
||||
* it is recommended to enable TCP server only if the user has an option
|
||||
* to disable it.
|
||||
*/
|
||||
uint16_t tcp_port;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user