Green-Sky/tomato
1
0
Fork 1
Code Issues Pull Requests 1 Actions Packages Projects Releases 1 Wiki Activity

Squashed 'external/toxcore/c-toxcore/' changes from 8f0d505f9a..6d634674a9

Browse Source 
6d634674a9 cleanup: Remove old type-ordered event getters.
d1d48d1dfc feat: add ngc events
994ffecc6b refactor: Make event dispatch ordered by receive time.
812f931d5f fix: Make sure there's enough space for CONSUME1 in fuzzers.
50f1b30fa9 test: Add fuzz tests to the coverage run.
df76f5cf47 chore: Move from gcov to llvm source-based coverage.
072e3beb3f fix: issues with packet broadcast error reporting
6b6718e4d2 cleanup: Make group packet entry creation less error-prone
5b9c420ce1 refactor: packet broadcast functions now return errors
af4cb31028 refactor: Use `operator==` for equality tests of `Node_format`.
9592d590cf refactor(test): Slightly nicer C++ interface to tox Random.
c66e10fb7a refactor: Minor refactoring of get_close_nodes functions.
ebc9643862 fix: don't pass garbage data buffer to packet send functions
32b68cffca cleanup: Some more test cleanups, removing overly smart code.
0426624dcb refactor: Assign malloc return to a local variable first.
afc38f2458 test: Add more unit tests for `add_to_list`.
05ce5c1ab9 test: Add "infer" CI check to github, remove from circle.
REVERT: 8f0d505f9a feat: add ngc events
REVERT: 9b8216e70c refactor: Make event dispatch ordered by receive time.

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: 6d634674a929edb0ab70689dcbcb195b3547be13
This commit is contained in:
Green Sky
2024-01-12 21:30:48 +01:00
parent 9ace11a0e2
commit 8eb4892b49
126 changed files with 1556 additions and 2484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
toxcore/events/conference_connected.c
View File

@ -118,42 +118,6 @@ static Tox_Event_Conference_Connected *tox_events_add_conference_connected(Tox_E
return conference_connected;
}
const Tox_Event_Conference_Connected *tox_events_get_conference_connected(const Tox_Events *events, uint32_t index)
{
uint32_t conference_connected_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (conference_connected_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_CONNECTED) {
const Tox_Event_Conference_Connected *conference_connected = events->events[i].data.conference_connected;
if (conference_connected_index == index) {
return conference_connected;
}
++conference_connected_index;
}
}
return nullptr;
}
uint32_t tox_events_get_conference_connected_size(const Tox_Events *events)
{
uint32_t conference_connected_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_CONNECTED) {
++conference_connected_size;
}
}
return conference_connected_size;
}
bool tox_event_conference_connected_unpack(
Tox_Event_Conference_Connected **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/conference_invite.c
View File

@ -69,13 +69,14 @@ static bool tox_event_conference_invite_set_cookie(Tox_Event_Conference_Invite *
conference_invite->cookie_length = 0;
}
conference_invite->cookie = (uint8_t *)malloc(cookie_length);
uint8_t *cookie_copy = (uint8_t *)malloc(cookie_length);
if (conference_invite->cookie == nullptr) {
if (cookie_copy == nullptr) {
return false;
}
memcpy(conference_invite->cookie, cookie, cookie_length);
memcpy(cookie_copy, cookie, cookie_length);
conference_invite->cookie = cookie_copy;
conference_invite->cookie_length = cookie_length;
return true;
}
@ -179,42 +180,6 @@ static Tox_Event_Conference_Invite *tox_events_add_conference_invite(Tox_Events
return conference_invite;
}
const Tox_Event_Conference_Invite *tox_events_get_conference_invite(const Tox_Events *events, uint32_t index)
{
uint32_t conference_invite_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (conference_invite_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_INVITE) {
const Tox_Event_Conference_Invite *conference_invite = events->events[i].data.conference_invite;
if (conference_invite_index == index) {
return conference_invite;
}
++conference_invite_index;
}
}
return nullptr;
}
uint32_t tox_events_get_conference_invite_size(const Tox_Events *events)
{
uint32_t conference_invite_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_INVITE) {
++conference_invite_size;
}
}
return conference_invite_size;
}
bool tox_event_conference_invite_unpack(
Tox_Event_Conference_Invite **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/conference_message.c
View File

@ -83,13 +83,14 @@ static bool tox_event_conference_message_set_message(Tox_Event_Conference_Messag
conference_message->message_length = 0;
}
conference_message->message = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)malloc(message_length);
if (conference_message->message == nullptr) {
if (message_copy == nullptr) {
return false;
}
memcpy(conference_message->message, message, message_length);
memcpy(message_copy, message, message_length);
conference_message->message = message_copy;
conference_message->message_length = message_length;
return true;
}
@ -195,42 +196,6 @@ static Tox_Event_Conference_Message *tox_events_add_conference_message(Tox_Event
return conference_message;
}
const Tox_Event_Conference_Message *tox_events_get_conference_message(const Tox_Events *events, uint32_t index)
{
uint32_t conference_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (conference_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_MESSAGE) {
const Tox_Event_Conference_Message *conference_message = events->events[i].data.conference_message;
if (conference_message_index == index) {
return conference_message;
}
++conference_message_index;
}
}
return nullptr;
}
uint32_t tox_events_get_conference_message_size(const Tox_Events *events)
{
uint32_t conference_message_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_MESSAGE) {
++conference_message_size;
}
}
return conference_message_size;
}
bool tox_event_conference_message_unpack(
Tox_Event_Conference_Message **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/conference_peer_list_changed.c
View File

@ -118,42 +118,6 @@ static Tox_Event_Conference_Peer_List_Changed *tox_events_add_conference_peer_li
return conference_peer_list_changed;
}
const Tox_Event_Conference_Peer_List_Changed *tox_events_get_conference_peer_list_changed(const Tox_Events *events, uint32_t index)
{
uint32_t conference_peer_list_changed_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (conference_peer_list_changed_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED) {
const Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed = events->events[i].data.conference_peer_list_changed;
if (conference_peer_list_changed_index == index) {
return conference_peer_list_changed;
}
++conference_peer_list_changed_index;
}
}
return nullptr;
}
uint32_t tox_events_get_conference_peer_list_changed_size(const Tox_Events *events)
{
uint32_t conference_peer_list_changed_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED) {
++conference_peer_list_changed_size;
}
}
return conference_peer_list_changed_size;
}
bool tox_event_conference_peer_list_changed_unpack(
Tox_Event_Conference_Peer_List_Changed **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/conference_peer_name.c
View File

@ -68,13 +68,14 @@ static bool tox_event_conference_peer_name_set_name(Tox_Event_Conference_Peer_Na
conference_peer_name->name_length = 0;
}
conference_peer_name->name = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)malloc(name_length);
if (conference_peer_name->name == nullptr) {
if (name_copy == nullptr) {
return false;
}
memcpy(conference_peer_name->name, name, name_length);
memcpy(name_copy, name, name_length);
conference_peer_name->name = name_copy;
conference_peer_name->name_length = name_length;
return true;
}
@ -178,42 +179,6 @@ static Tox_Event_Conference_Peer_Name *tox_events_add_conference_peer_name(Tox_E
return conference_peer_name;
}
const Tox_Event_Conference_Peer_Name *tox_events_get_conference_peer_name(const Tox_Events *events, uint32_t index)
{
uint32_t conference_peer_name_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (conference_peer_name_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_NAME) {
const Tox_Event_Conference_Peer_Name *conference_peer_name = events->events[i].data.conference_peer_name;
if (conference_peer_name_index == index) {
return conference_peer_name;
}
++conference_peer_name_index;
}
}
return nullptr;
}
uint32_t tox_events_get_conference_peer_name_size(const Tox_Events *events)
{
uint32_t conference_peer_name_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_NAME) {
++conference_peer_name_size;
}
}
return conference_peer_name_size;
}
bool tox_event_conference_peer_name_unpack(
Tox_Event_Conference_Peer_Name **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/conference_title.c
View File

@ -68,13 +68,14 @@ static bool tox_event_conference_title_set_title(Tox_Event_Conference_Title *con
conference_title->title_length = 0;
}
conference_title->title = (uint8_t *)malloc(title_length);
uint8_t *title_copy = (uint8_t *)malloc(title_length);
if (conference_title->title == nullptr) {
if (title_copy == nullptr) {
return false;
}
memcpy(conference_title->title, title, title_length);
memcpy(title_copy, title, title_length);
conference_title->title = title_copy;
conference_title->title_length = title_length;
return true;
}
@ -178,42 +179,6 @@ static Tox_Event_Conference_Title *tox_events_add_conference_title(Tox_Events *e
return conference_title;
}
const Tox_Event_Conference_Title *tox_events_get_conference_title(const Tox_Events *events, uint32_t index)
{
uint32_t conference_title_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (conference_title_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_TITLE) {
const Tox_Event_Conference_Title *conference_title = events->events[i].data.conference_title;
if (conference_title_index == index) {
return conference_title;
}
++conference_title_index;
}
}
return nullptr;
}
uint32_t tox_events_get_conference_title_size(const Tox_Events *events)
{
uint32_t conference_title_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_TITLE) {
++conference_title_size;
}
}
return conference_title_size;
}
bool tox_event_conference_title_unpack(
Tox_Event_Conference_Title **event, Bin_Unpack *bu, const Memory *mem)
{

17
toxcore/events/events_alloc.c
View File

@ -22,18 +22,21 @@ Tox_Events_State *tox_events_alloc(void *user_data)
return state;
}
state->events = (Tox_Events *)mem_alloc(state->mem, sizeof(Tox_Events));
Tox_Events *events = (Tox_Events *)mem_alloc(state->mem, sizeof(Tox_Events));
if (state->events == nullptr) {
if (events == nullptr) {
// It's still null => allocation failed.
state->events = nullptr;
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
} else {
*state->events = (Tox_Events) {
nullptr
};
state->events->mem = state->mem;
return state;
}
*events = (Tox_Events) {
nullptr
};
state->events = events;
state->events->mem = state->mem;
return state;
}

