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

Consistently use camel case enum names.

Browse Source 
Including in tests and implementation files.
This commit is contained in:
iphydf 2018-10-08 21:05:14 +00:00
parent 77e025fae4
commit 605dfe882c
No known key found for this signature in database
GPG Key ID: 3855DBA2D74403C9
33 changed files with 142 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
auto_tests/bootstrap_test.c
View File

@ -32,7 +32,7 @@ int main(void)
c_sleep(ITERATION_INTERVAL);
} while (tox_self_get_connection_status(tox_udp) == TOX_CONNECTION_NONE);
const TOX_CONNECTION status = tox_self_get_connection_status(tox_udp);
const Tox_Connection status = tox_self_get_connection_status(tox_udp);
ck_assert_msg(status == TOX_CONNECTION_UDP,
"expected connection status to be UDP, but got %d", status);
printf("Connection (UDP): %d\n", tox_self_get_connection_status(tox_udp));

8
auto_tests/conference_double_invite_test.c
View File

@ -19,7 +19,7 @@ typedef struct State {
#include "run_auto_test.h"
static void handle_conference_invite(
Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type,
Tox *tox, uint32_t friend_number, Tox_Conference_Type type,
const uint8_t *cookie, size_t length, void *user_data)
{
State *state = (State *)user_data;
@ -29,7 +29,7 @@ static void handle_conference_invite(
fprintf(stderr, "tox%u joining conference\n", state->index);
if (friend_number != -1) {
TOX_ERR_CONFERENCE_JOIN err;
Tox_Err_Conference_Join err;
state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK,
"attempting to join the conference returned with an error: %d", err);
@ -46,7 +46,7 @@ static void conference_double_invite_test(Tox **toxes, State *state)
{
// Create new conference, tox0 is the founder.
TOX_ERR_CONFERENCE_NEW err;
Tox_Err_Conference_New err;
state[0].conference = tox_conference_new(toxes[0], &err);
state[0].joined = true;
ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK,
@ -56,7 +56,7 @@ static void conference_double_invite_test(Tox **toxes, State *state)
{
// Invite friend.
TOX_ERR_CONFERENCE_INVITE err;
Tox_Err_Conference_Invite err;
tox_conference_invite(toxes[0], 0, state[0].conference, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK,
"attempting to invite a friend returned with an error: %d", err);

12
auto_tests/conference_peer_nick_test.c
View File

@ -20,7 +20,7 @@ typedef struct State {
#include "run_auto_test.h"
static void handle_conference_invite(
Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type,
Tox *tox, uint32_t friend_number, Tox_Conference_Type type,
const uint8_t *cookie, size_t length, void *user_data)
{
State *state = (State *)user_data;
@ -29,7 +29,7 @@ static void handle_conference_invite(
state->index, friend_number, type, (unsigned)length);
fprintf(stderr, "tox%u joining conference\n", state->index);
TOX_ERR_CONFERENCE_JOIN err;
Tox_Err_Conference_Join err;
state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK,
"attempting to join the conference returned with an error: %d", err);
@ -44,7 +44,7 @@ static void handle_peer_list_changed(Tox *tox, uint32_t conference_number, void
fprintf(stderr, "handle_peer_list_changed(#%u, %u, _)\n",
state->index, conference_number);
TOX_ERR_CONFERENCE_PEER_QUERY err;
Tox_Err_Conference_Peer_Query err;
uint32_t const count = tox_conference_peer_count(tox, conference_number, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_PEER_QUERY_OK,
"failed to get conference peer count: err = %d", err);
@ -57,7 +57,7 @@ static void rebuild_peer_list(Tox *tox)
for (uint32_t conference_number = 0;
conference_number < tox_conference_get_chatlist_size(tox);
++conference_number) {
TOX_ERR_CONFERENCE_PEER_QUERY err;
Tox_Err_Conference_Peer_Query err;
uint32_t const count = tox_conference_peer_count(tox, conference_number, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_PEER_QUERY_OK,
"failed to get conference peer count for conference %u: err = %d", conference_number, err);
@ -90,7 +90,7 @@ static void conference_peer_nick_test(Tox **toxes, State *state)
{
// Create new conference, tox0 is the founder.
TOX_ERR_CONFERENCE_NEW err;
Tox_Err_Conference_New err;
state[0].conference = tox_conference_new(toxes[0], &err);
state[0].joined = true;
ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK,
@ -100,7 +100,7 @@ static void conference_peer_nick_test(Tox **toxes, State *state)
{
// Invite friend.
TOX_ERR_CONFERENCE_INVITE err;
Tox_Err_Conference_Invite err;
tox_conference_invite(toxes[0], 0, state[0].conference, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK,
"attempting to invite a friend returned with an error: %d", err);

20
auto_tests/conference_simple_test.c
View File

@ -23,7 +23,7 @@ typedef struct State {
uint32_t peers;
} State;
static void handle_self_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *user_data)
static void handle_self_connection_status(Tox *tox, Tox_Connection connection_status, void *user_data)
{
State *state = (State *)user_data;
@ -31,7 +31,7 @@ static void handle_self_connection_status(Tox *tox, TOX_CONNECTION connection_st
state->self_online = connection_status != TOX_CONNECTION_NONE;
}
static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, TOX_CONNECTION connection_status,
static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, Tox_Connection connection_status,
void *user_data)
{
State *state = (State *)user_data;
@ -40,7 +40,7 @@ static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, TO
state->friend_online = connection_status != TOX_CONNECTION_NONE;
}
static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type, const uint8_t *cookie,
static void handle_conference_invite(Tox *tox, uint32_t friend_number, Tox_Conference_Type type, const uint8_t *cookie,
size_t length, void *user_data)
{
State *state = (State *)user_data;
@ -50,7 +50,7 @@ static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFE
fprintf(stderr, "tox%u joining conference\n", state->id);
{
TOX_ERR_CONFERENCE_JOIN err;
Tox_Err_Conference_Join err;
state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK, "failed to join a conference: err = %d", err);
fprintf(stderr, "tox%u Joined conference %u\n", state->id, state->conference);
@ -59,7 +59,7 @@ static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFE
}
static void handle_conference_message(Tox *tox, uint32_t conference_number, uint32_t peer_number,
TOX_MESSAGE_TYPE type, const uint8_t *message, size_t length, void *user_data)
Tox_Message_Type type, const uint8_t *message, size_t length, void *user_data)
{
State *state = (State *)user_data;
@ -77,7 +77,7 @@ static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_nu
fprintf(stderr, "handle_conference_peer_list_changed(#%u, %u, _)\n",
state->id, conference_number);
TOX_ERR_CONFERENCE_PEER_QUERY err;
Tox_Err_Conference_Peer_Query err;
uint32_t count = tox_conference_peer_count(tox, conference_number, &err);
if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {
@ -95,7 +95,7 @@ static void handle_conference_connected(Tox *tox, uint32_t conference_number, vo
// We're tox2, so now we invite tox3.
if (state->id == 2 && !state->invited_next) {
TOX_ERR_CONFERENCE_INVITE err;
Tox_Err_Conference_Invite err;
tox_conference_invite(tox, 1, state->conference, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK, "tox2 failed to invite tox3: err = %d", err);
@ -190,7 +190,7 @@ int main(void)
{
// Create new conference, tox1 is the founder.
TOX_ERR_CONFERENCE_NEW err;
Tox_Err_Conference_New err;
state1.conference = tox_conference_new(tox1, &err);
state1.joined = true;
ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK, "failed to create a conference: err = %d", err);
@ -199,7 +199,7 @@ int main(void)
{
// Invite friend.
TOX_ERR_CONFERENCE_INVITE err;
Tox_Err_Conference_Invite err;
tox_conference_invite(tox1, 0, state1.conference, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK, "failed to invite a friend: err = %d", err);
state1.invited_next = true;
@ -232,7 +232,7 @@ int main(void)
{
fprintf(stderr, "tox1 sends a message to the group: \"hello!\"\n");
TOX_ERR_CONFERENCE_SEND_MESSAGE err;
Tox_Err_Conference_Send_Message err;
tox_conference_send_message(tox1, state1.conference, TOX_MESSAGE_TYPE_NORMAL,
(const uint8_t *)"hello!", 7, &err);

16
auto_tests/conference_test.c
View File

@ -33,7 +33,7 @@ typedef struct State {
#include "run_auto_test.h"
static void handle_self_connection_status(
Tox *tox, TOX_CONNECTION connection_status, void *user_data)
Tox *tox, Tox_Connection connection_status, void *user_data)
{
const State *state = (State *)user_data;
@ -45,7 +45,7 @@ static void handle_self_connection_status(
}
static void handle_friend_connection_status(
Tox *tox, uint32_t friendnumber, TOX_CONNECTION connection_status, void *user_data)
Tox *tox, uint32_t friendnumber, Tox_Connection connection_status, void *user_data)
{
const State *state = (State *)user_data;
@ -57,13 +57,13 @@ static void handle_friend_connection_status(
}
static void handle_conference_invite(
Tox *tox, uint32_t friendnumber, TOX_CONFERENCE_TYPE type,
Tox *tox, uint32_t friendnumber, Tox_Conference_Type type,
const uint8_t *data, size_t length, void *user_data)
{
const State *state = (State *)user_data;
ck_assert_msg(type == TOX_CONFERENCE_TYPE_TEXT, "tox #%u: wrong conference type: %d", state->index, type);
TOX_ERR_CONFERENCE_JOIN err;
Tox_Err_Conference_Join err;
uint32_t g_num = tox_conference_join(tox, friendnumber, data, length, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_JOIN_OK, "tox #%u: error joining group: %d", state->index, err);
@ -84,7 +84,7 @@ static void handle_conference_connected(
return;
}
TOX_ERR_CONFERENCE_INVITE err;
Tox_Err_Conference_Invite err;
tox_conference_invite(tox, 1, 0, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_INVITE_OK, "tox #%u failed to invite next friend: err = %d", state->index, err);
printf("tox #%u: invited next friend\n", state->index);
@ -94,7 +94,7 @@ static void handle_conference_connected(
static uint16_t num_recv;
static void handle_conference_message(
Tox *tox, uint32_t groupnumber, uint32_t peernumber, TOX_MESSAGE_TYPE type,
Tox *tox, uint32_t groupnumber, uint32_t peernumber, Tox_Message_Type type,
const uint8_t *message, size_t length, void *user_data)
{
if (length == (sizeof(GROUP_MESSAGE) - 1) && memcmp(message, GROUP_MESSAGE, sizeof(GROUP_MESSAGE) - 1) == 0) {
@ -211,7 +211,7 @@ static void run_conference_tests(Tox **toxes, State *state)
iterate_all_wait(NUM_GROUP_TOX, toxes, state, ITERATION_INTERVAL);
}
TOX_ERR_CONFERENCE_SEND_MESSAGE err;
Tox_Err_Conference_Send_Message err;
ck_assert_msg(
tox_conference_send_message(
toxes[random_u32() % NUM_GROUP_TOX], 0, TOX_MESSAGE_TYPE_NORMAL, (const uint8_t *)GROUP_MESSAGE,
@ -301,7 +301,7 @@ static void test_many_group(Tox **toxes, State *state)
iterate_all_wait(NUM_GROUP_TOX, toxes, state, ITERATION_INTERVAL);
for (uint16_t i = 0; i < NUM_GROUP_TOX; ++i) {
TOX_ERR_CONFERENCE_PEER_QUERY err;
Tox_Err_Conference_Peer_Query err;
uint32_t peer_count = tox_conference_peer_count(toxes[i], 0, &err);
if (err != TOX_ERR_CONFERENCE_PEER_QUERY_OK) {

2
auto_tests/conference_two_test.c
View File

@ -18,7 +18,7 @@ int main(void)
Tox *tox1 = tox_new_log(nullptr, nullptr, &id);
// Create two conferences and then exit.
TOX_ERR_CONFERENCE_NEW err;
Tox_Err_Conference_New err;
tox_conference_new(tox1, &err);
ck_assert_msg(err == TOX_ERR_CONFERENCE_NEW_OK, "failed to create conference 1: %d", err);
tox_conference_new(tox1, &err);

16
auto_tests/encryptsave_test.c
View File

@ -70,7 +70,7 @@ static void test_save_friend(void)
tox_get_savedata(tox1, data);
size_t size2 = size + TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
VLA(uint8_t, enc_data, size2);
TOX_ERR_ENCRYPTION error1;
Tox_Err_Encryption error1;
bool ret = tox_pass_encrypt(data, size, (const uint8_t *)"correcthorsebatterystaple", 25, enc_data, &error1);
ck_assert_msg(ret, "failed to encrypted save: %d", error1);
ck_assert_msg(tox_is_data_encrypted(enc_data), "magic number missing");
@ -79,13 +79,13 @@ static void test_save_friend(void)
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);
tox_options_set_savedata_data(options, enc_data, size2);
TOX_ERR_NEW err2;
Tox_Err_New err2;
Tox *tox3 = tox_new_log(options, &err2, nullptr);
ck_assert_msg(err2 == TOX_ERR_NEW_LOAD_ENCRYPTED, "wrong error! %d. should fail with %d", err2,
TOX_ERR_NEW_LOAD_ENCRYPTED);
ck_assert_msg(tox3 == nullptr, "tox_new with error should return NULL");
VLA(uint8_t, dec_data, size);
TOX_ERR_DECRYPTION err3;
Tox_Err_Decryption err3;
ret = tox_pass_decrypt(enc_data, size2, (const uint8_t *)"correcthorsebatterystaple", 25, dec_data, &err3);
ck_assert_msg(ret, "failed to decrypt save: %d", err3);
tox_options_set_savedata_data(options, dec_data, size);
@ -99,7 +99,7 @@ static void test_save_friend(void)
size = tox_get_savedata_size(tox3);
VLA(uint8_t, data2, size);
tox_get_savedata(tox3, data2);
TOX_ERR_KEY_DERIVATION keyerr;
Tox_Err_Key_Derivation keyerr;
Tox_Pass_Key *key = tox_pass_key_derive((const uint8_t *)"123qweasdzxc", 12, &keyerr);
ck_assert_msg(key != nullptr, "pass key allocation failure");
memcpy((uint8_t *)key, test_salt, TOX_PASS_SALT_LENGTH);
@ -139,9 +139,9 @@ static void test_save_friend(void)
static void test_keys(void)
{
TOX_ERR_ENCRYPTION encerr;
TOX_ERR_DECRYPTION decerr;
TOX_ERR_KEY_DERIVATION keyerr;
Tox_Err_Encryption encerr;
Tox_Err_Decryption decerr;
Tox_Err_Key_Derivation keyerr;
Tox_Pass_Key *key = tox_pass_key_derive((const uint8_t *)"123qweasdzxc", 12, &keyerr);
ck_assert_msg(key != nullptr, "generic failure 1: %d", keyerr);
const uint8_t *string = (const uint8_t *)"No Patrick, mayonnaise is not an instrument."; // 44
@ -177,7 +177,7 @@ static void test_keys(void)
ck_assert_msg(memcmp(out1, string, 44) == 0, "decryption 3 failed");
uint8_t salt[TOX_PASS_SALT_LENGTH];
TOX_ERR_GET_SALT salt_err;
Tox_Err_Get_Salt salt_err;
ck_assert_msg(tox_get_salt(encrypted, salt, &salt_err), "couldn't get salt");
ck_assert_msg(salt_err == TOX_ERR_GET_SALT_OK, "get_salt returned an error");
Tox_Pass_Key *key2 = tox_pass_key_derive_with_salt((const uint8_t *)"123qweasdzxc", 12, salt, &keyerr);

6
auto_tests/file_saving_test.c
View File

@ -61,7 +61,7 @@ static void save_data_encrypted(void)
size += TOX_PASS_ENCRYPTION_EXTRA_LENGTH;
uint8_t *cipher = (uint8_t *)malloc(size);
TOX_ERR_ENCRYPTION eerr;
Tox_Err_Encryption eerr;
ck_assert_msg(tox_pass_encrypt(clear, size - TOX_PASS_ENCRYPTION_EXTRA_LENGTH, (const uint8_t *)pphrase,
strlen(pphrase), cipher,
@ -90,7 +90,7 @@ static void load_data_decrypted(void)
size_t read_value = fread(cipher, sizeof(*cipher), size, f);
printf("Read read_value = %u of %u\n", (unsigned)read_value, (unsigned)size);
TOX_ERR_DECRYPTION derr;
Tox_Err_Decryption derr;
ck_assert_msg(tox_pass_decrypt(cipher, size, (const uint8_t *)pphrase, strlen(pphrase), clear, &derr),
"Could not decrypt, error code %d.", derr);
@ -101,7 +101,7 @@ static void load_data_decrypted(void)
tox_options_set_savedata_data(options, clear, size);
TOX_ERR_NEW err;
Tox_Err_New err;
Tox *t = tox_new_log(options, &err, nullptr);

14
auto_tests/file_transfer_test.c
View File

@ -60,7 +60,7 @@ static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_num
if (filesize) {
sending_pos = size_recv = 1337;
TOX_ERR_FILE_SEEK err_s;
Tox_Err_File_Seek err_s;
ck_assert_msg(tox_file_seek(tox, friend_number, file_number, 1337, &err_s), "tox_file_seek error");
@ -70,13 +70,13 @@ static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_num
sending_pos = size_recv = 0;
}
TOX_ERR_FILE_CONTROL error;
Tox_Err_File_Control error;
ck_assert_msg(tox_file_control(tox, friend_number, file_number, TOX_FILE_CONTROL_RESUME, &error),
"tox_file_control failed. %i", error);
++file_accepted;
TOX_ERR_FILE_SEEK err_s;
Tox_Err_File_Seek err_s;
ck_assert_msg(!tox_file_seek(tox, friend_number, file_number, 1234, &err_s), "tox_file_seek no error");
@ -84,7 +84,7 @@ static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_num
}
static uint32_t sendf_ok;
static void file_print_control(Tox *tox, uint32_t friend_number, uint32_t file_number, TOX_FILE_CONTROL control,
static void file_print_control(Tox *tox, uint32_t friend_number, uint32_t file_number, Tox_File_Control control,
void *userdata)
{
/* First send file num is 0.*/
@ -121,7 +121,7 @@ static void tox_file_chunk_request(Tox *tox, uint32_t friend_number, uint32_t fi
VLA(uint8_t, f_data, length);
memset(f_data, sending_num, length);
TOX_ERR_FILE_SEND_CHUNK error;
Tox_Err_File_Send_Chunk error;
tox_file_send_chunk(tox, friend_number, file_number, position, f_data, length, &error);
@ -159,7 +159,7 @@ static void file_transfer_test(void)
printf("Starting test: few_clients\n");
uint32_t index[] = { 1, 2, 3 };
long long unsigned int cur_time = time(nullptr);
TOX_ERR_NEW t_n_error;
Tox_Err_New t_n_error;
Tox *tox1 = tox_new_log(nullptr, &t_n_error, &index[0]);
ck_assert_msg(t_n_error == TOX_ERR_NEW_OK, "wrong error");
Tox *tox2 = tox_new_log(nullptr, &t_n_error, &index[1]);
@ -218,7 +218,7 @@ static void file_transfer_test(void)
sizeof("Gentoo.exe"), nullptr);
ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
TOX_ERR_FILE_GET gfierr;
Tox_Err_File_Get gfierr;
ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");

2
auto_tests/invalid_tcp_proxy_test.c
View File

@ -41,7 +41,7 @@ int main(void)
tox_iterate(tox, nullptr);
c_sleep(ITERATION_INTERVAL);
// None of the iterations should have a connection.
const TOX_CONNECTION status = tox_self_get_connection_status(tox);
const Tox_Connection status = tox_self_get_connection_status(tox);
ck_assert_msg(status == TOX_CONNECTION_NONE,
"unexpectedly got a connection (%d)", status);
}

2
auto_tests/invalid_udp_proxy_test.c
View File

@ -41,7 +41,7 @@ int main(void)
tox_iterate(tox, nullptr);
c_sleep(ITERATION_INTERVAL);
// None of the iterations should have a connection.
const TOX_CONNECTION status = tox_self_get_connection_status(tox);
const Tox_Connection status = tox_self_get_connection_status(tox);
ck_assert_msg(status == TOX_CONNECTION_NONE,
"unexpectedly got a connection (%d)", status);
}

4
auto_tests/overflow_recvq_test.c
View File

@ -18,7 +18,7 @@ typedef struct State {
#define NUM_MSGS 40000
static void handle_friend_message(Tox *tox, uint32_t friend_number, TOX_MESSAGE_TYPE type,
static void handle_friend_message(Tox *tox, uint32_t friend_number, Tox_Message_Type type,
const uint8_t *message, size_t length, void *user_data)
{
State *state = (State *)user_data;
@ -36,7 +36,7 @@ static void net_crypto_overflow_test(Tox **toxes, State *state)
uint8_t message[128] = {0};
snprintf((char *)message, sizeof(message), "%u-%u", tox_index, i);
TOX_ERR_FRIEND_SEND_MESSAGE err;
Tox_Err_Friend_Send_Message err;
tox_friend_send_message(toxes[tox_index], 0, TOX_MESSAGE_TYPE_NORMAL, message, sizeof message, &err);
if (err == TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ) {

2
auto_tests/overflow_sendq_test.c
View File

@ -22,7 +22,7 @@ static void net_crypto_overflow_test(Tox **toxes, State *state)
bool errored = false;
for (uint32_t i = 0; i < NUM_MSGS; i++) {
TOX_ERR_FRIEND_SEND_MESSAGE err;
Tox_Err_Friend_Send_Message err;
tox_friend_send_message(toxes[0], 0, TOX_MESSAGE_TYPE_NORMAL, message, sizeof message, &err);
if (err != TOX_ERR_FRIEND_SEND_MESSAGE_OK) {

2
auto_tests/save_friend_test.c
View File

@ -22,7 +22,7 @@ struct test_data {
bool received_status_message;
};
static void set_random(Tox *m, bool (*setter)(Tox *, const uint8_t *, size_t, TOX_ERR_SET_INFO *), size_t length)
static void set_random(Tox *m, bool (*setter)(Tox *, const uint8_t *, size_t, Tox_Err_Set_Info *), size_t length)
{
VLA(uint8_t, text, length);
uint32_t i;

2
auto_tests/save_load_test.c
View File

@ -24,7 +24,7 @@ static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8
}
static unsigned int connected_t1;
static void tox_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *user_data)
static void tox_connection_status(Tox *tox, Tox_Connection connection_status, void *user_data)
{
if (connected_t1 && !connection_status) {
ck_abort_msg("Tox went offline");

4
auto_tests/send_message_test.c
View File

@ -21,7 +21,7 @@ typedef struct State {
#define MESSAGE_FILLER 'G'
static void message_callback(
Tox *m, uint32_t friendnumber, TOX_MESSAGE_TYPE type,
Tox *m, uint32_t friendnumber, Tox_Message_Type type,
const uint8_t *string, size_t length, void *userdata)
{
State *state = (State *)userdata;
@ -45,7 +45,7 @@ static void send_message_test(Tox **toxes, State *state)
uint8_t msgs[TOX_MAX_MESSAGE_LENGTH + 1];
memset(msgs, MESSAGE_FILLER, sizeof(msgs));
TOX_ERR_FRIEND_SEND_MESSAGE errm;
Tox_Err_Friend_Send_Message errm;
tox_friend_send_message(toxes[0], 0, TOX_MESSAGE_TYPE_NORMAL, msgs, TOX_MAX_MESSAGE_LENGTH + 1, &errm);
ck_assert_msg(errm == TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG, "TOX_MAX_MESSAGE_LENGTH is too small? error=%d", errm);

2
auto_tests/set_name_test.c
View File

@ -69,7 +69,7 @@ static void test_set_name(void)
printf("tox clients connected took %lu seconds\n", (unsigned long)(time(nullptr) - con_time));
tox_callback_friend_name(tox2, nickchange_callback);
TOX_ERR_SET_INFO err_n;
Tox_Err_Set_Info err_n;
bool ret = tox_self_set_name(tox1, (const uint8_t *)NICKNAME, sizeof(NICKNAME), &err_n);
ck_assert_msg(ret && err_n == TOX_ERR_SET_INFO_OK, "tox_self_set_name failed because %u\n", err_n);

2
auto_tests/set_status_message_test.c
View File

@ -72,7 +72,7 @@ static void test_set_status_message(void)
printf("tox clients connected took %lu seconds\n", (unsigned long)(time(nullptr) - con_time));
TOX_ERR_SET_INFO err_n;
Tox_Err_Set_Info err_n;
tox_callback_friend_status_message(tox2, status_callback);
bool ret = tox_self_set_status_message(tox1, (const uint8_t *)STATUS_MESSAGE, sizeof(STATUS_MESSAGE),
&err_n);

2
auto_tests/tcp_relay_test.c
View File

@ -36,7 +36,7 @@ int main(void)
c_sleep(ITERATION_INTERVAL);
} while (tox_self_get_connection_status(tox_tcp) == TOX_CONNECTION_NONE);
const TOX_CONNECTION status = tox_self_get_connection_status(tox_tcp);
const Tox_Connection status = tox_self_get_connection_status(tox_tcp);
ck_assert_msg(status == TOX_CONNECTION_TCP,
"expected TCP connection, but got %d", status);
printf("Connection (TCP): %d\n", status);

6
auto_tests/tox_many_tcp_test.c
View File

@ -62,7 +62,7 @@ START_TEST(test_many_clients_tcp)
tox_callback_friend_request(toxes[i], accept_friend_request);
uint8_t dpk[TOX_PUBLIC_KEY_SIZE];
tox_self_get_dht_id(toxes[0], dpk);
TOX_ERR_BOOTSTRAP error = TOX_ERR_BOOTSTRAP_OK;
Tox_Err_Bootstrap error = TOX_ERR_BOOTSTRAP_OK;
ck_assert_msg(tox_add_tcp_relay(toxes[i], TOX_LOCALHOST, TCP_RELAY_PORT, dpk, &error), "add relay error, %u, %d", i,
error);
uint16_t first_port = tox_self_get_udp_port(toxes[0], nullptr);
@ -91,7 +91,7 @@ loop_top:
tox_self_get_address(toxes[pairs[i].tox1], address);
TOX_ERR_FRIEND_ADD test;
Tox_Err_Friend_Add test;
uint32_t num = tox_friend_add(toxes[pairs[i].tox2], address, (const uint8_t *)"Gentoo", 7, &test);
if (test == TOX_ERR_FRIEND_ADD_ALREADY_SENT) {
@ -185,7 +185,7 @@ loop_top:
tox_self_get_address(toxes[pairs[i].tox1], address);
TOX_ERR_FRIEND_ADD test;
Tox_Err_Friend_Add test;
uint32_t num = tox_friend_add(toxes[pairs[i].tox2], address, (const uint8_t *)"Gentoo", 7, &test);
if (test == TOX_ERR_FRIEND_ADD_ALREADY_SENT) {

2
auto_tests/tox_many_test.c
View File

@ -68,7 +68,7 @@ loop_top:
tox_self_get_address(toxes[pairs[i].tox1], address);
TOX_ERR_FRIEND_ADD test;
Tox_Err_Friend_Add test;
uint32_t num = tox_friend_add(toxes[pairs[i].tox2], address, (const uint8_t *)"Gentoo", 7, &test);
if (test == TOX_ERR_FRIEND_ADD_ALREADY_SENT) {

4
auto_tests/tox_one_test.c
View File

@ -44,7 +44,7 @@ static void test_one(void)
uint8_t address[TOX_ADDRESS_SIZE];
tox_self_get_address(tox1, address);
TOX_ERR_FRIEND_ADD error;
Tox_Err_Friend_Add error;
uint32_t ret = tox_friend_add(tox1, address, (const uint8_t *)"m", 1, &error);
ck_assert_msg(ret == UINT32_MAX && error == TOX_ERR_FRIEND_ADD_OWN_KEY, "Adding own address worked.");
@ -82,7 +82,7 @@ static void test_one(void)
tox_get_savedata(tox1, data);
tox_kill(tox2);
TOX_ERR_NEW err_n;
Tox_Err_New err_n;
struct Tox_Options *options = tox_options_new(nullptr);
tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE);

38
auto_tests/toxav_basic_test.c
View File

@ -28,7 +28,7 @@
#define ck_assert_call_control(a, b, c) do { \
TOXAV_ERR_CALL_CONTROL cc_err; \
Toxav_Err_Call_Control cc_err; \
bool ok = toxav_call_control(a, b, c, &cc_err); \
if (!ok) { \
printf("toxav_call_control returned error %d\n", cc_err); \
@ -113,7 +113,7 @@ static void regular_call_flow(
clear_call_control(AliceCC);
clear_call_control(BobCC);
TOXAV_ERR_CALL call_err;
Toxav_Err_Call call_err;
toxav_call(AliceAV, 0, a_br, v_br, &call_err);
if (call_err != TOXAV_ERR_CALL_OK) {
@ -125,7 +125,7 @@ static void regular_call_flow(
do {
if (BobCC->incoming) {
TOXAV_ERR_ANSWER answer_err;
Toxav_Err_Answer answer_err;
toxav_answer(BobAV, 0, a_br, v_br, &answer_err);
if (answer_err != TOXAV_ERR_ANSWER_OK) {
@ -137,7 +137,7 @@ static void regular_call_flow(
} else { /* TODO(mannol): rtp */
if (time(nullptr) - start_time >= 1) {
TOXAV_ERR_CALL_CONTROL cc_err;
Toxav_Err_Call_Control cc_err;
toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &cc_err);
if (cc_err != TOXAV_ERR_CALL_CONTROL_OK) {
@ -162,7 +162,7 @@ static void test_av_flows(void)
CallControl AliceCC, BobCC;
{
TOX_ERR_NEW error;
Tox_Err_New error;
bootstrap = tox_new_log(nullptr, &error, &index[0]);
ck_assert(error == TOX_ERR_NEW_OK);
@ -215,7 +215,7 @@ static void test_av_flows(void)
{
TOXAV_ERR_NEW error;
Toxav_Err_New error;
AliceAV = toxav_new(Alice, &error);
ck_assert(error == TOXAV_ERR_NEW_OK);
@ -261,7 +261,7 @@ static void test_av_flows(void)
clear_call_control(&BobCC);
{
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -276,7 +276,7 @@ static void test_av_flows(void)
/* Reject */
{
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(BobAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@ -299,7 +299,7 @@ static void test_av_flows(void)
clear_call_control(&BobCC);
{
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -314,7 +314,7 @@ static void test_av_flows(void)
/* Cancel */
{
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@ -339,7 +339,7 @@ static void test_av_flows(void)
/* Assume sending audio and video */
{
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, 0, 48, 1000, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -361,7 +361,7 @@ static void test_av_flows(void)
ck_assert(!toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_SHOW_VIDEO, nullptr));
{
TOXAV_ERR_ANSWER rc;
Toxav_Err_Answer rc;
toxav_answer(BobAV, 0, 48, 4000, &rc);
if (rc != TOXAV_ERR_ANSWER_OK) {
@ -406,7 +406,7 @@ static void test_av_flows(void)
ck_assert(BobCC.state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_V);
{
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@ -429,7 +429,7 @@ static void test_av_flows(void)
/* Assume sending audio and video */
{
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -443,7 +443,7 @@ static void test_av_flows(void)
} while (!BobCC.incoming);
{
TOXAV_ERR_ANSWER rc;
Toxav_Err_Answer rc;
toxav_answer(BobAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_ANSWER_OK) {
@ -474,7 +474,7 @@ static void test_av_flows(void)
ck_assert(!(BobCC.state & TOXAV_FRIEND_CALL_STATE_SENDING_A));
{
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@ -497,7 +497,7 @@ static void test_av_flows(void)
/* Assume sending audio and video */
{
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -511,7 +511,7 @@ static void test_av_flows(void)
} while (!BobCC.incoming);
{
TOXAV_ERR_ANSWER rc;
Toxav_Err_Answer rc;
toxav_answer(BobAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_ANSWER_OK) {
@ -534,7 +534,7 @@ static void test_av_flows(void)
iterate_tox(bootstrap, Alice, Bob);
{
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {

10
auto_tests/toxav_many_test.c
View File

@ -82,7 +82,7 @@ static void t_accept_friend_request_cb(Tox *m, const uint8_t *public_key, const
*/
static ToxAV *setup_av_instance(Tox *tox, CallControl *CC)
{
TOXAV_ERR_NEW error;
Toxav_Err_New error;
ToxAV *av = toxav_new(tox, &error);
ck_assert(error == TOXAV_ERR_NEW_OK);
@ -107,7 +107,7 @@ static void *call_thread(void *pd)
memset(BobCC, 0, sizeof(CallControl));
{ /* Call */
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, friend_number, 48, 3000, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -121,7 +121,7 @@ static void *call_thread(void *pd)
} while (!BobCC->incoming);
{ /* Answer */
TOXAV_ERR_ANSWER rc;
Toxav_Err_Answer rc;
toxav_answer(BobAV, 0, 8, 500, &rc);
if (rc != TOXAV_ERR_ANSWER_OK) {
@ -153,7 +153,7 @@ static void *call_thread(void *pd)
} while (time(nullptr) - start_time < 4);
{ /* Hangup */
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(AliceAV, friend_number, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@ -184,7 +184,7 @@ static void test_av_three_calls(void)
CallControl AliceCC[3], BobsCC[3];
{
TOX_ERR_NEW error;
Tox_Err_New error;
bootstrap = tox_new_log(nullptr, &error, &index[0]);
ck_assert(error == TOX_ERR_NEW_OK);

2
auto_tests/typing_test.c
View File

@ -48,7 +48,7 @@ static void test_typing(Tox **toxes, State *state)
iterate_all_wait(2, toxes, state, 200);
} while (state[1].friend_is_typing);
TOX_ERR_FRIEND_QUERY err_t;
Tox_Err_Friend_Query err_t;
ck_assert_msg(tox_friend_get_typing(toxes[1], 0, &err_t) == 0,
"tox_friend_get_typing should have returned false, but it didn't");
ck_assert_msg(err_t == TOX_ERR_FRIEND_QUERY_OK, "tox_friend_get_typing call did not return correct error");

18
testing/av_test.c
View File

@ -245,7 +245,7 @@ static void initialize_tox(Tox **bootstrap, ToxAV **AliceAV, CallControl *AliceC
tox_options_set_ipv6_enabled(opts, false);
{
TOX_ERR_NEW error;
Tox_Err_New error;
tox_options_set_start_port(opts, 33445);
*bootstrap = tox_new(opts, &error);
@ -298,7 +298,7 @@ static void initialize_tox(Tox **bootstrap, ToxAV **AliceAV, CallControl *AliceC
}
TOXAV_ERR_NEW rc;
Toxav_Err_New rc;
*AliceAV = toxav_new(Alice, &rc);
assert(rc == TOXAV_ERR_NEW_OK);
@ -590,7 +590,7 @@ CHECK_ARG:
BobCC.arb = rb_new(16);
{ /* Call */
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -604,7 +604,7 @@ CHECK_ARG:
}
{ /* Answer */
TOXAV_ERR_ANSWER rc;
Toxav_Err_Answer rc;
toxav_answer(BobAV, 0, 48, 0, &rc);
if (rc != TOXAV_ERR_ANSWER_OK) {
@ -677,7 +677,7 @@ CHECK_ARG:
int64_t count = sf_read_short(af_handle, PCM, frame_size);
if (count > 0) {
TOXAV_ERR_SEND_FRAME rc;
Toxav_Err_Send_Frame rc;
if (toxav_audio_send_frame(AliceAV, 0, PCM, count / af_info.channels, af_info.channels, af_info.samplerate,
&rc) == false) {
@ -695,7 +695,7 @@ CHECK_ARG:
sf_close(af_handle);
{ /* Hangup */
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {
@ -737,7 +737,7 @@ CHECK_ARG:
memset(&BobCC, 0, sizeof(CallControl));
{ /* Call */
TOXAV_ERR_CALL rc;
Toxav_Err_Call rc;
toxav_call(AliceAV, 0, 0, 2000, &rc);
if (rc != TOXAV_ERR_CALL_OK) {
@ -751,7 +751,7 @@ CHECK_ARG:
}
{ /* Answer */
TOXAV_ERR_ANSWER rc;
Toxav_Err_Answer rc;
toxav_answer(BobAV, 0, 0, 5000, &rc);
if (rc != TOXAV_ERR_ANSWER_OK) {
@ -801,7 +801,7 @@ CHECK_ARG:
cvReleaseCapture(&capture);
{ /* Hangup */
TOXAV_ERR_CALL_CONTROL rc;
Toxav_Err_Call_Control rc;
toxav_call_control(AliceAV, 0, TOXAV_CALL_CONTROL_CANCEL, &rc);
if (rc != TOXAV_ERR_CALL_CONTROL_OK) {

8
testing/misc_tools.c
View File

@ -155,7 +155,7 @@ int cmdline_parsefor_ipv46(int argc, char **argv, uint8_t *ipv6enabled)
return argvoffset;
}
static const char *tox_log_level_name(TOX_LOG_LEVEL level)
static const char *tox_log_level_name(Tox_Log_Level level)
{
switch (level) {
case TOX_LOG_LEVEL_TRACE:
@ -177,7 +177,7 @@ static const char *tox_log_level_name(TOX_LOG_LEVEL level)
return "<unknown>";
}
void print_debug_log(Tox *m, TOX_LOG_LEVEL level, const char *file, uint32_t line, const char *func,
void print_debug_log(Tox *m, Tox_Log_Level level, const char *file, uint32_t line, const char *func,
const char *message, void *user_data)
{
if (level == TOX_LOG_LEVEL_TRACE) {
@ -188,7 +188,7 @@ void print_debug_log(Tox *m, TOX_LOG_LEVEL level, const char *file, uint32_t lin
fprintf(stderr, "[#%u] %s %s:%u\t%s:\t%s\n", index, tox_log_level_name(level), file, line, func, message);
}
Tox *tox_new_log_lan(struct Tox_Options *options, TOX_ERR_NEW *err, void *log_user_data, bool lan_discovery)
Tox *tox_new_log_lan(struct Tox_Options *options, Tox_Err_New *err, void *log_user_data, bool lan_discovery)
{
struct Tox_Options *log_options = options;
@ -212,7 +212,7 @@ Tox *tox_new_log_lan(struct Tox_Options *options, TOX_ERR_NEW *err, void *log_us
return tox;
}
Tox *tox_new_log(struct Tox_Options *options, TOX_ERR_NEW *err, void *log_user_data)
Tox *tox_new_log(struct Tox_Options *options, Tox_Err_New *err, void *log_user_data)
{
return tox_new_log_lan(options, err, log_user_data, false);
}

6
testing/misc_tools.h
View File

@ -17,11 +17,11 @@ void to_hex(char *out, uint8_t *in, int size);
int tox_strncasecmp(const char *s1, const char *s2, size_t n);
int cmdline_parsefor_ipv46(int argc, char **argv, uint8_t *ipv6enabled);
void print_debug_log(Tox *m, TOX_LOG_LEVEL level, const char *file, uint32_t line, const char *func,
void print_debug_log(Tox *m, Tox_Log_Level level, const char *file, uint32_t line, const char *func,
const char *message, void *user_data);
Tox *tox_new_log(struct Tox_Options *options, TOX_ERR_NEW *err, void *log_user_data);
Tox *tox_new_log_lan(struct Tox_Options *options, TOX_ERR_NEW *err, void *log_user_data, bool lan_discovery);
Tox *tox_new_log(struct Tox_Options *options, Tox_Err_New *err, void *log_user_data);
Tox *tox_new_log_lan(struct Tox_Options *options, Tox_Err_New *err, void *log_user_data, bool lan_discovery);
int use_test_rng(uint32_t seed);

28
testing/random_testing.cc
View File

@ -119,7 +119,7 @@ struct Global_State : std::vector<Local_State> {
Global_State::~Global_State() {}
void handle_friend_connection_status(Tox *tox, uint32_t friend_number,
TOX_CONNECTION connection_status, void *user_data) {
Tox_Connection connection_status, void *user_data) {
Local_State *state = static_cast<Local_State *>(user_data);
if (connection_status == TOX_CONNECTION_NONE) {
@ -130,7 +130,7 @@ void handle_friend_connection_status(Tox *tox, uint32_t friend_number,
}
}
void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type,
void handle_conference_invite(Tox *tox, uint32_t friend_number, Tox_Conference_Type type,
const uint8_t *cookie, size_t length, void *user_data) {
Local_State *state = static_cast<Local_State *>(user_data);
@ -138,13 +138,13 @@ void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFERENCE_T
std::printf("Tox #%u joins the conference it was invited to\n", state->id());
}
TOX_ERR_CONFERENCE_JOIN err;
Tox_Err_Conference_Join err;
tox_conference_join(tox, friend_number, cookie, length, &err);
assert(err == TOX_ERR_CONFERENCE_JOIN_OK);
}
void handle_conference_message(Tox *tox, uint32_t conference_number, uint32_t peer_number,
TOX_MESSAGE_TYPE type, const uint8_t *message, size_t length,
Tox_Message_Type type, const uint8_t *message, size_t length,
void *user_data) {
Local_State *state = static_cast<Local_State *>(user_data);
@ -161,7 +161,7 @@ void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_number, v
std::printf("Tox #%u rebuilds peer list for conference %u\n", state->id(), conference_number);
}
TOX_ERR_CONFERENCE_PEER_QUERY err;
Tox_Err_Conference_Peer_Query err;
uint32_t const count = tox_conference_peer_count(tox, conference_number, &err);
assert(err == TOX_ERR_CONFERENCE_PEER_QUERY_OK);
@ -182,7 +182,7 @@ Global_State make_toxes(std::vector<Action> const &actions) {
tox_options_set_local_discovery_enabled(options.get(), false);
for (uint32_t i = 0; i < NUM_TOXES; i++) {
TOX_ERR_NEW err;
Tox_Err_New err;
toxes.emplace_back(Tox_Ptr(tox_new(options.get(), &err)), i);
assert(err == TOX_ERR_NEW_OK);
assert(toxes.back().tox() != nullptr);
@ -201,7 +201,7 @@ Global_State make_toxes(std::vector<Action> const &actions) {
const uint16_t dht_port = tox_self_get_udp_port(toxes.front().tox(), nullptr);
for (Local_State const &state : toxes) {
TOX_ERR_BOOTSTRAP err;
Tox_Err_Bootstrap err;
tox_bootstrap(state.tox(), "localhost", dht_port, dht_key, &err);
assert(err == TOX_ERR_BOOTSTRAP_OK);
}
@ -211,7 +211,7 @@ Global_State make_toxes(std::vector<Action> const &actions) {
for (Local_State const &state1 : toxes) {
for (Local_State const &state2 : toxes) {
if (state1.tox() != state2.tox()) {
TOX_ERR_FRIEND_ADD err;
Tox_Err_Friend_Add err;
uint8_t key[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(state1.tox(), key);
@ -289,7 +289,7 @@ int main() {
return tox_conference_get_chatlist_size(state.tox()) < MAX_CONFERENCES_PER_USER;
},
[](Local_State *state, Random *rnd, std::mt19937 *rng) {
TOX_ERR_CONFERENCE_NEW err;
Tox_Err_Conference_New err;
tox_conference_new(state->tox(), &err);
assert(err == TOX_ERR_CONFERENCE_NEW_OK);
},
@ -303,7 +303,7 @@ int main() {
[](Local_State *state, Random *rnd, std::mt19937 *rng) {
size_t chat_count = tox_conference_get_chatlist_size(state->tox());
assert(chat_count != 0); // Condition above.
TOX_ERR_CONFERENCE_INVITE err;
Tox_Err_Conference_Invite err;
tox_conference_invite(state->tox(), rnd->friend_selector(*rng),
state->next_invite % chat_count, &err);
state->next_invite++;
@ -317,7 +317,7 @@ int main() {
return tox_conference_get_chatlist_size(state.tox()) != 0;
},
[](Local_State *state, Random *rnd, std::mt19937 *rng) {
TOX_ERR_CONFERENCE_DELETE err;
Tox_Err_Conference_Delete err;
tox_conference_delete(state->tox(), tox_conference_get_chatlist_size(state->tox()) - 1,
&err);
assert(err == TOX_ERR_CONFERENCE_DELETE_OK);
@ -335,7 +335,7 @@ int main() {
byte = rnd->byte_selector(*rng);
}
TOX_ERR_CONFERENCE_SEND_MESSAGE err;
Tox_Err_Conference_Send_Message err;
tox_conference_send_message(
state->tox(), tox_conference_get_chatlist_size(state->tox()) - 1,
TOX_MESSAGE_TYPE_NORMAL, message.data(), message.size(), &err);
@ -356,7 +356,7 @@ int main() {
byte = rnd->byte_selector(*rng);
}
TOX_ERR_SET_INFO err;
Tox_Err_Set_Info err;
tox_self_set_name(state->tox(), name.data(), name.size(), &err);
assert(err == TOX_ERR_SET_INFO_OK);
@ -368,7 +368,7 @@ int main() {
"sets their name to empty",
[](Local_State const &state) { return true; },
[](Local_State *state, Random *rnd, std::mt19937 *rng) {
TOX_ERR_SET_INFO err;
Tox_Err_Set_Info err;
tox_self_set_name(state->tox(), nullptr, 0, &err);
assert(err == TOX_ERR_SET_INFO_OK);
},

6
toxcore/tox_api.c
View File

@ -44,14 +44,14 @@ void tox_options_set_##ns##name(struct Tox_Options *options, type name) \
ACCESSORS(bool,, ipv6_enabled)
ACCESSORS(bool,, udp_enabled)
ACCESSORS(TOX_PROXY_TYPE, proxy_, type)
ACCESSORS(Tox_Proxy_Type, proxy_, type)
ACCESSORS(const char *, proxy_, host)
ACCESSORS(uint16_t, proxy_, port)
ACCESSORS(uint16_t,, start_port)
ACCESSORS(uint16_t,, end_port)
ACCESSORS(uint16_t,, tcp_port)
ACCESSORS(bool,, hole_punching_enabled)
ACCESSORS(TOX_SAVEDATA_TYPE, savedata_, type)
ACCESSORS(Tox_Savedata_Type, savedata_, type)
ACCESSORS(size_t, savedata_, length)
ACCESSORS(tox_log_cb *, log_, callback)
ACCESSORS(void *, log_, user_data)
@ -81,7 +81,7 @@ void tox_options_default(struct Tox_Options *options)
}
}
struct Tox_Options *tox_options_new(TOX_ERR_OPTIONS_NEW *error)
struct Tox_Options *tox_options_new(Tox_Err_Options_New *error)
{
struct Tox_Options *options = (struct Tox_Options *)malloc(sizeof(struct Tox_Options));

5
toxencryptsave/toxencryptsave.api.h
View File

@ -313,5 +313,10 @@ static bool is_data_encrypted(const uint8_t *data);
}
#endif
typedef TOX_ERR_KEY_DERIVATION Tox_Err_Key_Derivation;
typedef TOX_ERR_ENCRYPTION Tox_Err_Encryption;
typedef TOX_ERR_DECRYPTION Tox_Err_Decryption;
typedef TOX_ERR_GET_SALT Tox_Err_Get_Salt;
#endif // C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H
%}

16
toxencryptsave/toxencryptsave.c
View File

@ -91,7 +91,7 @@ void tox_pass_key_free(Tox_Pass_Key *pass_key)
* success does not say anything about the validity of the data, only that data of
* the appropriate size was copied
*/
bool tox_get_salt(const uint8_t *data, uint8_t *salt, TOX_ERR_GET_SALT *error)
bool tox_get_salt(const uint8_t *data, uint8_t *salt, Tox_Err_Get_Salt *error)
{
if (!data || !salt) {
SET_ERROR_PARAMETER(error, TOX_ERR_GET_SALT_NULL);
@ -121,7 +121,7 @@ bool tox_get_salt(const uint8_t *data, uint8_t *salt, TOX_ERR_GET_SALT *error)
* returns true on success
*/
Tox_Pass_Key *tox_pass_key_derive(const uint8_t *passphrase, size_t pplength,
TOX_ERR_KEY_DERIVATION *error)
Tox_Err_Key_Derivation *error)
{
uint8_t salt[crypto_pwhash_scryptsalsa208sha256_SALTBYTES];
random_bytes(salt, sizeof salt);
@ -132,7 +132,7 @@ Tox_Pass_Key *tox_pass_key_derive(const uint8_t *passphrase, size_t pplength,
* The salt must be TOX_PASS_SALT_LENGTH bytes in length.
*/
Tox_Pass_Key *tox_pass_key_derive_with_salt(const uint8_t *passphrase, size_t pplength,
const uint8_t *salt, TOX_ERR_KEY_DERIVATION *error)
const uint8_t *salt, Tox_Err_Key_Derivation *error)
{
if (!salt || (!passphrase && pplength != 0)) {
SET_ERROR_PARAMETER(error, TOX_ERR_KEY_DERIVATION_NULL);
@ -181,7 +181,7 @@ Tox_Pass_Key *tox_pass_key_derive_with_salt(const uint8_t *passphrase, size_t pp
* returns true on success
*/
bool tox_pass_key_encrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t data_len, uint8_t *out,
TOX_ERR_ENCRYPTION *error)
Tox_Err_Encryption *error)
{
if (data_len == 0 || !data || !key || !out) {
SET_ERROR_PARAMETER(error, TOX_ERR_ENCRYPTION_NULL);
@ -227,9 +227,9 @@ bool tox_pass_key_encrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t d
* returns true on success
*/
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_Encryption *error)
{
TOX_ERR_KEY_DERIVATION _error;
Tox_Err_Key_Derivation _error;
Tox_Pass_Key *key = tox_pass_key_derive(passphrase, pplength, &_error);
if (!key) {
@ -255,7 +255,7 @@ bool tox_pass_encrypt(const uint8_t *data, size_t data_len, const uint8_t *passp
* returns true on success
*/
bool tox_pass_key_decrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t length, uint8_t *out,
TOX_ERR_DECRYPTION *error)
Tox_Err_Decryption *error)
{
if (length <= TOX_PASS_ENCRYPTION_EXTRA_LENGTH) {
SET_ERROR_PARAMETER(error, TOX_ERR_DECRYPTION_INVALID_LENGTH);
@ -301,7 +301,7 @@ bool tox_pass_key_decrypt(const Tox_Pass_Key *key, const uint8_t *data, size_t l
* returns true on success
*/
bool tox_pass_decrypt(const uint8_t *data, size_t length, const uint8_t *passphrase, size_t pplength, uint8_t *out,
TOX_ERR_DECRYPTION *error)
Tox_Err_Decryption *error)
{
if (length <= TOX_PASS_ENCRYPTION_EXTRA_LENGTH) {
SET_ERROR_PARAMETER(error, TOX_ERR_DECRYPTION_INVALID_LENGTH);

5
toxencryptsave/toxencryptsave.h
View File

@ -375,4 +375,9 @@ bool tox_is_data_encrypted(const uint8_t *data);
}
#endif
typedef TOX_ERR_KEY_DERIVATION Tox_Err_Key_Derivation;
typedef TOX_ERR_ENCRYPTION Tox_Err_Encryption;
typedef TOX_ERR_DECRYPTION Tox_Err_Decryption;
typedef TOX_ERR_GET_SALT Tox_Err_Get_Salt;
#endif // C_TOXCORE_TOXENCRYPTSAVE_TOXENCRYPTSAVE_H