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

cleanup: Remove all uses of TOX_*_MAX_SIZE macros.

Browse Source 
We should use the functions for these instead.
This commit is contained in:
iphydf 2022-03-30 20:04:01 +00:00
parent 3cc72f5f57
commit b09a1ff02d
No known key found for this signature in database
GPG Key ID: 3855DBA2D74403C9
8 changed files with 119 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
auto_tests/file_saving_test.c
View File

@ -95,16 +95,17 @@ static void load_data_decrypted(void)
ck_assert_msg(t != nullptr, "tox_new returned the error value %d", err);
uint8_t readname[TOX_MAX_NAME_LENGTH];
uint8_t *readname = (uint8_t *)malloc(tox_self_get_name_size(t));
ck_assert(readname != nullptr);
tox_self_get_name(t, readname);
readname[tox_self_get_name_size(t)] = '\0';
ck_assert_msg(strcmp((const char *)readname, name) == 0,
ck_assert_msg(memcmp(readname, name, tox_self_get_name_size(t)) == 0,
"name returned by tox_self_get_name does not match expected result");
tox_kill(t);
free(clear);
free(cipher);
free(readname);
fclose(f);
}

29
auto_tests/lossless_packet_test.c
View File

@ -7,8 +7,6 @@
#include <time.h>
#include "../testing/misc_tools.h"
#include "../toxcore/ccompat.h"
#include "../toxcore/tox.h"
#include "../toxcore/util.h"
#include "check_compat.h"
@ -20,32 +18,37 @@ typedef struct State {
#define LOSSLESS_PACKET_FILLER 160
static void handle_lossless_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
void *user_data)
static void handle_lossless_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length, void *user_data)
{
uint8_t *cmp_packet = (uint8_t *)malloc(tox_max_custom_packet_size());
ck_assert(cmp_packet != nullptr);
memset(cmp_packet, LOSSLESS_PACKET_FILLER, tox_max_custom_packet_size());
if (length == tox_max_custom_packet_size() && memcmp(data, cmp_packet, tox_max_custom_packet_size()) == 0) {
const AutoTox *autotox = (AutoTox *)user_data;
State *state = (State *)autotox->state;
uint8_t cmp_packet[TOX_MAX_CUSTOM_PACKET_SIZE];
memset(cmp_packet, LOSSLESS_PACKET_FILLER, sizeof(cmp_packet));
if (length == TOX_MAX_CUSTOM_PACKET_SIZE && memcmp(data, cmp_packet, sizeof(cmp_packet)) == 0) {
state->custom_packet_received = true;
}
free(cmp_packet);
}
static void test_lossless_packet(AutoTox *autotoxes)
{
tox_callback_friend_lossless_packet(autotoxes[1].tox, &handle_lossless_packet);
uint8_t packet[TOX_MAX_CUSTOM_PACKET_SIZE + 1];
memset(packet, LOSSLESS_PACKET_FILLER, sizeof(packet));
const size_t packet_size = tox_max_custom_packet_size() + 1;
uint8_t *packet = (uint8_t *)malloc(packet_size);
ck_assert(packet != nullptr);
memset(packet, LOSSLESS_PACKET_FILLER, packet_size);
bool ret = tox_friend_send_lossless_packet(autotoxes[0].tox, 0, packet, sizeof(packet), nullptr);
bool ret = tox_friend_send_lossless_packet(autotoxes[0].tox, 0, packet, packet_size, nullptr);
ck_assert_msg(ret == false, "should not be able to send custom packets this big %i", ret);
ret = tox_friend_send_lossless_packet(autotoxes[0].tox, 0, packet, TOX_MAX_CUSTOM_PACKET_SIZE, nullptr);
ret = tox_friend_send_lossless_packet(autotoxes[0].tox, 0, packet, tox_max_custom_packet_size(), nullptr);
ck_assert_msg(ret == true, "tox_friend_send_lossless_packet fail %i", ret);
free(packet);
do {
iterate_all_wait(autotoxes, 2, ITERATION_INTERVAL);
} while (!((State *)autotoxes[1].state)->custom_packet_received);

21
auto_tests/lossy_packet_test.c
View File

@ -20,28 +20,35 @@ typedef struct State {
static void handle_lossy_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length, void *user_data)
{
uint8_t cmp_packet[TOX_MAX_CUSTOM_PACKET_SIZE];
memset(cmp_packet, LOSSY_PACKET_FILLER, sizeof(cmp_packet));
uint8_t *cmp_packet = (uint8_t *)malloc(tox_max_custom_packet_size());
ck_assert(cmp_packet != nullptr);
memset(cmp_packet, LOSSY_PACKET_FILLER, tox_max_custom_packet_size());
if (length == TOX_MAX_CUSTOM_PACKET_SIZE && memcmp(data, cmp_packet, sizeof(cmp_packet)) == 0) {
if (length == tox_max_custom_packet_size() && memcmp(data, cmp_packet, tox_max_custom_packet_size()) == 0) {
const AutoTox *autotox = (AutoTox *)user_data;
State *state = (State *)autotox->state;
state->custom_packet_received = true;
}
free(cmp_packet);
}
static void test_lossy_packet(AutoTox *autotoxes)
{
tox_callback_friend_lossy_packet(autotoxes[1].tox, &handle_lossy_packet);
uint8_t packet[TOX_MAX_CUSTOM_PACKET_SIZE + 1];
memset(packet, LOSSY_PACKET_FILLER, sizeof(packet));
const size_t packet_size = tox_max_custom_packet_size() + 1;
uint8_t *packet = (uint8_t *)malloc(packet_size);
ck_assert(packet != nullptr);
memset(packet, LOSSY_PACKET_FILLER, packet_size);
bool ret = tox_friend_send_lossy_packet(autotoxes[0].tox, 0, packet, sizeof(packet), nullptr);
bool ret = tox_friend_send_lossy_packet(autotoxes[0].tox, 0, packet, packet_size, nullptr);
ck_assert_msg(ret == false, "should not be able to send custom packets this big %i", ret);
ret = tox_friend_send_lossy_packet(autotoxes[0].tox, 0, packet, TOX_MAX_CUSTOM_PACKET_SIZE, nullptr);
ret = tox_friend_send_lossy_packet(autotoxes[0].tox, 0, packet, tox_max_custom_packet_size(), nullptr);
ck_assert_msg(ret == true, "tox_friend_send_lossy_packet fail %i", ret);
free(packet);
do {
iterate_all_wait(autotoxes, 2, ITERATION_INTERVAL);
} while (!((State *)autotoxes[1].state)->custom_packet_received);

8
auto_tests/save_compatibility_test.c
View File

@ -92,7 +92,8 @@ static void test_save_compatibility(const char *save_path)
ck_assert_msg(name_size == EXPECTED_NAME_SIZE, "name sizes do not match expected %zu got %zu", EXPECTED_NAME_SIZE,
name_size);
uint8_t name[TOX_MAX_NAME_LENGTH];
uint8_t *name = (uint8_t *)malloc(tox_self_get_name_size(tox));
ck_assert(name != nullptr);
tox_self_get_name(tox, name);
ck_assert_msg(strncmp((const char *)name, EXPECTED_NAME, name_size) == 0,
"names do not match, expected %s got %s", EXPECTED_NAME, name);
@ -101,7 +102,8 @@ static void test_save_compatibility(const char *save_path)
ck_assert_msg(status_message_size == EXPECTED_STATUS_MESSAGE_SIZE,
"status message sizes do not match, expected %zu got %zu", EXPECTED_STATUS_MESSAGE_SIZE, status_message_size);
uint8_t status_message[TOX_MAX_STATUS_MESSAGE_LENGTH];
uint8_t *status_message = (uint8_t *)malloc(tox_self_get_status_message_size(tox));
ck_assert(status_message != nullptr);
tox_self_get_status_message(tox, status_message);
ck_assert_msg(strncmp((const char *)status_message, EXPECTED_STATUS_MESSAGE, status_message_size) == 0,
"status messages do not match, expected %s got %s",
@ -128,6 +130,8 @@ static void test_save_compatibility(const char *save_path)
/* Giving the tox a chance to error on iterate due to corrupted loaded structures */
tox_iterate(tox, nullptr);
free(status_message);
free(name);
tox_kill(tox);
}

47
auto_tests/save_friend_test.c
View File

@ -13,8 +13,8 @@
#include "check_compat.h"
struct test_data {
uint8_t name[TOX_MAX_NAME_LENGTH];
uint8_t status_message[TOX_MAX_STATUS_MESSAGE_LENGTH];
uint8_t *name;
uint8_t *status_message;
bool received_name;
bool received_status_message;
};
@ -31,10 +31,23 @@ static void set_random(Tox *m, bool (*setter)(Tox *, const uint8_t *, size_t, To
setter(m, text, SIZEOF_VLA(text), nullptr);
}
static void alloc_string(uint8_t **to, size_t length)
{
free(*to);
*to = (uint8_t *)malloc(length);
ck_assert(*to != nullptr);
}
static void set_string(uint8_t **to, const uint8_t *from, size_t length)
{
alloc_string(to, length);
memcpy(*to, from, length);
}
static void namechange_callback(Tox *tox, uint32_t friend_number, const uint8_t *name, size_t length, void *user_data)
{
struct test_data *to_compare = (struct test_data *)user_data;
memcpy(to_compare->name, name, length);
set_string(&to_compare->name, name, length);
to_compare->received_name = true;
}
@ -42,7 +55,7 @@ static void statuschange_callback(Tox *tox, uint32_t friend_number, const uint8_
void *user_data)
{
struct test_data *to_compare = (struct test_data *)user_data;
memcpy(to_compare->status_message, message, length);
set_string(&to_compare->status_message, message, length);
to_compare->received_status_message = true;
}
@ -60,7 +73,7 @@ int main(void)
tox_bootstrap(tox2, "localhost", dht_port, dht_key, nullptr);
struct test_data to_compare = {{0}};
struct test_data to_compare = {nullptr};
uint8_t public_key[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(tox1, public_key);
@ -68,13 +81,15 @@ int main(void)
tox_self_get_public_key(tox2, public_key);
tox_friend_add_norequest(tox1, public_key, nullptr);
uint8_t reference_name[TOX_MAX_NAME_LENGTH] = { 0 };
uint8_t reference_status[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 };
uint8_t *reference_name = (uint8_t *)malloc(tox_max_name_length());
uint8_t *reference_status = (uint8_t *)malloc(tox_max_status_message_length());
ck_assert(reference_name != nullptr);
ck_assert(reference_status != nullptr);
set_random(tox1, tox_self_set_name, TOX_MAX_NAME_LENGTH);
set_random(tox2, tox_self_set_name, TOX_MAX_NAME_LENGTH);
set_random(tox1, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH);
set_random(tox2, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH);
set_random(tox1, tox_self_set_name, tox_max_name_length());
set_random(tox2, tox_self_set_name, tox_max_name_length());
set_random(tox1, tox_self_set_status_message, tox_max_status_message_length());
set_random(tox2, tox_self_set_status_message, tox_max_status_message_length());
tox_self_get_name(tox2, reference_name);
tox_self_get_status_message(tox2, reference_status);
@ -118,12 +133,14 @@ int main(void)
Tox *const tox_to_compare = tox_new_log(options, nullptr, nullptr);
alloc_string(&to_compare.name, tox_friend_get_name_size(tox_to_compare, 0, nullptr));
tox_friend_get_name(tox_to_compare, 0, to_compare.name, nullptr);
alloc_string(&to_compare.status_message, tox_friend_get_status_message_size(tox_to_compare, 0, nullptr));
tox_friend_get_status_message(tox_to_compare, 0, to_compare.status_message, nullptr);
ck_assert_msg(memcmp(reference_name, to_compare.name, TOX_MAX_NAME_LENGTH) == 0,
ck_assert_msg(memcmp(reference_name, to_compare.name, tox_max_name_length()) == 0,
"incorrect name: should be all zeroes");
ck_assert_msg(memcmp(reference_status, to_compare.status_message, TOX_MAX_STATUS_MESSAGE_LENGTH) == 0,
ck_assert_msg(memcmp(reference_status, to_compare.status_message, tox_max_status_message_length()) == 0,
"incorrect status message: should be all zeroes");
tox_options_free(options);
@ -131,6 +148,10 @@ int main(void)
tox_kill(tox2);
tox_kill(tox_to_compare);
free(savedata);
free(to_compare.name);
free(to_compare.status_message);
free(reference_status);
free(reference_name);
return 0;
}

25
auto_tests/send_message_test.c
View File

@ -24,27 +24,34 @@ static void message_callback(
ck_abort_msg("Bad type");
}
uint8_t cmp_msg[TOX_MAX_MESSAGE_LENGTH];
memset(cmp_msg, MESSAGE_FILLER, sizeof(cmp_msg));
const size_t cmp_msg_len = tox_max_message_length();
uint8_t *cmp_msg = (uint8_t *)malloc(cmp_msg_len);
ck_assert(cmp_msg != nullptr);
memset(cmp_msg, MESSAGE_FILLER, cmp_msg_len);
if (length == TOX_MAX_MESSAGE_LENGTH && memcmp(string, cmp_msg, sizeof(cmp_msg)) == 0) {
if (length == tox_max_message_length() && memcmp(string, cmp_msg, cmp_msg_len) == 0) {
state->message_received = true;
}
free(cmp_msg);
}
static void send_message_test(AutoTox *autotoxes)
{
tox_callback_friend_message(autotoxes[1].tox, &message_callback);
uint8_t msgs[TOX_MAX_MESSAGE_LENGTH + 1];
memset(msgs, MESSAGE_FILLER, sizeof(msgs));
const size_t msgs_len = tox_max_message_length() + 1;
uint8_t *msgs = (uint8_t *)malloc(msgs_len);
memset(msgs, MESSAGE_FILLER, msgs_len);
Tox_Err_Friend_Send_Message errm;
tox_friend_send_message(autotoxes[0].tox, 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);
tox_friend_send_message(autotoxes[0].tox, 0, TOX_MESSAGE_TYPE_NORMAL, msgs, msgs_len, &errm);
ck_assert_msg(errm == TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG, "tox_max_message_length() is too small? error=%d", errm);
tox_friend_send_message(autotoxes[0].tox, 0, TOX_MESSAGE_TYPE_NORMAL, msgs, TOX_MAX_MESSAGE_LENGTH, &errm);
ck_assert_msg(errm == TOX_ERR_FRIEND_SEND_MESSAGE_OK, "TOX_MAX_MESSAGE_LENGTH is too big? error=%d", errm);
tox_friend_send_message(autotoxes[0].tox, 0, TOX_MESSAGE_TYPE_NORMAL, msgs, tox_max_message_length(), &errm);
ck_assert_msg(errm == TOX_ERR_FRIEND_SEND_MESSAGE_OK, "tox_max_message_length() is too big? error=%d", errm);
free(msgs);
do {
iterate_all_wait(autotoxes, 2, ITERATION_INTERVAL);

5
other/fun/save-generator.c
View File

@ -1,3 +1,4 @@
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
@ -72,8 +73,10 @@ static void print_information(Tox *tox)
int length = snprintf(nospam_str, sizeof(nospam_str), "%08X", nospam);
nospam_str[length] = '\0';
uint8_t name[TOX_MAX_NAME_LENGTH];
uint8_t *name = (uint8_t *)malloc(tox_self_get_name_size(tox) + 1);
assert(name != nullptr);
tox_self_get_name(tox, name);
name[tox_self_get_name_size(tox)] = '\0';
printf("INFORMATION\n");
printf("----------------------------------\n");

44
toxcore/tox_test.cc
View File

@ -3,6 +3,7 @@
#include <gtest/gtest.h>
#include <array>
#include <vector>
#include "crypto_core.h"
#include "tox_private.h"
@ -11,11 +12,11 @@ namespace {
static void set_random_name_and_status_message(Tox *tox, uint8_t *name, uint8_t *status_message)
{
for (uint16_t i = 0; i < TOX_MAX_NAME_LENGTH; ++i) {
for (uint16_t i = 0; i < tox_max_name_length(); ++i) {
name[i] = random_u08();
}
for (uint16_t i = 0; i < TOX_MAX_STATUS_MESSAGE_LENGTH; ++i) {
for (uint16_t i = 0; i < tox_max_status_message_length(); ++i) {
status_message[i] = random_u08();
}
}
@ -75,11 +76,11 @@ TEST(Tox, OneTest)
tox_options_set_start_port(options, 33545);
tox_options_set_end_port(options, 33545 + 2000);
std::array<uint8_t, TOX_MAX_NAME_LENGTH> name;
std::array<uint8_t, TOX_MAX_STATUS_MESSAGE_LENGTH> status_message;
std::vector<uint8_t> name(tox_max_name_length());
std::vector<uint8_t> status_message(tox_max_status_message_length());
std::array<uint8_t, TOX_MAX_NAME_LENGTH> name2;
std::array<uint8_t, TOX_MAX_STATUS_MESSAGE_LENGTH> status_message2;
std::vector<uint8_t> name2(tox_max_name_length());
std::vector<uint8_t> status_message2(tox_max_status_message_length());
Tox *tox1 = tox_new(options, nullptr);
ASSERT_NE(tox1, nullptr);
@ -97,15 +98,15 @@ TEST(Tox, OneTest)
EXPECT_EQ(ret, UINT32_MAX);
tox_self_get_address(tox2, address.data());
uint8_t message[TOX_MAX_FRIEND_REQUEST_LENGTH + 1] = {0};
std::vector<uint8_t> message(tox_max_friend_request_length() + 1);
ret = tox_friend_add(tox1, address.data(), nullptr, 0, &error);
EXPECT_EQ(error, TOX_ERR_FRIEND_ADD_NULL) << "Sending request with no message worked.";
EXPECT_EQ(ret, UINT32_MAX);
ret = tox_friend_add(tox1, address.data(), message, 0, &error);
ret = tox_friend_add(tox1, address.data(), message.data(), 0, &error);
EXPECT_EQ(error, TOX_ERR_FRIEND_ADD_NO_MESSAGE) << "Sending request with no message worked.";
EXPECT_EQ(ret, UINT32_MAX);
ret = tox_friend_add(tox1, address.data(), message, sizeof(message), &error);
EXPECT_EQ(error, TOX_ERR_FRIEND_ADD_TOO_LONG) << "TOX_MAX_FRIEND_REQUEST_LENGTH is too big.";
ret = tox_friend_add(tox1, address.data(), message.data(), message.size(), &error);
EXPECT_EQ(error, TOX_ERR_FRIEND_ADD_TOO_LONG) << "tox_max_friend_request_length() is too big.";
EXPECT_EQ(ret, UINT32_MAX);
address[0]++;
@ -114,19 +115,22 @@ TEST(Tox, OneTest)
EXPECT_EQ(ret, UINT32_MAX);
tox_self_get_address(tox2, address.data());
ret = tox_friend_add(tox1, address.data(), message, TOX_MAX_FRIEND_REQUEST_LENGTH, &error);
ret = tox_friend_add(
tox1, address.data(), message.data(), tox_max_friend_request_length(), &error);
EXPECT_EQ(error, TOX_ERR_FRIEND_ADD_OK) << "Failed to add friend.";
EXPECT_EQ(ret, 0);
ret = tox_friend_add(tox1, address.data(), message, TOX_MAX_FRIEND_REQUEST_LENGTH, &error);
ret = tox_friend_add(
tox1, address.data(), message.data(), tox_max_friend_request_length(), &error);
EXPECT_EQ(error, TOX_ERR_FRIEND_ADD_ALREADY_SENT) << "Adding friend twice worked.";
EXPECT_EQ(ret, UINT32_MAX);
tox_self_set_name(tox1, name.data(), name.size(), nullptr);
EXPECT_EQ(tox_self_get_name_size(tox1), name.size()) << "Can't set name of TOX_MAX_NAME_LENGTH";
EXPECT_EQ(tox_self_get_name_size(tox1), name.size())
<< "Can't set name of length " << tox_max_name_length();
tox_self_set_status_message(tox1, status_message.data(), status_message.size(), nullptr);
EXPECT_EQ(tox_self_get_status_message_size(tox1), status_message.size())
<< "Can't set status message of TOX_MAX_STATUS_MESSAGE_LENGTH";
<< "Can't set status message of length " << tox_max_status_message_length();
tox_self_get_address(tox1, address.data());
std::vector<uint8_t> data(tox_get_savedata_size(tox1));
@ -140,22 +144,22 @@ TEST(Tox, OneTest)
tox2 = tox_new(options, &err_n);
EXPECT_EQ(err_n, TOX_ERR_NEW_OK) << "Load failed";
EXPECT_EQ(tox_self_get_name_size(tox2), sizeof name) << "Wrong name size.";
EXPECT_EQ(tox_self_get_status_message_size(tox2), sizeof status_message)
EXPECT_EQ(tox_self_get_name_size(tox2), name.size()) << "Wrong name size.";
EXPECT_EQ(tox_self_get_status_message_size(tox2), status_message.size())
<< "Wrong status message size";
std::array<uint8_t, TOX_MAX_NAME_LENGTH> name_loaded{};
std::vector<uint8_t> name_loaded(tox_max_name_length());
tox_self_get_name(tox2, name_loaded.data());
EXPECT_EQ(name, name_loaded) << "Wrong name.";
std::array<uint8_t, TOX_MAX_STATUS_MESSAGE_LENGTH> status_message_loaded{};
std::vector<uint8_t> status_message_loaded(tox_max_status_message_length());
tox_self_get_status_message(tox2, status_message_loaded.data());
EXPECT_EQ(status_message, status_message_loaded) << "Wrong status message.";
std::array<uint8_t, TOX_ADDRESS_SIZE> address2{};
std::array<uint8_t, TOX_ADDRESS_SIZE> address2;
tox_self_get_address(tox2, address2.data());
EXPECT_EQ(address2, address) << "Wrong address.";
std::array<uint8_t, TOX_MAX_NAME_LENGTH> new_name{};
std::vector<uint8_t> new_name(tox_max_name_length());
tox_self_get_name(tox2, new_name.data());
EXPECT_EQ(name, new_name) << "Wrong name";