From b09a1ff02d18658c61fde206b9812f186455897c Mon Sep 17 00:00:00 2001 From: iphydf Date: Wed, 30 Mar 2022 20:04:01 +0000 Subject: [PATCH] cleanup: Remove all uses of `TOX_*_MAX_SIZE` macros. We should use the functions for these instead. --- auto_tests/file_saving_test.c | 7 +++-- auto_tests/lossless_packet_test.c | 31 +++++++++--------- auto_tests/lossy_packet_test.c | 21 ++++++++----- auto_tests/save_compatibility_test.c | 8 +++-- auto_tests/save_friend_test.c | 47 ++++++++++++++++++++-------- auto_tests/send_message_test.c | 25 +++++++++------ other/fun/save-generator.c | 5 ++- toxcore/tox_test.cc | 44 ++++++++++++++------------ 8 files changed, 119 insertions(+), 69 deletions(-) diff --git a/auto_tests/file_saving_test.c b/auto_tests/file_saving_test.c index 7dfba68c..58a1b6de 100644 --- a/auto_tests/file_saving_test.c +++ b/auto_tests/file_saving_test.c @@ -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); } diff --git a/auto_tests/lossless_packet_test.c b/auto_tests/lossless_packet_test.c index cf7c37b5..995e8f19 100644 --- a/auto_tests/lossless_packet_test.c +++ b/auto_tests/lossless_packet_test.c @@ -7,8 +7,6 @@ #include #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) { - const AutoTox *autotox = (AutoTox *)user_data; - State *state = (State *)autotox->state; + 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()); - 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) { + 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_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); diff --git a/auto_tests/lossy_packet_test.c b/auto_tests/lossy_packet_test.c index a7c7f905..cc8a831b 100644 --- a/auto_tests/lossy_packet_test.c +++ b/auto_tests/lossy_packet_test.c @@ -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); diff --git a/auto_tests/save_compatibility_test.c b/auto_tests/save_compatibility_test.c index 8ef5185a..74d7b51a 100644 --- a/auto_tests/save_compatibility_test.c +++ b/auto_tests/save_compatibility_test.c @@ -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); } diff --git a/auto_tests/save_friend_test.c b/auto_tests/save_friend_test.c index 715fa006..5002c2fa 100644 --- a/auto_tests/save_friend_test.c +++ b/auto_tests/save_friend_test.c @@ -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; } diff --git a/auto_tests/send_message_test.c b/auto_tests/send_message_test.c index 84a8c3b3..1509def3 100644 --- a/auto_tests/send_message_test.c +++ b/auto_tests/send_message_test.c @@ -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); diff --git a/other/fun/save-generator.c b/other/fun/save-generator.c index b2c793c0..7e8aa344 100644 --- a/other/fun/save-generator.c +++ b/other/fun/save-generator.c @@ -1,3 +1,4 @@ +#include #include #include #include @@ -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"); diff --git a/toxcore/tox_test.cc b/toxcore/tox_test.cc index 360a41e9..249ba8f7 100644 --- a/toxcore/tox_test.cc +++ b/toxcore/tox_test.cc @@ -3,6 +3,7 @@ #include #include +#include #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 name; - std::array status_message; + std::vector name(tox_max_name_length()); + std::vector status_message(tox_max_status_message_length()); - std::array name2; - std::array status_message2; + std::vector name2(tox_max_name_length()); + std::vector 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 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 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 name_loaded{}; + std::vector name_loaded(tox_max_name_length()); tox_self_get_name(tox2, name_loaded.data()); EXPECT_EQ(name, name_loaded) << "Wrong name."; - std::array status_message_loaded{}; + std::vector 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 address2{}; + std::array address2; tox_self_get_address(tox2, address2.data()); EXPECT_EQ(address2, address) << "Wrong address."; - std::array new_name{}; + std::vector new_name(tox_max_name_length()); tox_self_get_name(tox2, new_name.data()); EXPECT_EQ(name, new_name) << "Wrong name";