36
toxcore/events/file_chunk_request.c
View File

@ -171,42 +171,6 @@ static Tox_Event_File_Chunk_Request *tox_events_add_file_chunk_request(Tox_Event
return file_chunk_request;
}
const Tox_Event_File_Chunk_Request *tox_events_get_file_chunk_request(const Tox_Events *events, uint32_t index)
{
uint32_t file_chunk_request_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (file_chunk_request_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_CHUNK_REQUEST) {
const Tox_Event_File_Chunk_Request *file_chunk_request = events->events[i].data.file_chunk_request;
if (file_chunk_request_index == index) {
return file_chunk_request;
}
++file_chunk_request_index;
}
}
return nullptr;
}
uint32_t tox_events_get_file_chunk_request_size(const Tox_Events *events)
{
uint32_t file_chunk_request_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_CHUNK_REQUEST) {
++file_chunk_request_size;
}
}
return file_chunk_request_size;
}
bool tox_event_file_chunk_request_unpack(
Tox_Event_File_Chunk_Request **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/file_recv.c
View File

@ -96,13 +96,14 @@ static bool tox_event_file_recv_set_filename(Tox_Event_File_Recv *file_recv,
file_recv->filename_length = 0;
}
file_recv->filename = (uint8_t *)malloc(filename_length);
uint8_t *filename_copy = (uint8_t *)malloc(filename_length);
if (file_recv->filename == nullptr) {
if (filename_copy == nullptr) {
return false;
}
memcpy(file_recv->filename, filename, filename_length);
memcpy(filename_copy, filename, filename_length);
file_recv->filename = filename_copy;
file_recv->filename_length = filename_length;
return true;
}
@ -210,42 +211,6 @@ static Tox_Event_File_Recv *tox_events_add_file_recv(Tox_Events *events, const M
return file_recv;
}
const Tox_Event_File_Recv *tox_events_get_file_recv(const Tox_Events *events, uint32_t index)
{
uint32_t file_recv_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (file_recv_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_RECV) {
const Tox_Event_File_Recv *file_recv = events->events[i].data.file_recv;
if (file_recv_index == index) {
return file_recv;
}
++file_recv_index;
}
}
return nullptr;
}
uint32_t tox_events_get_file_recv_size(const Tox_Events *events)
{
uint32_t file_recv_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_RECV) {
++file_recv_size;
}
}
return file_recv_size;
}
bool tox_event_file_recv_unpack(
Tox_Event_File_Recv **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/file_recv_chunk.c
View File

@ -82,13 +82,14 @@ static bool tox_event_file_recv_chunk_set_data(Tox_Event_File_Recv_Chunk *file_r
file_recv_chunk->data_length = 0;
}
file_recv_chunk->data = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)malloc(data_length);
if (file_recv_chunk->data == nullptr) {
if (data_copy == nullptr) {
return false;
}
memcpy(file_recv_chunk->data, data, data_length);
memcpy(data_copy, data, data_length);
file_recv_chunk->data = data_copy;
file_recv_chunk->data_length = data_length;
return true;
}
@ -194,42 +195,6 @@ static Tox_Event_File_Recv_Chunk *tox_events_add_file_recv_chunk(Tox_Events *eve
return file_recv_chunk;
}
const Tox_Event_File_Recv_Chunk *tox_events_get_file_recv_chunk(const Tox_Events *events, uint32_t index)
{
uint32_t file_recv_chunk_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (file_recv_chunk_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_RECV_CHUNK) {
const Tox_Event_File_Recv_Chunk *file_recv_chunk = events->events[i].data.file_recv_chunk;
if (file_recv_chunk_index == index) {
return file_recv_chunk;
}
++file_recv_chunk_index;
}
}
return nullptr;
}
uint32_t tox_events_get_file_recv_chunk_size(const Tox_Events *events)
{
uint32_t file_recv_chunk_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_RECV_CHUNK) {
++file_recv_chunk_size;
}
}
return file_recv_chunk_size;
}
bool tox_event_file_recv_chunk_unpack(
Tox_Event_File_Recv_Chunk **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/file_recv_control.c
View File

@ -156,42 +156,6 @@ static Tox_Event_File_Recv_Control *tox_events_add_file_recv_control(Tox_Events
return file_recv_control;
}
const Tox_Event_File_Recv_Control *tox_events_get_file_recv_control(const Tox_Events *events, uint32_t index)
{
uint32_t file_recv_control_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (file_recv_control_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_RECV_CONTROL) {
const Tox_Event_File_Recv_Control *file_recv_control = events->events[i].data.file_recv_control;
if (file_recv_control_index == index) {
return file_recv_control;
}
++file_recv_control_index;
}
}
return nullptr;
}
uint32_t tox_events_get_file_recv_control_size(const Tox_Events *events)
{
uint32_t file_recv_control_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_RECV_CONTROL) {
++file_recv_control_size;
}
}
return file_recv_control_size;
}
bool tox_event_file_recv_control_unpack(
Tox_Event_File_Recv_Control **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/friend_connection_status.c
View File

@ -140,42 +140,6 @@ static Tox_Event_Friend_Connection_Status *tox_events_add_friend_connection_stat
return friend_connection_status;
}
const Tox_Event_Friend_Connection_Status *tox_events_get_friend_connection_status(const Tox_Events *events, uint32_t index)
{
uint32_t friend_connection_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_connection_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_CONNECTION_STATUS) {
const Tox_Event_Friend_Connection_Status *friend_connection_status = events->events[i].data.friend_connection_status;
if (friend_connection_status_index == index) {
return friend_connection_status;
}
++friend_connection_status_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_connection_status_size(const Tox_Events *events)
{
uint32_t friend_connection_status_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_CONNECTION_STATUS) {
++friend_connection_status_size;
}
}
return friend_connection_status_size;
}
bool tox_event_friend_connection_status_unpack(
Tox_Event_Friend_Connection_Status **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/friend_lossless_packet.c
View File

@ -54,13 +54,14 @@ static bool tox_event_friend_lossless_packet_set_data(Tox_Event_Friend_Lossless_
friend_lossless_packet->data_length = 0;
}
friend_lossless_packet->data = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)malloc(data_length);
if (friend_lossless_packet->data == nullptr) {
if (data_copy == nullptr) {
return false;
}
memcpy(friend_lossless_packet->data, data, data_length);
memcpy(data_copy, data, data_length);
friend_lossless_packet->data = data_copy;
friend_lossless_packet->data_length = data_length;
return true;
}
@ -162,42 +163,6 @@ static Tox_Event_Friend_Lossless_Packet *tox_events_add_friend_lossless_packet(T
return friend_lossless_packet;
}
const Tox_Event_Friend_Lossless_Packet *tox_events_get_friend_lossless_packet(const Tox_Events *events, uint32_t index)
{
uint32_t friend_lossless_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_lossless_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSLESS_PACKET) {
const Tox_Event_Friend_Lossless_Packet *friend_lossless_packet = events->events[i].data.friend_lossless_packet;
if (friend_lossless_packet_index == index) {
return friend_lossless_packet;
}
++friend_lossless_packet_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_lossless_packet_size(const Tox_Events *events)
{
uint32_t friend_lossless_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSLESS_PACKET) {
++friend_lossless_packet_size;
}
}
return friend_lossless_packet_size;
}
bool tox_event_friend_lossless_packet_unpack(
Tox_Event_Friend_Lossless_Packet **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/friend_lossy_packet.c
View File

@ -54,13 +54,14 @@ static bool tox_event_friend_lossy_packet_set_data(Tox_Event_Friend_Lossy_Packet
friend_lossy_packet->data_length = 0;
}
friend_lossy_packet->data = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)malloc(data_length);
if (friend_lossy_packet->data == nullptr) {
if (data_copy == nullptr) {
return false;
}
memcpy(friend_lossy_packet->data, data, data_length);
memcpy(data_copy, data, data_length);
friend_lossy_packet->data = data_copy;
friend_lossy_packet->data_length = data_length;
return true;
}
@ -162,42 +163,6 @@ static Tox_Event_Friend_Lossy_Packet *tox_events_add_friend_lossy_packet(Tox_Eve
return friend_lossy_packet;
}
const Tox_Event_Friend_Lossy_Packet *tox_events_get_friend_lossy_packet(const Tox_Events *events, uint32_t index)
{
uint32_t friend_lossy_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_lossy_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSY_PACKET) {
const Tox_Event_Friend_Lossy_Packet *friend_lossy_packet = events->events[i].data.friend_lossy_packet;
if (friend_lossy_packet_index == index) {
return friend_lossy_packet;
}
++friend_lossy_packet_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_lossy_packet_size(const Tox_Events *events)
{
uint32_t friend_lossy_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSY_PACKET) {
++friend_lossy_packet_size;
}
}
return friend_lossy_packet_size;
}
bool tox_event_friend_lossy_packet_unpack(
Tox_Event_Friend_Lossy_Packet **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/friend_message.c
View File

@ -69,13 +69,14 @@ static bool tox_event_friend_message_set_message(Tox_Event_Friend_Message *frien
friend_message->message_length = 0;
}
friend_message->message = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)malloc(message_length);
if (friend_message->message == nullptr) {
if (message_copy == nullptr) {
return false;
}
memcpy(friend_message->message, message, message_length);
memcpy(message_copy, message, message_length);
friend_message->message = message_copy;
friend_message->message_length = message_length;
return true;
}
@ -179,42 +180,6 @@ static Tox_Event_Friend_Message *tox_events_add_friend_message(Tox_Events *event
return friend_message;
}
const Tox_Event_Friend_Message *tox_events_get_friend_message(const Tox_Events *events, uint32_t index)
{
uint32_t friend_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_MESSAGE) {
const Tox_Event_Friend_Message *friend_message = events->events[i].data.friend_message;
if (friend_message_index == index) {
return friend_message;
}
++friend_message_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_message_size(const Tox_Events *events)
{
uint32_t friend_message_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_MESSAGE) {
++friend_message_size;
}
}
return friend_message_size;
}
bool tox_event_friend_message_unpack(
Tox_Event_Friend_Message **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/friend_name.c
View File

@ -54,13 +54,14 @@ static bool tox_event_friend_name_set_name(Tox_Event_Friend_Name *friend_name,
friend_name->name_length = 0;
}
friend_name->name = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)malloc(name_length);
if (friend_name->name == nullptr) {
if (name_copy == nullptr) {
return false;
}
memcpy(friend_name->name, name, name_length);
memcpy(name_copy, name, name_length);
friend_name->name = name_copy;
friend_name->name_length = name_length;
return true;
}
@ -162,42 +163,6 @@ static Tox_Event_Friend_Name *tox_events_add_friend_name(Tox_Events *events, con
return friend_name;
}
const Tox_Event_Friend_Name *tox_events_get_friend_name(const Tox_Events *events, uint32_t index)
{
uint32_t friend_name_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_name_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_NAME) {
const Tox_Event_Friend_Name *friend_name = events->events[i].data.friend_name;
if (friend_name_index == index) {
return friend_name;
}
++friend_name_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_name_size(const Tox_Events *events)
{
uint32_t friend_name_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_NAME) {
++friend_name_size;
}
}
return friend_name_size;
}
bool tox_event_friend_name_unpack(
Tox_Event_Friend_Name **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/friend_read_receipt.c
View File

@ -139,42 +139,6 @@ static Tox_Event_Friend_Read_Receipt *tox_events_add_friend_read_receipt(Tox_Eve
return friend_read_receipt;
}
const Tox_Event_Friend_Read_Receipt *tox_events_get_friend_read_receipt(const Tox_Events *events, uint32_t index)
{
uint32_t friend_read_receipt_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_read_receipt_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_READ_RECEIPT) {
const Tox_Event_Friend_Read_Receipt *friend_read_receipt = events->events[i].data.friend_read_receipt;
if (friend_read_receipt_index == index) {
return friend_read_receipt;
}
++friend_read_receipt_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_read_receipt_size(const Tox_Events *events)
{
uint32_t friend_read_receipt_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_READ_RECEIPT) {
++friend_read_receipt_size;
}
}
return friend_read_receipt_size;
}
bool tox_event_friend_read_receipt_unpack(
Tox_Event_Friend_Read_Receipt **event, Bin_Unpack *bu, const Memory *mem)
{

45
toxcore/events/friend_request.c
View File

@ -55,13 +55,14 @@ static bool tox_event_friend_request_set_message(Tox_Event_Friend_Request *frien
friend_request->message_length = 0;
}
friend_request->message = (uint8_t *)mem_balloc(mem, message_length * sizeof(uint8_t));
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (friend_request->message == nullptr) {
if (message_copy == nullptr) {
return false;
}
memcpy(friend_request->message, message, message_length * sizeof(uint8_t));
memcpy(message_copy, message, message_length);
friend_request->message = message_copy;
friend_request->message_length = message_length;
return true;
}
@ -157,44 +158,6 @@ static Tox_Event_Friend_Request *tox_events_add_friend_request(Tox_Events *event
return friend_request;
}
const Tox_Event_Friend_Request *tox_events_get_friend_request(
const Tox_Events *events, uint32_t index)
{
uint32_t friend_request_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_request_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_REQUEST) {
const Tox_Event_Friend_Request *friend_request = events->events[i].data.friend_request;
if (friend_request_index == index) {
return friend_request;
}
++friend_request_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_request_size(
const Tox_Events *events)
{
uint32_t friend_request_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_REQUEST) {
++friend_request_size;
}
}
return friend_request_size;
}
bool tox_event_friend_request_unpack(
Tox_Event_Friend_Request **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/friend_status.c
View File

@ -140,42 +140,6 @@ static Tox_Event_Friend_Status *tox_events_add_friend_status(Tox_Events *events,
return friend_status;
}
const Tox_Event_Friend_Status *tox_events_get_friend_status(const Tox_Events *events, uint32_t index)
{
uint32_t friend_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS) {
const Tox_Event_Friend_Status *friend_status = events->events[i].data.friend_status;
if (friend_status_index == index) {
return friend_status;
}
++friend_status_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_status_size(const Tox_Events *events)
{
uint32_t friend_status_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS) {
++friend_status_size;
}
}
return friend_status_size;
}
bool tox_event_friend_status_unpack(
Tox_Event_Friend_Status **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/friend_status_message.c
View File

@ -54,13 +54,14 @@ static bool tox_event_friend_status_message_set_message(Tox_Event_Friend_Status_
friend_status_message->message_length = 0;
}
friend_status_message->message = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)malloc(message_length);
if (friend_status_message->message == nullptr) {
if (message_copy == nullptr) {
return false;
}
memcpy(friend_status_message->message, message, message_length);
memcpy(message_copy, message, message_length);
friend_status_message->message = message_copy;
friend_status_message->message_length = message_length;
return true;
}
@ -162,42 +163,6 @@ static Tox_Event_Friend_Status_Message *tox_events_add_friend_status_message(Tox
return friend_status_message;
}
const Tox_Event_Friend_Status_Message *tox_events_get_friend_status_message(const Tox_Events *events, uint32_t index)
{
uint32_t friend_status_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_status_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS_MESSAGE) {
const Tox_Event_Friend_Status_Message *friend_status_message = events->events[i].data.friend_status_message;
if (friend_status_message_index == index) {
return friend_status_message;
}
++friend_status_message_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_status_message_size(const Tox_Events *events)
{
uint32_t friend_status_message_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS_MESSAGE) {
++friend_status_message_size;
}
}
return friend_status_message_size;
}
bool tox_event_friend_status_message_unpack(
Tox_Event_Friend_Status_Message **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/friend_typing.c
View File

@ -139,42 +139,6 @@ static Tox_Event_Friend_Typing *tox_events_add_friend_typing(Tox_Events *events,
return friend_typing;
}
const Tox_Event_Friend_Typing *tox_events_get_friend_typing(const Tox_Events *events, uint32_t index)
{
uint32_t friend_typing_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_typing_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_TYPING) {
const Tox_Event_Friend_Typing *friend_typing = events->events[i].data.friend_typing;
if (friend_typing_index == index) {
return friend_typing;
}
++friend_typing_index;
}
}
return nullptr;
}
uint32_t tox_events_get_friend_typing_size(const Tox_Events *events)
{
uint32_t friend_typing_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_TYPING) {
++friend_typing_size;
}
}
return friend_typing_size;
}
bool tox_event_friend_typing_unpack(
Tox_Event_Friend_Typing **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/group_custom_packet.c
View File

@ -68,13 +68,14 @@ static bool tox_event_group_custom_packet_set_data(Tox_Event_Group_Custom_Packet
group_custom_packet->data_length = 0;
}
group_custom_packet->data = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)malloc(data_length);
if (group_custom_packet->data == nullptr) {
if (data_copy == nullptr) {
return false;
}
memcpy(group_custom_packet->data, data, data_length);
memcpy(data_copy, data, data_length);
group_custom_packet->data = data_copy;
group_custom_packet->data_length = data_length;
return true;
}
@ -178,42 +179,6 @@ static Tox_Event_Group_Custom_Packet *tox_events_add_group_custom_packet(Tox_Eve
return group_custom_packet;
}
const Tox_Event_Group_Custom_Packet *tox_events_get_group_custom_packet(const Tox_Events *events, uint32_t index)
{
uint32_t group_custom_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_custom_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PACKET) {
const Tox_Event_Group_Custom_Packet *group_custom_packet = events->events[i].data.group_custom_packet;
if (group_custom_packet_index == index) {
return group_custom_packet;
}
++group_custom_packet_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_custom_packet_size(const Tox_Events *events)
{
uint32_t group_custom_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PACKET) {
++group_custom_packet_size;
}
}
return group_custom_packet_size;
}
bool tox_event_group_custom_packet_unpack(
Tox_Event_Group_Custom_Packet **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/group_custom_private_packet.c
View File

@ -68,13 +68,14 @@ static bool tox_event_group_custom_private_packet_set_data(Tox_Event_Group_Custo
group_custom_private_packet->data_length = 0;
}
group_custom_private_packet->data = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)malloc(data_length);
if (group_custom_private_packet->data == nullptr) {
if (data_copy == nullptr) {
return false;
}
memcpy(group_custom_private_packet->data, data, data_length);
memcpy(data_copy, data, data_length);
group_custom_private_packet->data = data_copy;
group_custom_private_packet->data_length = data_length;
return true;
}
@ -178,42 +179,6 @@ static Tox_Event_Group_Custom_Private_Packet *tox_events_add_group_custom_privat
return group_custom_private_packet;
}
const Tox_Event_Group_Custom_Private_Packet *tox_events_get_group_custom_private_packet(const Tox_Events *events, uint32_t index)
{
uint32_t group_custom_private_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_custom_private_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET) {
const Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet = events->events[i].data.group_custom_private_packet;
if (group_custom_private_packet_index == index) {
return group_custom_private_packet;
}
++group_custom_private_packet_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_custom_private_packet_size(const Tox_Events *events)
{
uint32_t group_custom_private_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET) {
++group_custom_private_packet_size;
}
}
return group_custom_private_packet_size;
}
bool tox_event_group_custom_private_packet_unpack(
Tox_Event_Group_Custom_Private_Packet **event, Bin_Unpack *bu, const Memory *mem)
{

50
toxcore/events/group_invite.c
View File

@ -56,13 +56,14 @@ static bool tox_event_group_invite_set_invite_data(Tox_Event_Group_Invite *group
group_invite->invite_data_length = 0;
}
group_invite->invite_data = (uint8_t *)malloc(invite_data_length);
uint8_t *invite_data_copy = (uint8_t *)malloc(invite_data_length);
if (group_invite->invite_data == nullptr) {
if (invite_data_copy == nullptr) {
return false;
}
memcpy(group_invite->invite_data, invite_data, invite_data_length);
memcpy(invite_data_copy, invite_data, invite_data_length);
group_invite->invite_data = invite_data_copy;
group_invite->invite_data_length = invite_data_length;
return true;
}
@ -89,13 +90,14 @@ static bool tox_event_group_invite_set_group_name(Tox_Event_Group_Invite *group_
group_invite->group_name_length = 0;
}
group_invite->group_name = (uint8_t *)malloc(group_name_length);
uint8_t *group_name_copy = (uint8_t *)malloc(group_name_length);
if (group_invite->group_name == nullptr) {
if (group_name_copy == nullptr) {
return false;
}
memcpy(group_invite->group_name, group_name, group_name_length);
memcpy(group_name_copy, group_name, group_name_length);
group_invite->group_name = group_name_copy;
group_invite->group_name_length = group_name_length;
return true;
}
@ -200,42 +202,6 @@ static Tox_Event_Group_Invite *tox_events_add_group_invite(Tox_Events *events, c
return group_invite;
}
const Tox_Event_Group_Invite *tox_events_get_group_invite(const Tox_Events *events, uint32_t index)
{
uint32_t group_invite_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_invite_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_INVITE) {
const Tox_Event_Group_Invite *group_invite = events->events[i].data.group_invite;
if (group_invite_index == index) {
return group_invite;
}
++group_invite_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_invite_size(const Tox_Events *events)
{
uint32_t group_invite_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_INVITE) {
++group_invite_size;
}
}
return group_invite_size;
}
bool tox_event_group_invite_unpack(
Tox_Event_Group_Invite **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_join_fail.c
View File

@ -140,42 +140,6 @@ static Tox_Event_Group_Join_Fail *tox_events_add_group_join_fail(Tox_Events *eve
return group_join_fail;
}
const Tox_Event_Group_Join_Fail *tox_events_get_group_join_fail(const Tox_Events *events, uint32_t index)
{
uint32_t group_join_fail_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_join_fail_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_JOIN_FAIL) {
const Tox_Event_Group_Join_Fail *group_join_fail = events->events[i].data.group_join_fail;
if (group_join_fail_index == index) {
return group_join_fail;
}
++group_join_fail_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_join_fail_size(const Tox_Events *events)
{
uint32_t group_join_fail_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_JOIN_FAIL) {
++group_join_fail_size;
}
}
return group_join_fail_size;
}
bool tox_event_group_join_fail_unpack(
Tox_Event_Group_Join_Fail **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/group_message.c
View File

@ -84,13 +84,14 @@ static bool tox_event_group_message_set_message(Tox_Event_Group_Message *group_m
group_message->message_length = 0;
}
group_message->message = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)malloc(message_length);
if (group_message->message == nullptr) {
if (message_copy == nullptr) {
return false;
}
memcpy(group_message->message, message, message_length);
memcpy(message_copy, message, message_length);
group_message->message = message_copy;
group_message->message_length = message_length;
return true;
}
@ -211,42 +212,6 @@ static Tox_Event_Group_Message *tox_events_add_group_message(Tox_Events *events,
return group_message;
}
const Tox_Event_Group_Message *tox_events_get_group_message(const Tox_Events *events, uint32_t index)
{
uint32_t group_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_MESSAGE) {
const Tox_Event_Group_Message *group_message = events->events[i].data.group_message;
if (group_message_index == index) {
return group_message;
}
++group_message_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_message_size(const Tox_Events *events)
{
uint32_t group_message_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_MESSAGE) {
++group_message_size;
}
}
return group_message_size;
}
bool tox_event_group_message_unpack(
Tox_Event_Group_Message **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_moderation.c
View File

@ -172,42 +172,6 @@ static Tox_Event_Group_Moderation *tox_events_add_group_moderation(Tox_Events *e
return group_moderation;
}
const Tox_Event_Group_Moderation *tox_events_get_group_moderation(const Tox_Events *events, uint32_t index)
{
uint32_t group_moderation_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_moderation_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_MODERATION) {
const Tox_Event_Group_Moderation *group_moderation = events->events[i].data.group_moderation;
if (group_moderation_index == index) {
return group_moderation;
}
++group_moderation_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_moderation_size(const Tox_Events *events)
{
uint32_t group_moderation_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_MODERATION) {
++group_moderation_size;
}
}
return group_moderation_size;
}
bool tox_event_group_moderation_unpack(
Tox_Event_Group_Moderation **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/group_password.c
View File

@ -54,13 +54,14 @@ static bool tox_event_group_password_set_password(Tox_Event_Group_Password *grou
group_password->password_length = 0;
}
group_password->password = (uint8_t *)malloc(password_length);
uint8_t *password_copy = (uint8_t *)malloc(password_length);
if (group_password->password == nullptr) {
if (password_copy == nullptr) {
return false;
}
memcpy(group_password->password, password, password_length);
memcpy(password_copy, password, password_length);
group_password->password = password_copy;
group_password->password_length = password_length;
return true;
}
@ -162,42 +163,6 @@ static Tox_Event_Group_Password *tox_events_add_group_password(Tox_Events *event
return group_password;
}
const Tox_Event_Group_Password *tox_events_get_group_password(const Tox_Events *events, uint32_t index)
{
uint32_t group_password_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_password_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PASSWORD) {
const Tox_Event_Group_Password *group_password = events->events[i].data.group_password;
if (group_password_index == index) {
return group_password;
}
++group_password_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_password_size(const Tox_Events *events)
{
uint32_t group_password_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PASSWORD) {
++group_password_size;
}
}
return group_password_size;
}
bool tox_event_group_password_unpack(
Tox_Event_Group_Password **event, Bin_Unpack *bu, const Memory *mem)
{

50
toxcore/events/group_peer_exit.c
View File

@ -85,13 +85,14 @@ static bool tox_event_group_peer_exit_set_name(Tox_Event_Group_Peer_Exit *group_
group_peer_exit->name_length = 0;
}
group_peer_exit->name = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)malloc(name_length);
if (group_peer_exit->name == nullptr) {
if (name_copy == nullptr) {
return false;
}
memcpy(group_peer_exit->name, name, name_length);
memcpy(name_copy, name, name_length);
group_peer_exit->name = name_copy;
group_peer_exit->name_length = name_length;
return true;
}
@ -118,13 +119,14 @@ static bool tox_event_group_peer_exit_set_part_message(Tox_Event_Group_Peer_Exit
group_peer_exit->part_message_length = 0;
}
group_peer_exit->part_message = (uint8_t *)malloc(part_message_length);
uint8_t *part_message_copy = (uint8_t *)malloc(part_message_length);
if (group_peer_exit->part_message == nullptr) {
if (part_message_copy == nullptr) {
return false;
}
memcpy(group_peer_exit->part_message, part_message, part_message_length);
memcpy(part_message_copy, part_message, part_message_length);
group_peer_exit->part_message = part_message_copy;
group_peer_exit->part_message_length = part_message_length;
return true;
}
@ -233,42 +235,6 @@ static Tox_Event_Group_Peer_Exit *tox_events_add_group_peer_exit(Tox_Events *eve
return group_peer_exit;
}
const Tox_Event_Group_Peer_Exit *tox_events_get_group_peer_exit(const Tox_Events *events, uint32_t index)
{
uint32_t group_peer_exit_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_peer_exit_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_EXIT) {
const Tox_Event_Group_Peer_Exit *group_peer_exit = events->events[i].data.group_peer_exit;
if (group_peer_exit_index == index) {
return group_peer_exit;
}
++group_peer_exit_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_peer_exit_size(const Tox_Events *events)
{
uint32_t group_peer_exit_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_EXIT) {
++group_peer_exit_size;
}
}
return group_peer_exit_size;
}
bool tox_event_group_peer_exit_unpack(
Tox_Event_Group_Peer_Exit **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_peer_join.c
View File

@ -139,42 +139,6 @@ static Tox_Event_Group_Peer_Join *tox_events_add_group_peer_join(Tox_Events *eve
return group_peer_join;
}
const Tox_Event_Group_Peer_Join *tox_events_get_group_peer_join(const Tox_Events *events, uint32_t index)
{
uint32_t group_peer_join_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_peer_join_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_JOIN) {
const Tox_Event_Group_Peer_Join *group_peer_join = events->events[i].data.group_peer_join;
if (group_peer_join_index == index) {
return group_peer_join;
}
++group_peer_join_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_peer_join_size(const Tox_Events *events)
{
uint32_t group_peer_join_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_JOIN) {
++group_peer_join_size;
}
}
return group_peer_join_size;
}
bool tox_event_group_peer_join_unpack(
Tox_Event_Group_Peer_Join **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_peer_limit.c
View File

@ -139,42 +139,6 @@ static Tox_Event_Group_Peer_Limit *tox_events_add_group_peer_limit(Tox_Events *e
return group_peer_limit;
}
const Tox_Event_Group_Peer_Limit *tox_events_get_group_peer_limit(const Tox_Events *events, uint32_t index)
{
uint32_t group_peer_limit_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_peer_limit_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_LIMIT) {
const Tox_Event_Group_Peer_Limit *group_peer_limit = events->events[i].data.group_peer_limit;
if (group_peer_limit_index == index) {
return group_peer_limit;
}
++group_peer_limit_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_peer_limit_size(const Tox_Events *events)
{
uint32_t group_peer_limit_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_LIMIT) {
++group_peer_limit_size;
}
}
return group_peer_limit_size;
}
bool tox_event_group_peer_limit_unpack(
Tox_Event_Group_Peer_Limit **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/group_peer_name.c
View File

@ -68,13 +68,14 @@ static bool tox_event_group_peer_name_set_name(Tox_Event_Group_Peer_Name *group_
group_peer_name->name_length = 0;
}
group_peer_name->name = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)malloc(name_length);
if (group_peer_name->name == nullptr) {
if (name_copy == nullptr) {
return false;
}
memcpy(group_peer_name->name, name, name_length);
memcpy(name_copy, name, name_length);
group_peer_name->name = name_copy;
group_peer_name->name_length = name_length;
return true;
}
@ -178,42 +179,6 @@ static Tox_Event_Group_Peer_Name *tox_events_add_group_peer_name(Tox_Events *eve
return group_peer_name;
}
const Tox_Event_Group_Peer_Name *tox_events_get_group_peer_name(const Tox_Events *events, uint32_t index)
{
uint32_t group_peer_name_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_peer_name_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_NAME) {
const Tox_Event_Group_Peer_Name *group_peer_name = events->events[i].data.group_peer_name;
if (group_peer_name_index == index) {
return group_peer_name;
}
++group_peer_name_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_peer_name_size(const Tox_Events *events)
{
uint32_t group_peer_name_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_NAME) {
++group_peer_name_size;
}
}
return group_peer_name_size;
}
bool tox_event_group_peer_name_unpack(
Tox_Event_Group_Peer_Name **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_peer_status.c
View File

@ -156,42 +156,6 @@ static Tox_Event_Group_Peer_Status *tox_events_add_group_peer_status(Tox_Events
return group_peer_status;
}
const Tox_Event_Group_Peer_Status *tox_events_get_group_peer_status(const Tox_Events *events, uint32_t index)
{
uint32_t group_peer_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_peer_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_STATUS) {
const Tox_Event_Group_Peer_Status *group_peer_status = events->events[i].data.group_peer_status;
if (group_peer_status_index == index) {
return group_peer_status;
}
++group_peer_status_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_peer_status_size(const Tox_Events *events)
{
uint32_t group_peer_status_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_STATUS) {
++group_peer_status_size;
}
}
return group_peer_status_size;
}
bool tox_event_group_peer_status_unpack(
Tox_Event_Group_Peer_Status **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_privacy_state.c
View File

@ -140,42 +140,6 @@ static Tox_Event_Group_Privacy_State *tox_events_add_group_privacy_state(Tox_Eve
return group_privacy_state;
}
const Tox_Event_Group_Privacy_State *tox_events_get_group_privacy_state(const Tox_Events *events, uint32_t index)
{
uint32_t group_privacy_state_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_privacy_state_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PRIVACY_STATE) {
const Tox_Event_Group_Privacy_State *group_privacy_state = events->events[i].data.group_privacy_state;
if (group_privacy_state_index == index) {
return group_privacy_state;
}
++group_privacy_state_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_privacy_state_size(const Tox_Events *events)
{
uint32_t group_privacy_state_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PRIVACY_STATE) {
++group_privacy_state_size;
}
}
return group_privacy_state_size;
}
bool tox_event_group_privacy_state_unpack(
Tox_Event_Group_Privacy_State **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/group_private_message.c
View File

@ -83,13 +83,14 @@ static bool tox_event_group_private_message_set_message(Tox_Event_Group_Private_
group_private_message->message_length = 0;
}
group_private_message->message = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)malloc(message_length);
if (group_private_message->message == nullptr) {
if (message_copy == nullptr) {
return false;
}
memcpy(group_private_message->message, message, message_length);
memcpy(message_copy, message, message_length);
group_private_message->message = message_copy;
group_private_message->message_length = message_length;
return true;
}
@ -195,42 +196,6 @@ static Tox_Event_Group_Private_Message *tox_events_add_group_private_message(Tox
return group_private_message;
}
const Tox_Event_Group_Private_Message *tox_events_get_group_private_message(const Tox_Events *events, uint32_t index)
{
uint32_t group_private_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_private_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PRIVATE_MESSAGE) {
const Tox_Event_Group_Private_Message *group_private_message = events->events[i].data.group_private_message;
if (group_private_message_index == index) {
return group_private_message;
}
++group_private_message_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_private_message_size(const Tox_Events *events)
{
uint32_t group_private_message_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PRIVATE_MESSAGE) {
++group_private_message_size;
}
}
return group_private_message_size;
}
bool tox_event_group_private_message_unpack(
Tox_Event_Group_Private_Message **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_self_join.c
View File

@ -118,42 +118,6 @@ static Tox_Event_Group_Self_Join *tox_events_add_group_self_join(Tox_Events *eve
return group_self_join;
}
const Tox_Event_Group_Self_Join *tox_events_get_group_self_join(const Tox_Events *events, uint32_t index)
{
uint32_t group_self_join_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_self_join_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_SELF_JOIN) {
const Tox_Event_Group_Self_Join *group_self_join = events->events[i].data.group_self_join;
if (group_self_join_index == index) {
return group_self_join;
}
++group_self_join_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_self_join_size(const Tox_Events *events)
{
uint32_t group_self_join_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_SELF_JOIN) {
++group_self_join_size;
}
}
return group_self_join_size;
}
bool tox_event_group_self_join_unpack(
Tox_Event_Group_Self_Join **event, Bin_Unpack *bu, const Memory *mem)
{

43
toxcore/events/group_topic.c
View File

@ -68,13 +68,14 @@ static bool tox_event_group_topic_set_topic(Tox_Event_Group_Topic *group_topic,
group_topic->topic_length = 0;
}
group_topic->topic = (uint8_t *)malloc(topic_length);
uint8_t *topic_copy = (uint8_t *)malloc(topic_length);
if (group_topic->topic == nullptr) {
if (topic_copy == nullptr) {
return false;
}
memcpy(group_topic->topic, topic, topic_length);
memcpy(topic_copy, topic, topic_length);
group_topic->topic = topic_copy;
group_topic->topic_length = topic_length;
return true;
}
@ -178,42 +179,6 @@ static Tox_Event_Group_Topic *tox_events_add_group_topic(Tox_Events *events, con
return group_topic;
}
const Tox_Event_Group_Topic *tox_events_get_group_topic(const Tox_Events *events, uint32_t index)
{
uint32_t group_topic_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_topic_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC) {
const Tox_Event_Group_Topic *group_topic = events->events[i].data.group_topic;
if (group_topic_index == index) {
return group_topic;
}
++group_topic_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_topic_size(const Tox_Events *events)
{
uint32_t group_topic_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC) {
++group_topic_size;
}
}
return group_topic_size;
}
bool tox_event_group_topic_unpack(
Tox_Event_Group_Topic **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_topic_lock.c
View File

@ -140,42 +140,6 @@ static Tox_Event_Group_Topic_Lock *tox_events_add_group_topic_lock(Tox_Events *e
return group_topic_lock;
}
const Tox_Event_Group_Topic_Lock *tox_events_get_group_topic_lock(const Tox_Events *events, uint32_t index)
{
uint32_t group_topic_lock_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_topic_lock_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC_LOCK) {
const Tox_Event_Group_Topic_Lock *group_topic_lock = events->events[i].data.group_topic_lock;
if (group_topic_lock_index == index) {
return group_topic_lock;
}
++group_topic_lock_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_topic_lock_size(const Tox_Events *events)
{
uint32_t group_topic_lock_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC_LOCK) {
++group_topic_lock_size;
}
}
return group_topic_lock_size;
}
bool tox_event_group_topic_lock_unpack(
Tox_Event_Group_Topic_Lock **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/group_voice_state.c
View File

@ -140,42 +140,6 @@ static Tox_Event_Group_Voice_State *tox_events_add_group_voice_state(Tox_Events
return group_voice_state;
}
const Tox_Event_Group_Voice_State *tox_events_get_group_voice_state(const Tox_Events *events, uint32_t index)
{
uint32_t group_voice_state_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (group_voice_state_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_VOICE_STATE) {
const Tox_Event_Group_Voice_State *group_voice_state = events->events[i].data.group_voice_state;
if (group_voice_state_index == index) {
return group_voice_state;
}
++group_voice_state_index;
}
}
return nullptr;
}
uint32_t tox_events_get_group_voice_state_size(const Tox_Events *events)
{
uint32_t group_voice_state_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_VOICE_STATE) {
++group_voice_state_size;
}
}
return group_voice_state_size;
}
bool tox_event_group_voice_state_unpack(
Tox_Event_Group_Voice_State **event, Bin_Unpack *bu, const Memory *mem)
{

36
toxcore/events/self_connection_status.c
View File

@ -119,42 +119,6 @@ static Tox_Event_Self_Connection_Status *tox_events_add_self_connection_status(T
return self_connection_status;
}
const Tox_Event_Self_Connection_Status *tox_events_get_self_connection_status(const Tox_Events *events, uint32_t index)
{
uint32_t self_connection_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (self_connection_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_SELF_CONNECTION_STATUS) {
const Tox_Event_Self_Connection_Status *self_connection_status = events->events[i].data.self_connection_status;
if (self_connection_status_index == index) {
return self_connection_status;
}
++self_connection_status_index;
}
}
return nullptr;
}
uint32_t tox_events_get_self_connection_status_size(const Tox_Events *events)
{
uint32_t self_connection_status_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_SELF_CONNECTION_STATUS) {
++self_connection_status_size;
}
}
return self_connection_status_size;
}
bool tox_event_self_connection_status_unpack(
Tox_Event_Self_Connection_Status **event, Bin_Unpack *bu, const Memory *mem)
{