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 1828c5356..c9cdae001

Browse Source 
c9cdae001 fix(toxav): remove extra copy of video frame on encode
4f6d4546b test: Improve the fake network library.
a2581e700 refactor(toxcore): generate `Friend_Request` and `Dht_Nodes_Response`
2aaa11770 refactor(toxcore): use Tox_Memory in generated events
5c367452b test(toxcore): fix incorrect mutex in tox_scenario_get_time
8f92e710f perf: Add a timed limit of number of cookie requests.
695b6417a test: Add some more simulated network support.
815ae9ce9 test(toxcore): fix thread-safety in scenario framework
6d85c754e test(toxcore): add unit tests for net_crypto
9c22e79cc test(support): add SimulatedEnvironment for deterministic testing
f34fcb195 chore: Update windows Dockerfile to debian stable (trixie).
ece0e8980 fix(group_moderation): allow validating unsorted sanction list signatures
a4fa754d7 refactor: rename struct Packet to struct Net_Packet
d6f330f85 cleanup: Fix some warnings from coverity.
e206bffa2 fix(group_chats): fix sync packets reverting topics
0e4715598 test: Add new scenario testing framework.
668291f44 refactor(toxcore): decouple Network_Funcs from sockaddr via IP_Port
fc4396cef fix: potential division by zero in toxav and unsafe hex parsing
8e8b352ab refactor: Add nullable annotations to struct members.
7740bb421 refactor: decouple net_crypto from DHT
1936d4296 test: add benchmark for toxav audio and video
46bfdc2df fix: correct printf format specifiers for unsigned integers
REVERT: 1828c5356 fix(toxav): remove extra copy of video frame on encode

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: c9cdae001341e701fca980c9bb9febfeb95d2902
This commit is contained in:
Green Sky
2026-01-11 14:42:31 +01:00
parent e95f2cbb1c
commit 565efa4f39
328 changed files with 19057 additions and 13982 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
toxcore/events/conference_connected.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -86,7 +86,7 @@ Tox_Event_Conference_Connected *tox_event_conference_connected_new(const Memory
void tox_event_conference_connected_free(Tox_Event_Conference_Connected *conference_connected, const Memory *mem)
{
if (conference_connected != nullptr) {
tox_event_conference_connected_destruct(conference_connected, mem);
tox_event_conference_connected_destruct((Tox_Event_Conference_Connected * _Nonnull)conference_connected, mem);
}
mem_delete(mem, conference_connected);
}
@@ -124,11 +124,8 @@ bool tox_event_conference_connected_unpack(
return tox_event_conference_connected_unpack_into(*event, bu);
}
static Tox_Event_Conference_Connected *tox_event_conference_connected_alloc(void *_Nonnull user_data)
static Tox_Event_Conference_Connected *tox_event_conference_connected_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -153,7 +150,8 @@ void tox_events_handle_conference_connected(
Tox *tox, uint32_t conference_number,
void *user_data)
{
Tox_Event_Conference_Connected *conference_connected = tox_event_conference_connected_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Conference_Connected *conference_connected = tox_event_conference_connected_alloc(state);
if (conference_connected == nullptr) {
return;

23
toxcore/events/conference_invite.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -55,11 +54,11 @@ Tox_Conference_Type tox_event_conference_invite_get_type(const Tox_Event_Confere
}
static bool tox_event_conference_invite_set_cookie(Tox_Event_Conference_Invite *_Nonnull conference_invite,
const uint8_t *_Nullable cookie, uint32_t cookie_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable cookie, uint32_t cookie_length)
{
assert(conference_invite != nullptr);
if (conference_invite->cookie != nullptr) {
free(conference_invite->cookie);
mem_delete(mem, conference_invite->cookie);
conference_invite->cookie = nullptr;
conference_invite->cookie_length = 0;
}
@@ -69,7 +68,7 @@ static bool tox_event_conference_invite_set_cookie(Tox_Event_Conference_Invite *
return true;
}
uint8_t *cookie_copy = (uint8_t *)malloc(cookie_length);
uint8_t *cookie_copy = (uint8_t *)mem_balloc(mem, cookie_length);
if (cookie_copy == nullptr) {
return false;
@@ -99,7 +98,7 @@ static void tox_event_conference_invite_construct(Tox_Event_Conference_Invite *_
}
static void tox_event_conference_invite_destruct(Tox_Event_Conference_Invite *_Nonnull conference_invite, const Memory *_Nonnull mem)
{
free(conference_invite->cookie);
mem_delete(mem, conference_invite->cookie);
}
bool tox_event_conference_invite_pack(
@@ -150,7 +149,7 @@ Tox_Event_Conference_Invite *tox_event_conference_invite_new(const Memory *mem)
void tox_event_conference_invite_free(Tox_Event_Conference_Invite *conference_invite, const Memory *mem)
{
if (conference_invite != nullptr) {
tox_event_conference_invite_destruct(conference_invite, mem);
tox_event_conference_invite_destruct((Tox_Event_Conference_Invite * _Nonnull)conference_invite, mem);
}
mem_delete(mem, conference_invite);
}
@@ -188,11 +187,8 @@ bool tox_event_conference_invite_unpack(
return tox_event_conference_invite_unpack_into(*event, bu);
}
static Tox_Event_Conference_Invite *tox_event_conference_invite_alloc(void *_Nonnull user_data)
static Tox_Event_Conference_Invite *tox_event_conference_invite_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -217,7 +213,8 @@ void tox_events_handle_conference_invite(
Tox *tox, uint32_t friend_number, Tox_Conference_Type type, const uint8_t *cookie, size_t length,
void *user_data)
{
Tox_Event_Conference_Invite *conference_invite = tox_event_conference_invite_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Conference_Invite *conference_invite = tox_event_conference_invite_alloc(state);
if (conference_invite == nullptr) {
return;
@@ -225,5 +222,5 @@ void tox_events_handle_conference_invite(
tox_event_conference_invite_set_friend_number(conference_invite, friend_number);
tox_event_conference_invite_set_type(conference_invite, type);
tox_event_conference_invite_set_cookie(conference_invite, cookie, length);
tox_event_conference_invite_set_cookie(conference_invite, state->mem, cookie, length);
}

23
toxcore/events/conference_message.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -67,11 +66,11 @@ Tox_Message_Type tox_event_conference_message_get_type(const Tox_Event_Conferenc
}
static bool tox_event_conference_message_set_message(Tox_Event_Conference_Message *_Nonnull conference_message,
const uint8_t *_Nullable message, uint32_t message_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable message, uint32_t message_length)
{
assert(conference_message != nullptr);
if (conference_message->message != nullptr) {
free(conference_message->message);
mem_delete(mem, conference_message->message);
conference_message->message = nullptr;
conference_message->message_length = 0;
}
@@ -81,7 +80,7 @@ static bool tox_event_conference_message_set_message(Tox_Event_Conference_Messag
return true;
}
uint8_t *message_copy = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
return false;
@@ -111,7 +110,7 @@ static void tox_event_conference_message_construct(Tox_Event_Conference_Message
}
static void tox_event_conference_message_destruct(Tox_Event_Conference_Message *_Nonnull conference_message, const Memory *_Nonnull mem)
{
free(conference_message->message);
mem_delete(mem, conference_message->message);
}
bool tox_event_conference_message_pack(
@@ -164,7 +163,7 @@ Tox_Event_Conference_Message *tox_event_conference_message_new(const Memory *mem
void tox_event_conference_message_free(Tox_Event_Conference_Message *conference_message, const Memory *mem)
{
if (conference_message != nullptr) {
tox_event_conference_message_destruct(conference_message, mem);
tox_event_conference_message_destruct((Tox_Event_Conference_Message * _Nonnull)conference_message, mem);
}
mem_delete(mem, conference_message);
}
@@ -202,11 +201,8 @@ bool tox_event_conference_message_unpack(
return tox_event_conference_message_unpack_into(*event, bu);
}
static Tox_Event_Conference_Message *tox_event_conference_message_alloc(void *_Nonnull user_data)
static Tox_Event_Conference_Message *tox_event_conference_message_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -231,7 +227,8 @@ void tox_events_handle_conference_message(
Tox *tox, uint32_t conference_number, uint32_t peer_number, Tox_Message_Type type, const uint8_t *message, size_t length,
void *user_data)
{
Tox_Event_Conference_Message *conference_message = tox_event_conference_message_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Conference_Message *conference_message = tox_event_conference_message_alloc(state);
if (conference_message == nullptr) {
return;
@@ -240,5 +237,5 @@ void tox_events_handle_conference_message(
tox_event_conference_message_set_conference_number(conference_message, conference_number);
tox_event_conference_message_set_peer_number(conference_message, peer_number);
tox_event_conference_message_set_type(conference_message, type);
tox_event_conference_message_set_message(conference_message, message, length);
tox_event_conference_message_set_message(conference_message, state->mem, message, length);
}

12
toxcore/events/conference_peer_list_changed.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -86,7 +86,7 @@ Tox_Event_Conference_Peer_List_Changed *tox_event_conference_peer_list_changed_n
void tox_event_conference_peer_list_changed_free(Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed, const Memory *mem)
{
if (conference_peer_list_changed != nullptr) {
tox_event_conference_peer_list_changed_destruct(conference_peer_list_changed, mem);
tox_event_conference_peer_list_changed_destruct((Tox_Event_Conference_Peer_List_Changed * _Nonnull)conference_peer_list_changed, mem);
}
mem_delete(mem, conference_peer_list_changed);
}
@@ -124,11 +124,8 @@ bool tox_event_conference_peer_list_changed_unpack(
return tox_event_conference_peer_list_changed_unpack_into(*event, bu);
}
static Tox_Event_Conference_Peer_List_Changed *tox_event_conference_peer_list_changed_alloc(void *_Nonnull user_data)
static Tox_Event_Conference_Peer_List_Changed *tox_event_conference_peer_list_changed_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -153,7 +150,8 @@ void tox_events_handle_conference_peer_list_changed(
Tox *tox, uint32_t conference_number,
void *user_data)
{
Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed = tox_event_conference_peer_list_changed_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed = tox_event_conference_peer_list_changed_alloc(state);
if (conference_peer_list_changed == nullptr) {
return;

23
toxcore/events/conference_peer_name.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -53,11 +52,11 @@ uint32_t tox_event_conference_peer_name_get_peer_number(const Tox_Event_Conferen
}
static bool tox_event_conference_peer_name_set_name(Tox_Event_Conference_Peer_Name *_Nonnull conference_peer_name,
const uint8_t *_Nullable name, uint32_t name_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable name, uint32_t name_length)
{
assert(conference_peer_name != nullptr);
if (conference_peer_name->name != nullptr) {
free(conference_peer_name->name);
mem_delete(mem, conference_peer_name->name);
conference_peer_name->name = nullptr;
conference_peer_name->name_length = 0;
}
@@ -67,7 +66,7 @@ static bool tox_event_conference_peer_name_set_name(Tox_Event_Conference_Peer_Na
return true;
}
uint8_t *name_copy = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
return false;
@@ -97,7 +96,7 @@ static void tox_event_conference_peer_name_construct(Tox_Event_Conference_Peer_N
}
static void tox_event_conference_peer_name_destruct(Tox_Event_Conference_Peer_Name *_Nonnull conference_peer_name, const Memory *_Nonnull mem)
{
free(conference_peer_name->name);
mem_delete(mem, conference_peer_name->name);
}
bool tox_event_conference_peer_name_pack(
@@ -148,7 +147,7 @@ Tox_Event_Conference_Peer_Name *tox_event_conference_peer_name_new(const Memory
void tox_event_conference_peer_name_free(Tox_Event_Conference_Peer_Name *conference_peer_name, const Memory *mem)
{
if (conference_peer_name != nullptr) {
tox_event_conference_peer_name_destruct(conference_peer_name, mem);
tox_event_conference_peer_name_destruct((Tox_Event_Conference_Peer_Name * _Nonnull)conference_peer_name, mem);
}
mem_delete(mem, conference_peer_name);
}
@@ -186,11 +185,8 @@ bool tox_event_conference_peer_name_unpack(
return tox_event_conference_peer_name_unpack_into(*event, bu);
}
static Tox_Event_Conference_Peer_Name *tox_event_conference_peer_name_alloc(void *_Nonnull user_data)
static Tox_Event_Conference_Peer_Name *tox_event_conference_peer_name_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -215,7 +211,8 @@ void tox_events_handle_conference_peer_name(
Tox *tox, uint32_t conference_number, uint32_t peer_number, const uint8_t *name, size_t length,
void *user_data)
{
Tox_Event_Conference_Peer_Name *conference_peer_name = tox_event_conference_peer_name_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Conference_Peer_Name *conference_peer_name = tox_event_conference_peer_name_alloc(state);
if (conference_peer_name == nullptr) {
return;
@@ -223,5 +220,5 @@ void tox_events_handle_conference_peer_name(
tox_event_conference_peer_name_set_conference_number(conference_peer_name, conference_number);
tox_event_conference_peer_name_set_peer_number(conference_peer_name, peer_number);
tox_event_conference_peer_name_set_name(conference_peer_name, name, length);
tox_event_conference_peer_name_set_name(conference_peer_name, state->mem, name, length);
}

23
toxcore/events/conference_title.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -53,11 +52,11 @@ uint32_t tox_event_conference_title_get_peer_number(const Tox_Event_Conference_T
}
static bool tox_event_conference_title_set_title(Tox_Event_Conference_Title *_Nonnull conference_title,
const uint8_t *_Nullable title, uint32_t title_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable title, uint32_t title_length)
{
assert(conference_title != nullptr);
if (conference_title->title != nullptr) {
free(conference_title->title);
mem_delete(mem, conference_title->title);
conference_title->title = nullptr;
conference_title->title_length = 0;
}
@@ -67,7 +66,7 @@ static bool tox_event_conference_title_set_title(Tox_Event_Conference_Title *_No
return true;
}
uint8_t *title_copy = (uint8_t *)malloc(title_length);
uint8_t *title_copy = (uint8_t *)mem_balloc(mem, title_length);
if (title_copy == nullptr) {
return false;
@@ -97,7 +96,7 @@ static void tox_event_conference_title_construct(Tox_Event_Conference_Title *_No
}
static void tox_event_conference_title_destruct(Tox_Event_Conference_Title *_Nonnull conference_title, const Memory *_Nonnull mem)
{
free(conference_title->title);
mem_delete(mem, conference_title->title);
}
bool tox_event_conference_title_pack(
@@ -148,7 +147,7 @@ Tox_Event_Conference_Title *tox_event_conference_title_new(const Memory *mem)
void tox_event_conference_title_free(Tox_Event_Conference_Title *conference_title, const Memory *mem)
{
if (conference_title != nullptr) {
tox_event_conference_title_destruct(conference_title, mem);
tox_event_conference_title_destruct((Tox_Event_Conference_Title * _Nonnull)conference_title, mem);
}
mem_delete(mem, conference_title);
}
@@ -186,11 +185,8 @@ bool tox_event_conference_title_unpack(
return tox_event_conference_title_unpack_into(*event, bu);
}
static Tox_Event_Conference_Title *tox_event_conference_title_alloc(void *_Nonnull user_data)
static Tox_Event_Conference_Title *tox_event_conference_title_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -215,7 +211,8 @@ void tox_events_handle_conference_title(
Tox *tox, uint32_t conference_number, uint32_t peer_number, const uint8_t *title, size_t length,
void *user_data)
{
Tox_Event_Conference_Title *conference_title = tox_event_conference_title_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Conference_Title *conference_title = tox_event_conference_title_alloc(state);
if (conference_title == nullptr) {
return;
@@ -223,5 +220,5 @@ void tox_events_handle_conference_title(
tox_event_conference_title_set_conference_number(conference_title, conference_number);
tox_event_conference_title_set_peer_number(conference_title, peer_number);
tox_event_conference_title_set_title(conference_title, title, length);
tox_event_conference_title_set_title(conference_title, state->mem, title, length);
}

62
toxcore/events/dht_nodes_response.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -15,7 +15,6 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_private.h"
/*****************************************************
*
@@ -32,49 +31,62 @@ struct Tox_Event_Dht_Nodes_Response {
static bool tox_event_dht_nodes_response_set_public_key(Tox_Event_Dht_Nodes_Response *_Nonnull dht_nodes_response, const uint8_t public_key[TOX_PUBLIC_KEY_SIZE])
{
assert(dht_nodes_response != nullptr);
memcpy(dht_nodes_response->public_key, public_key, TOX_PUBLIC_KEY_SIZE);
return true;
}
const uint8_t *_Nonnull tox_event_dht_nodes_response_get_public_key(const Tox_Event_Dht_Nodes_Response *dht_nodes_response)
const uint8_t *tox_event_dht_nodes_response_get_public_key(const Tox_Event_Dht_Nodes_Response *dht_nodes_response)
{
assert(dht_nodes_response != nullptr);
return dht_nodes_response->public_key;
}
static bool tox_event_dht_nodes_response_set_ip(Tox_Event_Dht_Nodes_Response *_Nonnull dht_nodes_response, const char *_Nonnull ip, uint32_t ip_length, const Memory *_Nonnull mem)
static bool tox_event_dht_nodes_response_set_ip(Tox_Event_Dht_Nodes_Response *_Nonnull dht_nodes_response,
const Memory *_Nonnull mem, const uint8_t *_Nullable ip, uint32_t ip_length)
{
assert(dht_nodes_response != nullptr);
if (dht_nodes_response->ip != nullptr) {
mem_delete(mem, dht_nodes_response->ip);
dht_nodes_response->ip = nullptr;
dht_nodes_response->ip_length = 0;
}
uint8_t *ip_tmp = (uint8_t *)mem_balloc(mem, ip_length + 1);
if (ip == nullptr) {
assert(ip_length == 0);
return true;
}
if (ip_tmp == nullptr) {
uint8_t *ip_copy = (uint8_t *)mem_balloc(mem, ip_length + 1);
if (ip_copy == nullptr) {
return false;
}
memcpy(ip_tmp, ip, ip_length + 1);
dht_nodes_response->ip = ip_tmp;
memcpy(ip_copy, ip, ip_length);
ip_copy[ip_length] = 0;
dht_nodes_response->ip = ip_copy;
dht_nodes_response->ip_length = ip_length;
return true;
}
uint32_t tox_event_dht_nodes_response_get_ip_length(const Tox_Event_Dht_Nodes_Response *dht_nodes_response)
{
assert(dht_nodes_response != nullptr);
return dht_nodes_response->ip_length;
}
const uint8_t *tox_event_dht_nodes_response_get_ip(const Tox_Event_Dht_Nodes_Response *dht_nodes_response)
{
assert(dht_nodes_response != nullptr);
return dht_nodes_response->ip;
}
static bool tox_event_dht_nodes_response_set_port(Tox_Event_Dht_Nodes_Response *_Nonnull dht_nodes_response, uint16_t port)
static void tox_event_dht_nodes_response_set_port(Tox_Event_Dht_Nodes_Response *_Nonnull dht_nodes_response, uint16_t port)
{
assert(dht_nodes_response != nullptr);
dht_nodes_response->port = port;
return true;
}
uint16_t tox_event_dht_nodes_response_get_port(const Tox_Event_Dht_Nodes_Response *dht_nodes_response)
{
assert(dht_nodes_response != nullptr);
return dht_nodes_response->port;
}
@@ -102,6 +114,7 @@ bool tox_event_dht_nodes_response_pack(
static bool tox_event_dht_nodes_response_unpack_into(Tox_Event_Dht_Nodes_Response *_Nonnull event, Bin_Unpack *_Nonnull bu)
{
assert(event != nullptr);
if (!bin_unpack_array_fixed(bu, 3, nullptr)) {
return false;
}
@@ -111,8 +124,13 @@ static bool tox_event_dht_nodes_response_unpack_into(Tox_Event_Dht_Nodes_Respons
&& bin_unpack_u16(bu, &event->port);
}
const Tox_Event_Dht_Nodes_Response *tox_event_get_dht_nodes_response(
const Tox_Event *event)
/*****************************************************
*
* :: new/free/add/get/size/unpack
*
*****************************************************/
const Tox_Event_Dht_Nodes_Response *tox_event_get_dht_nodes_response(const Tox_Event *event)
{
return event->type == TOX_EVENT_DHT_NODES_RESPONSE ? event->data.dht_nodes_response : nullptr;
}
@@ -133,7 +151,7 @@ Tox_Event_Dht_Nodes_Response *tox_event_dht_nodes_response_new(const Memory *mem
void tox_event_dht_nodes_response_free(Tox_Event_Dht_Nodes_Response *dht_nodes_response, const Memory *mem)
{
if (dht_nodes_response != nullptr) {
tox_event_dht_nodes_response_destruct(dht_nodes_response, mem);
tox_event_dht_nodes_response_destruct((Tox_Event_Dht_Nodes_Response * _Nonnull)dht_nodes_response, mem);
}
mem_delete(mem, dht_nodes_response);
}
@@ -160,6 +178,8 @@ static Tox_Event_Dht_Nodes_Response *tox_events_add_dht_nodes_response(Tox_Event
bool tox_event_dht_nodes_response_unpack(
Tox_Event_Dht_Nodes_Response **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
assert(*event == nullptr);
*event = tox_event_dht_nodes_response_new(mem);
if (*event == nullptr) {
@@ -169,11 +189,8 @@ bool tox_event_dht_nodes_response_unpack(
return tox_event_dht_nodes_response_unpack_into(*event, bu);
}
static Tox_Event_Dht_Nodes_Response *tox_event_dht_nodes_response_alloc(void *_Nonnull user_data)
static Tox_Event_Dht_Nodes_Response *tox_event_dht_nodes_response_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -195,18 +212,17 @@ static Tox_Event_Dht_Nodes_Response *tox_event_dht_nodes_response_alloc(void *_N
*****************************************************/
void tox_events_handle_dht_nodes_response(
Tox *tox, const uint8_t public_key[TOX_PUBLIC_KEY_SIZE],
const char *ip, uint32_t ip_length, uint16_t port, void *user_data)
Tox *tox, const uint8_t *public_key, const char *ip, uint32_t ip_length, uint16_t port,
void *user_data)
{
Tox_Event_Dht_Nodes_Response *dht_nodes_response = tox_event_dht_nodes_response_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Dht_Nodes_Response *dht_nodes_response = tox_event_dht_nodes_response_alloc(state);
if (dht_nodes_response == nullptr) {
return;
}
const Tox_System *sys = tox_get_system(tox);
tox_event_dht_nodes_response_set_public_key(dht_nodes_response, public_key);
tox_event_dht_nodes_response_set_ip(dht_nodes_response, ip, ip_length, sys->mem);
tox_event_dht_nodes_response_set_ip(dht_nodes_response, state->mem, (const uint8_t *)ip, ip_length);
tox_event_dht_nodes_response_set_port(dht_nodes_response, port);
}

12
toxcore/events/file_chunk_request.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -133,7 +133,7 @@ Tox_Event_File_Chunk_Request *tox_event_file_chunk_request_new(const Memory *mem
void tox_event_file_chunk_request_free(Tox_Event_File_Chunk_Request *file_chunk_request, const Memory *mem)
{
if (file_chunk_request != nullptr) {
tox_event_file_chunk_request_destruct(file_chunk_request, mem);
tox_event_file_chunk_request_destruct((Tox_Event_File_Chunk_Request * _Nonnull)file_chunk_request, mem);
}
mem_delete(mem, file_chunk_request);
}
@@ -171,11 +171,8 @@ bool tox_event_file_chunk_request_unpack(
return tox_event_file_chunk_request_unpack_into(*event, bu);
}
static Tox_Event_File_Chunk_Request *tox_event_file_chunk_request_alloc(void *_Nonnull user_data)
static Tox_Event_File_Chunk_Request *tox_event_file_chunk_request_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -200,7 +197,8 @@ void tox_events_handle_file_chunk_request(
Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position, size_t length,
void *user_data)
{
Tox_Event_File_Chunk_Request *file_chunk_request = tox_event_file_chunk_request_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_File_Chunk_Request *file_chunk_request = tox_event_file_chunk_request_alloc(state);
if (file_chunk_request == nullptr) {
return;

23
toxcore/events/file_recv.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -77,11 +76,11 @@ uint64_t tox_event_file_recv_get_file_size(const Tox_Event_File_Recv *file_recv)
}
static bool tox_event_file_recv_set_filename(Tox_Event_File_Recv *_Nonnull file_recv,
const uint8_t *_Nullable filename, uint32_t filename_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable filename, uint32_t filename_length)
{
assert(file_recv != nullptr);
if (file_recv->filename != nullptr) {
free(file_recv->filename);
mem_delete(mem, file_recv->filename);
file_recv->filename = nullptr;
file_recv->filename_length = 0;
}
@@ -91,7 +90,7 @@ static bool tox_event_file_recv_set_filename(Tox_Event_File_Recv *_Nonnull file_
return true;
}
uint8_t *filename_copy = (uint8_t *)malloc(filename_length);
uint8_t *filename_copy = (uint8_t *)mem_balloc(mem, filename_length);
if (filename_copy == nullptr) {
return false;
@@ -121,7 +120,7 @@ static void tox_event_file_recv_construct(Tox_Event_File_Recv *_Nonnull file_rec
}
static void tox_event_file_recv_destruct(Tox_Event_File_Recv *_Nonnull file_recv, const Memory *_Nonnull mem)
{
free(file_recv->filename);
mem_delete(mem, file_recv->filename);
}
bool tox_event_file_recv_pack(
@@ -176,7 +175,7 @@ Tox_Event_File_Recv *tox_event_file_recv_new(const Memory *mem)
void tox_event_file_recv_free(Tox_Event_File_Recv *file_recv, const Memory *mem)
{
if (file_recv != nullptr) {
tox_event_file_recv_destruct(file_recv, mem);
tox_event_file_recv_destruct((Tox_Event_File_Recv * _Nonnull)file_recv, mem);
}
mem_delete(mem, file_recv);
}
@@ -214,11 +213,8 @@ bool tox_event_file_recv_unpack(
return tox_event_file_recv_unpack_into(*event, bu);
}
static Tox_Event_File_Recv *tox_event_file_recv_alloc(void *_Nonnull user_data)
static Tox_Event_File_Recv *tox_event_file_recv_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -243,7 +239,8 @@ void tox_events_handle_file_recv(
Tox *tox, uint32_t friend_number, uint32_t file_number, uint32_t kind, uint64_t file_size, const uint8_t *filename, size_t filename_length,
void *user_data)
{
Tox_Event_File_Recv *file_recv = tox_event_file_recv_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_File_Recv *file_recv = tox_event_file_recv_alloc(state);
if (file_recv == nullptr) {
return;
@@ -253,5 +250,5 @@ void tox_events_handle_file_recv(
tox_event_file_recv_set_file_number(file_recv, file_number);
tox_event_file_recv_set_kind(file_recv, kind);
tox_event_file_recv_set_file_size(file_recv, file_size);
tox_event_file_recv_set_filename(file_recv, filename, filename_length);
tox_event_file_recv_set_filename(file_recv, state->mem, filename, filename_length);
}

23
toxcore/events/file_recv_chunk.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -65,11 +64,11 @@ uint64_t tox_event_file_recv_chunk_get_position(const Tox_Event_File_Recv_Chunk
}
static bool tox_event_file_recv_chunk_set_data(Tox_Event_File_Recv_Chunk *_Nonnull file_recv_chunk,
const uint8_t *_Nullable data, uint32_t data_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable data, uint32_t data_length)
{
assert(file_recv_chunk != nullptr);
if (file_recv_chunk->data != nullptr) {
free(file_recv_chunk->data);
mem_delete(mem, file_recv_chunk->data);
file_recv_chunk->data = nullptr;
file_recv_chunk->data_length = 0;
}
@@ -79,7 +78,7 @@ static bool tox_event_file_recv_chunk_set_data(Tox_Event_File_Recv_Chunk *_Nonnu
return true;
}
uint8_t *data_copy = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
return false;
@@ -109,7 +108,7 @@ static void tox_event_file_recv_chunk_construct(Tox_Event_File_Recv_Chunk *_Nonn
}
static void tox_event_file_recv_chunk_destruct(Tox_Event_File_Recv_Chunk *_Nonnull file_recv_chunk, const Memory *_Nonnull mem)
{
free(file_recv_chunk->data);
mem_delete(mem, file_recv_chunk->data);
}
bool tox_event_file_recv_chunk_pack(
@@ -162,7 +161,7 @@ Tox_Event_File_Recv_Chunk *tox_event_file_recv_chunk_new(const Memory *mem)
void tox_event_file_recv_chunk_free(Tox_Event_File_Recv_Chunk *file_recv_chunk, const Memory *mem)
{
if (file_recv_chunk != nullptr) {
tox_event_file_recv_chunk_destruct(file_recv_chunk, mem);
tox_event_file_recv_chunk_destruct((Tox_Event_File_Recv_Chunk * _Nonnull)file_recv_chunk, mem);
}
mem_delete(mem, file_recv_chunk);
}
@@ -200,11 +199,8 @@ bool tox_event_file_recv_chunk_unpack(
return tox_event_file_recv_chunk_unpack_into(*event, bu);
}
static Tox_Event_File_Recv_Chunk *tox_event_file_recv_chunk_alloc(void *_Nonnull user_data)
static Tox_Event_File_Recv_Chunk *tox_event_file_recv_chunk_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -229,7 +225,8 @@ void tox_events_handle_file_recv_chunk(
Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position, const uint8_t *data, size_t length,
void *user_data)
{
Tox_Event_File_Recv_Chunk *file_recv_chunk = tox_event_file_recv_chunk_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_File_Recv_Chunk *file_recv_chunk = tox_event_file_recv_chunk_alloc(state);
if (file_recv_chunk == nullptr) {
return;
@@ -238,5 +235,5 @@ void tox_events_handle_file_recv_chunk(
tox_event_file_recv_chunk_set_friend_number(file_recv_chunk, friend_number);
tox_event_file_recv_chunk_set_file_number(file_recv_chunk, file_number);
tox_event_file_recv_chunk_set_position(file_recv_chunk, position);
tox_event_file_recv_chunk_set_data(file_recv_chunk, data, length);
tox_event_file_recv_chunk_set_data(file_recv_chunk, state->mem, data, length);
}

12
toxcore/events/file_recv_control.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -121,7 +121,7 @@ Tox_Event_File_Recv_Control *tox_event_file_recv_control_new(const Memory *mem)
void tox_event_file_recv_control_free(Tox_Event_File_Recv_Control *file_recv_control, const Memory *mem)
{
if (file_recv_control != nullptr) {
tox_event_file_recv_control_destruct(file_recv_control, mem);
tox_event_file_recv_control_destruct((Tox_Event_File_Recv_Control * _Nonnull)file_recv_control, mem);
}
mem_delete(mem, file_recv_control);
}
@@ -159,11 +159,8 @@ bool tox_event_file_recv_control_unpack(
return tox_event_file_recv_control_unpack_into(*event, bu);
}
static Tox_Event_File_Recv_Control *tox_event_file_recv_control_alloc(void *_Nonnull user_data)
static Tox_Event_File_Recv_Control *tox_event_file_recv_control_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -188,7 +185,8 @@ void tox_events_handle_file_recv_control(
Tox *tox, uint32_t friend_number, uint32_t file_number, Tox_File_Control control,
void *user_data)
{
Tox_Event_File_Recv_Control *file_recv_control = tox_event_file_recv_control_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_File_Recv_Control *file_recv_control = tox_event_file_recv_control_alloc(state);
if (file_recv_control == nullptr) {
return;

12
toxcore/events/friend_connection_status.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -107,7 +107,7 @@ Tox_Event_Friend_Connection_Status *tox_event_friend_connection_status_new(const
void tox_event_friend_connection_status_free(Tox_Event_Friend_Connection_Status *friend_connection_status, const Memory *mem)
{
if (friend_connection_status != nullptr) {
tox_event_friend_connection_status_destruct(friend_connection_status, mem);
tox_event_friend_connection_status_destruct((Tox_Event_Friend_Connection_Status * _Nonnull)friend_connection_status, mem);
}
mem_delete(mem, friend_connection_status);
}
@@ -145,11 +145,8 @@ bool tox_event_friend_connection_status_unpack(
return tox_event_friend_connection_status_unpack_into(*event, bu);
}
static Tox_Event_Friend_Connection_Status *tox_event_friend_connection_status_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Connection_Status *tox_event_friend_connection_status_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -174,7 +171,8 @@ void tox_events_handle_friend_connection_status(
Tox *tox, uint32_t friend_number, Tox_Connection connection_status,
void *user_data)
{
Tox_Event_Friend_Connection_Status *friend_connection_status = tox_event_friend_connection_status_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Connection_Status *friend_connection_status = tox_event_friend_connection_status_alloc(state);
if (friend_connection_status == nullptr) {
return;

23
toxcore/events/friend_lossless_packet.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -41,11 +40,11 @@ uint32_t tox_event_friend_lossless_packet_get_friend_number(const Tox_Event_Frie
}
static bool tox_event_friend_lossless_packet_set_data(Tox_Event_Friend_Lossless_Packet *_Nonnull friend_lossless_packet,
const uint8_t *_Nullable data, uint32_t data_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable data, uint32_t data_length)
{
assert(friend_lossless_packet != nullptr);
if (friend_lossless_packet->data != nullptr) {
free(friend_lossless_packet->data);
mem_delete(mem, friend_lossless_packet->data);
friend_lossless_packet->data = nullptr;
friend_lossless_packet->data_length = 0;
}
@@ -55,7 +54,7 @@ static bool tox_event_friend_lossless_packet_set_data(Tox_Event_Friend_Lossless_
return true;
}
uint8_t *data_copy = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
return false;
@@ -85,7 +84,7 @@ static void tox_event_friend_lossless_packet_construct(Tox_Event_Friend_Lossless
}
static void tox_event_friend_lossless_packet_destruct(Tox_Event_Friend_Lossless_Packet *_Nonnull friend_lossless_packet, const Memory *_Nonnull mem)
{
free(friend_lossless_packet->data);
mem_delete(mem, friend_lossless_packet->data);
}
bool tox_event_friend_lossless_packet_pack(
@@ -134,7 +133,7 @@ Tox_Event_Friend_Lossless_Packet *tox_event_friend_lossless_packet_new(const Mem
void tox_event_friend_lossless_packet_free(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet, const Memory *mem)
{
if (friend_lossless_packet != nullptr) {
tox_event_friend_lossless_packet_destruct(friend_lossless_packet, mem);
tox_event_friend_lossless_packet_destruct((Tox_Event_Friend_Lossless_Packet * _Nonnull)friend_lossless_packet, mem);
}
mem_delete(mem, friend_lossless_packet);
}
@@ -172,11 +171,8 @@ bool tox_event_friend_lossless_packet_unpack(
return tox_event_friend_lossless_packet_unpack_into(*event, bu);
}
static Tox_Event_Friend_Lossless_Packet *tox_event_friend_lossless_packet_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Lossless_Packet *tox_event_friend_lossless_packet_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -201,12 +197,13 @@ void tox_events_handle_friend_lossless_packet(
Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
void *user_data)
{
Tox_Event_Friend_Lossless_Packet *friend_lossless_packet = tox_event_friend_lossless_packet_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Lossless_Packet *friend_lossless_packet = tox_event_friend_lossless_packet_alloc(state);
if (friend_lossless_packet == nullptr) {
return;
}
tox_event_friend_lossless_packet_set_friend_number(friend_lossless_packet, friend_number);
tox_event_friend_lossless_packet_set_data(friend_lossless_packet, data, length);
tox_event_friend_lossless_packet_set_data(friend_lossless_packet, state->mem, data, length);
}

23
toxcore/events/friend_lossy_packet.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -41,11 +40,11 @@ uint32_t tox_event_friend_lossy_packet_get_friend_number(const Tox_Event_Friend_
}
static bool tox_event_friend_lossy_packet_set_data(Tox_Event_Friend_Lossy_Packet *_Nonnull friend_lossy_packet,
const uint8_t *_Nullable data, uint32_t data_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable data, uint32_t data_length)
{
assert(friend_lossy_packet != nullptr);
if (friend_lossy_packet->data != nullptr) {
free(friend_lossy_packet->data);
mem_delete(mem, friend_lossy_packet->data);
friend_lossy_packet->data = nullptr;
friend_lossy_packet->data_length = 0;
}
@@ -55,7 +54,7 @@ static bool tox_event_friend_lossy_packet_set_data(Tox_Event_Friend_Lossy_Packet
return true;
}
uint8_t *data_copy = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
return false;
@@ -85,7 +84,7 @@ static void tox_event_friend_lossy_packet_construct(Tox_Event_Friend_Lossy_Packe
}
static void tox_event_friend_lossy_packet_destruct(Tox_Event_Friend_Lossy_Packet *_Nonnull friend_lossy_packet, const Memory *_Nonnull mem)
{
free(friend_lossy_packet->data);
mem_delete(mem, friend_lossy_packet->data);
}
bool tox_event_friend_lossy_packet_pack(
@@ -134,7 +133,7 @@ Tox_Event_Friend_Lossy_Packet *tox_event_friend_lossy_packet_new(const Memory *m
void tox_event_friend_lossy_packet_free(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet, const Memory *mem)
{
if (friend_lossy_packet != nullptr) {
tox_event_friend_lossy_packet_destruct(friend_lossy_packet, mem);
tox_event_friend_lossy_packet_destruct((Tox_Event_Friend_Lossy_Packet * _Nonnull)friend_lossy_packet, mem);
}
mem_delete(mem, friend_lossy_packet);
}
@@ -172,11 +171,8 @@ bool tox_event_friend_lossy_packet_unpack(
return tox_event_friend_lossy_packet_unpack_into(*event, bu);
}
static Tox_Event_Friend_Lossy_Packet *tox_event_friend_lossy_packet_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Lossy_Packet *tox_event_friend_lossy_packet_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -201,12 +197,13 @@ void tox_events_handle_friend_lossy_packet(
Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
void *user_data)
{
Tox_Event_Friend_Lossy_Packet *friend_lossy_packet = tox_event_friend_lossy_packet_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Lossy_Packet *friend_lossy_packet = tox_event_friend_lossy_packet_alloc(state);
if (friend_lossy_packet == nullptr) {
return;
}
tox_event_friend_lossy_packet_set_friend_number(friend_lossy_packet, friend_number);
tox_event_friend_lossy_packet_set_data(friend_lossy_packet, data, length);
tox_event_friend_lossy_packet_set_data(friend_lossy_packet, state->mem, data, length);
}

23
toxcore/events/friend_message.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -55,11 +54,11 @@ Tox_Message_Type tox_event_friend_message_get_type(const Tox_Event_Friend_Messag
}
static bool tox_event_friend_message_set_message(Tox_Event_Friend_Message *_Nonnull friend_message,
const uint8_t *_Nullable message, uint32_t message_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable message, uint32_t message_length)
{
assert(friend_message != nullptr);
if (friend_message->message != nullptr) {
free(friend_message->message);
mem_delete(mem, friend_message->message);
friend_message->message = nullptr;
friend_message->message_length = 0;
}
@@ -69,7 +68,7 @@ static bool tox_event_friend_message_set_message(Tox_Event_Friend_Message *_Nonn
return true;
}
uint8_t *message_copy = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
return false;
@@ -99,7 +98,7 @@ static void tox_event_friend_message_construct(Tox_Event_Friend_Message *_Nonnul
}
static void tox_event_friend_message_destruct(Tox_Event_Friend_Message *_Nonnull friend_message, const Memory *_Nonnull mem)
{
free(friend_message->message);
mem_delete(mem, friend_message->message);
}
bool tox_event_friend_message_pack(
@@ -150,7 +149,7 @@ Tox_Event_Friend_Message *tox_event_friend_message_new(const Memory *mem)
void tox_event_friend_message_free(Tox_Event_Friend_Message *friend_message, const Memory *mem)
{
if (friend_message != nullptr) {
tox_event_friend_message_destruct(friend_message, mem);
tox_event_friend_message_destruct((Tox_Event_Friend_Message * _Nonnull)friend_message, mem);
}
mem_delete(mem, friend_message);
}
@@ -188,11 +187,8 @@ bool tox_event_friend_message_unpack(
return tox_event_friend_message_unpack_into(*event, bu);
}
static Tox_Event_Friend_Message *tox_event_friend_message_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Message *tox_event_friend_message_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -217,7 +213,8 @@ void tox_events_handle_friend_message(
Tox *tox, uint32_t friend_number, Tox_Message_Type type, const uint8_t *message, size_t length,
void *user_data)
{
Tox_Event_Friend_Message *friend_message = tox_event_friend_message_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Message *friend_message = tox_event_friend_message_alloc(state);
if (friend_message == nullptr) {
return;
@@ -225,5 +222,5 @@ void tox_events_handle_friend_message(
tox_event_friend_message_set_friend_number(friend_message, friend_number);
tox_event_friend_message_set_type(friend_message, type);
tox_event_friend_message_set_message(friend_message, message, length);
tox_event_friend_message_set_message(friend_message, state->mem, message, length);
}

23
toxcore/events/friend_name.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -41,11 +40,11 @@ uint32_t tox_event_friend_name_get_friend_number(const Tox_Event_Friend_Name *fr
}
static bool tox_event_friend_name_set_name(Tox_Event_Friend_Name *_Nonnull friend_name,
const uint8_t *_Nullable name, uint32_t name_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable name, uint32_t name_length)
{
assert(friend_name != nullptr);
if (friend_name->name != nullptr) {
free(friend_name->name);
mem_delete(mem, friend_name->name);
friend_name->name = nullptr;
friend_name->name_length = 0;
}
@@ -55,7 +54,7 @@ static bool tox_event_friend_name_set_name(Tox_Event_Friend_Name *_Nonnull frien
return true;
}
uint8_t *name_copy = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
return false;
@@ -85,7 +84,7 @@ static void tox_event_friend_name_construct(Tox_Event_Friend_Name *_Nonnull frie
}
static void tox_event_friend_name_destruct(Tox_Event_Friend_Name *_Nonnull friend_name, const Memory *_Nonnull mem)
{
free(friend_name->name);
mem_delete(mem, friend_name->name);
}
bool tox_event_friend_name_pack(
@@ -134,7 +133,7 @@ Tox_Event_Friend_Name *tox_event_friend_name_new(const Memory *mem)
void tox_event_friend_name_free(Tox_Event_Friend_Name *friend_name, const Memory *mem)
{
if (friend_name != nullptr) {
tox_event_friend_name_destruct(friend_name, mem);
tox_event_friend_name_destruct((Tox_Event_Friend_Name * _Nonnull)friend_name, mem);
}
mem_delete(mem, friend_name);
}
@@ -172,11 +171,8 @@ bool tox_event_friend_name_unpack(
return tox_event_friend_name_unpack_into(*event, bu);
}
static Tox_Event_Friend_Name *tox_event_friend_name_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Name *tox_event_friend_name_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -201,12 +197,13 @@ void tox_events_handle_friend_name(
Tox *tox, uint32_t friend_number, const uint8_t *name, size_t length,
void *user_data)
{
Tox_Event_Friend_Name *friend_name = tox_event_friend_name_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Name *friend_name = tox_event_friend_name_alloc(state);
if (friend_name == nullptr) {
return;
}
tox_event_friend_name_set_friend_number(friend_name, friend_number);
tox_event_friend_name_set_name(friend_name, name, length);
tox_event_friend_name_set_name(friend_name, state->mem, name, length);
}

12
toxcore/events/friend_read_receipt.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -105,7 +105,7 @@ Tox_Event_Friend_Read_Receipt *tox_event_friend_read_receipt_new(const Memory *m
void tox_event_friend_read_receipt_free(Tox_Event_Friend_Read_Receipt *friend_read_receipt, const Memory *mem)
{
if (friend_read_receipt != nullptr) {
tox_event_friend_read_receipt_destruct(friend_read_receipt, mem);
tox_event_friend_read_receipt_destruct((Tox_Event_Friend_Read_Receipt * _Nonnull)friend_read_receipt, mem);
}
mem_delete(mem, friend_read_receipt);
}
@@ -143,11 +143,8 @@ bool tox_event_friend_read_receipt_unpack(
return tox_event_friend_read_receipt_unpack_into(*event, bu);
}
static Tox_Event_Friend_Read_Receipt *tox_event_friend_read_receipt_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Read_Receipt *tox_event_friend_read_receipt_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -172,7 +169,8 @@ void tox_events_handle_friend_read_receipt(
Tox *tox, uint32_t friend_number, uint32_t message_id,
void *user_data)
{
Tox_Event_Friend_Read_Receipt *friend_read_receipt = tox_event_friend_read_receipt_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Read_Receipt *friend_read_receipt = tox_event_friend_read_receipt_alloc(state);
if (friend_read_receipt == nullptr) {
return;

43
toxcore/events/friend_request.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -15,7 +15,6 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_private.h"
/*****************************************************
*
@@ -29,10 +28,9 @@ struct Tox_Event_Friend_Request {
uint32_t message_length;
};
static bool tox_event_friend_request_set_public_key(Tox_Event_Friend_Request *_Nonnull friend_request, const uint8_t *_Nonnull public_key)
static bool tox_event_friend_request_set_public_key(Tox_Event_Friend_Request *_Nonnull friend_request, const uint8_t public_key[TOX_PUBLIC_KEY_SIZE])
{
assert(friend_request != nullptr);
memcpy(friend_request->public_key, public_key, TOX_PUBLIC_KEY_SIZE);
return true;
}
@@ -42,16 +40,21 @@ const uint8_t *tox_event_friend_request_get_public_key(const Tox_Event_Friend_Re
return friend_request->public_key;
}
static bool tox_event_friend_request_set_message(Tox_Event_Friend_Request *_Nonnull friend_request, const uint8_t *_Nonnull message, uint32_t message_length, const Memory *_Nonnull mem)
static bool tox_event_friend_request_set_message(Tox_Event_Friend_Request *_Nonnull friend_request,
const Memory *_Nonnull mem, const uint8_t *_Nullable message, uint32_t message_length)
{
assert(friend_request != nullptr);
if (friend_request->message != nullptr) {
mem_delete(mem, friend_request->message);
friend_request->message = nullptr;
friend_request->message_length = 0;
}
if (message == nullptr) {
assert(message_length == 0);
return true;
}
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
@@ -106,8 +109,13 @@ static bool tox_event_friend_request_unpack_into(Tox_Event_Friend_Request *_Nonn
&& bin_unpack_bin(bu, &event->message, &event->message_length);
}
const Tox_Event_Friend_Request *tox_event_get_friend_request(
const Tox_Event *event)
/*****************************************************
*
* :: new/free/add/get/size/unpack
*
*****************************************************/
const Tox_Event_Friend_Request *tox_event_get_friend_request(const Tox_Event *event)
{
return event->type == TOX_EVENT_FRIEND_REQUEST ? event->data.friend_request : nullptr;
}
@@ -128,7 +136,7 @@ Tox_Event_Friend_Request *tox_event_friend_request_new(const Memory *mem)
void tox_event_friend_request_free(Tox_Event_Friend_Request *friend_request, const Memory *mem)
{
if (friend_request != nullptr) {
tox_event_friend_request_destruct(friend_request, mem);
tox_event_friend_request_destruct((Tox_Event_Friend_Request * _Nonnull)friend_request, mem);
}
mem_delete(mem, friend_request);
}
@@ -166,11 +174,8 @@ bool tox_event_friend_request_unpack(
return tox_event_friend_request_unpack_into(*event, bu);
}
static Tox_Event_Friend_Request *tox_event_friend_request_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Request *tox_event_friend_request_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -191,17 +196,17 @@ static Tox_Event_Friend_Request *tox_event_friend_request_alloc(void *_Nonnull u
*
*****************************************************/
void tox_events_handle_friend_request(Tox *tox, const uint8_t *public_key, const uint8_t *message, size_t length,
void *user_data)
void tox_events_handle_friend_request(
Tox *tox, const uint8_t *public_key, const uint8_t *message, size_t length,
void *user_data)
{
Tox_Event_Friend_Request *friend_request = tox_event_friend_request_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Request *friend_request = tox_event_friend_request_alloc(state);
if (friend_request == nullptr) {
return;
}
const Tox_System *sys = tox_get_system(tox);
tox_event_friend_request_set_public_key(friend_request, public_key);
tox_event_friend_request_set_message(friend_request, message, length, sys->mem);
tox_event_friend_request_set_message(friend_request, state->mem, message, length);
}

12
toxcore/events/friend_status.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -107,7 +107,7 @@ Tox_Event_Friend_Status *tox_event_friend_status_new(const Memory *mem)
void tox_event_friend_status_free(Tox_Event_Friend_Status *friend_status, const Memory *mem)
{
if (friend_status != nullptr) {
tox_event_friend_status_destruct(friend_status, mem);
tox_event_friend_status_destruct((Tox_Event_Friend_Status * _Nonnull)friend_status, mem);
}
mem_delete(mem, friend_status);
}
@@ -145,11 +145,8 @@ bool tox_event_friend_status_unpack(
return tox_event_friend_status_unpack_into(*event, bu);
}
static Tox_Event_Friend_Status *tox_event_friend_status_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Status *tox_event_friend_status_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -174,7 +171,8 @@ void tox_events_handle_friend_status(
Tox *tox, uint32_t friend_number, Tox_User_Status status,
void *user_data)
{
Tox_Event_Friend_Status *friend_status = tox_event_friend_status_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Status *friend_status = tox_event_friend_status_alloc(state);
if (friend_status == nullptr) {
return;

23
toxcore/events/friend_status_message.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -41,11 +40,11 @@ uint32_t tox_event_friend_status_message_get_friend_number(const Tox_Event_Frien
}
static bool tox_event_friend_status_message_set_message(Tox_Event_Friend_Status_Message *_Nonnull friend_status_message,
const uint8_t *_Nullable message, uint32_t message_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable message, uint32_t message_length)
{
assert(friend_status_message != nullptr);
if (friend_status_message->message != nullptr) {
free(friend_status_message->message);
mem_delete(mem, friend_status_message->message);
friend_status_message->message = nullptr;
friend_status_message->message_length = 0;
}
@@ -55,7 +54,7 @@ static bool tox_event_friend_status_message_set_message(Tox_Event_Friend_Status_
return true;
}
uint8_t *message_copy = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
return false;
@@ -85,7 +84,7 @@ static void tox_event_friend_status_message_construct(Tox_Event_Friend_Status_Me
}
static void tox_event_friend_status_message_destruct(Tox_Event_Friend_Status_Message *_Nonnull friend_status_message, const Memory *_Nonnull mem)
{
free(friend_status_message->message);
mem_delete(mem, friend_status_message->message);
}
bool tox_event_friend_status_message_pack(
@@ -134,7 +133,7 @@ Tox_Event_Friend_Status_Message *tox_event_friend_status_message_new(const Memor
void tox_event_friend_status_message_free(Tox_Event_Friend_Status_Message *friend_status_message, const Memory *mem)
{
if (friend_status_message != nullptr) {
tox_event_friend_status_message_destruct(friend_status_message, mem);
tox_event_friend_status_message_destruct((Tox_Event_Friend_Status_Message * _Nonnull)friend_status_message, mem);
}
mem_delete(mem, friend_status_message);
}
@@ -172,11 +171,8 @@ bool tox_event_friend_status_message_unpack(
return tox_event_friend_status_message_unpack_into(*event, bu);
}
static Tox_Event_Friend_Status_Message *tox_event_friend_status_message_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Status_Message *tox_event_friend_status_message_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -201,12 +197,13 @@ void tox_events_handle_friend_status_message(
Tox *tox, uint32_t friend_number, const uint8_t *message, size_t length,
void *user_data)
{
Tox_Event_Friend_Status_Message *friend_status_message = tox_event_friend_status_message_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Status_Message *friend_status_message = tox_event_friend_status_message_alloc(state);
if (friend_status_message == nullptr) {
return;
}
tox_event_friend_status_message_set_friend_number(friend_status_message, friend_number);
tox_event_friend_status_message_set_message(friend_status_message, message, length);
tox_event_friend_status_message_set_message(friend_status_message, state->mem, message, length);
}

12
toxcore/events/friend_typing.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -105,7 +105,7 @@ Tox_Event_Friend_Typing *tox_event_friend_typing_new(const Memory *mem)
void tox_event_friend_typing_free(Tox_Event_Friend_Typing *friend_typing, const Memory *mem)
{
if (friend_typing != nullptr) {
tox_event_friend_typing_destruct(friend_typing, mem);
tox_event_friend_typing_destruct((Tox_Event_Friend_Typing * _Nonnull)friend_typing, mem);
}
mem_delete(mem, friend_typing);
}
@@ -143,11 +143,8 @@ bool tox_event_friend_typing_unpack(
return tox_event_friend_typing_unpack_into(*event, bu);
}
static Tox_Event_Friend_Typing *tox_event_friend_typing_alloc(void *_Nonnull user_data)
static Tox_Event_Friend_Typing *tox_event_friend_typing_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -172,7 +169,8 @@ void tox_events_handle_friend_typing(
Tox *tox, uint32_t friend_number, bool typing,
void *user_data)
{
Tox_Event_Friend_Typing *friend_typing = tox_event_friend_typing_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Friend_Typing *friend_typing = tox_event_friend_typing_alloc(state);
if (friend_typing == nullptr) {
return;

23
toxcore/events/group_custom_packet.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -53,11 +52,11 @@ uint32_t tox_event_group_custom_packet_get_peer_id(const Tox_Event_Group_Custom_
}
static bool tox_event_group_custom_packet_set_data(Tox_Event_Group_Custom_Packet *_Nonnull group_custom_packet,
const uint8_t *_Nullable data, uint32_t data_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable data, uint32_t data_length)
{
assert(group_custom_packet != nullptr);
if (group_custom_packet->data != nullptr) {
free(group_custom_packet->data);
mem_delete(mem, group_custom_packet->data);
group_custom_packet->data = nullptr;
group_custom_packet->data_length = 0;
}
@@ -67,7 +66,7 @@ static bool tox_event_group_custom_packet_set_data(Tox_Event_Group_Custom_Packet
return true;
}
uint8_t *data_copy = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
return false;
@@ -97,7 +96,7 @@ static void tox_event_group_custom_packet_construct(Tox_Event_Group_Custom_Packe
}
static void tox_event_group_custom_packet_destruct(Tox_Event_Group_Custom_Packet *_Nonnull group_custom_packet, const Memory *_Nonnull mem)
{
free(group_custom_packet->data);
mem_delete(mem, group_custom_packet->data);
}
bool tox_event_group_custom_packet_pack(
@@ -148,7 +147,7 @@ Tox_Event_Group_Custom_Packet *tox_event_group_custom_packet_new(const Memory *m
void tox_event_group_custom_packet_free(Tox_Event_Group_Custom_Packet *group_custom_packet, const Memory *mem)
{
if (group_custom_packet != nullptr) {
tox_event_group_custom_packet_destruct(group_custom_packet, mem);
tox_event_group_custom_packet_destruct((Tox_Event_Group_Custom_Packet * _Nonnull)group_custom_packet, mem);
}
mem_delete(mem, group_custom_packet);
}
@@ -186,11 +185,8 @@ bool tox_event_group_custom_packet_unpack(
return tox_event_group_custom_packet_unpack_into(*event, bu);
}
static Tox_Event_Group_Custom_Packet *tox_event_group_custom_packet_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Custom_Packet *tox_event_group_custom_packet_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -215,7 +211,8 @@ void tox_events_handle_group_custom_packet(
Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *data, size_t data_length,
void *user_data)
{
Tox_Event_Group_Custom_Packet *group_custom_packet = tox_event_group_custom_packet_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Custom_Packet *group_custom_packet = tox_event_group_custom_packet_alloc(state);
if (group_custom_packet == nullptr) {
return;
@@ -223,5 +220,5 @@ void tox_events_handle_group_custom_packet(
tox_event_group_custom_packet_set_group_number(group_custom_packet, group_number);
tox_event_group_custom_packet_set_peer_id(group_custom_packet, peer_id);
tox_event_group_custom_packet_set_data(group_custom_packet, data, data_length);
tox_event_group_custom_packet_set_data(group_custom_packet, state->mem, data, data_length);
}

23
toxcore/events/group_custom_private_packet.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -53,11 +52,11 @@ uint32_t tox_event_group_custom_private_packet_get_peer_id(const Tox_Event_Group
}
static bool tox_event_group_custom_private_packet_set_data(Tox_Event_Group_Custom_Private_Packet *_Nonnull group_custom_private_packet,
const uint8_t *_Nullable data, uint32_t data_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable data, uint32_t data_length)
{
assert(group_custom_private_packet != nullptr);
if (group_custom_private_packet->data != nullptr) {
free(group_custom_private_packet->data);
mem_delete(mem, group_custom_private_packet->data);
group_custom_private_packet->data = nullptr;
group_custom_private_packet->data_length = 0;
}
@@ -67,7 +66,7 @@ static bool tox_event_group_custom_private_packet_set_data(Tox_Event_Group_Custo
return true;
}
uint8_t *data_copy = (uint8_t *)malloc(data_length);
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
return false;
@@ -97,7 +96,7 @@ static void tox_event_group_custom_private_packet_construct(Tox_Event_Group_Cust
}
static void tox_event_group_custom_private_packet_destruct(Tox_Event_Group_Custom_Private_Packet *_Nonnull group_custom_private_packet, const Memory *_Nonnull mem)
{
free(group_custom_private_packet->data);
mem_delete(mem, group_custom_private_packet->data);
}
bool tox_event_group_custom_private_packet_pack(
@@ -148,7 +147,7 @@ Tox_Event_Group_Custom_Private_Packet *tox_event_group_custom_private_packet_new
void tox_event_group_custom_private_packet_free(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet, const Memory *mem)
{
if (group_custom_private_packet != nullptr) {
tox_event_group_custom_private_packet_destruct(group_custom_private_packet, mem);
tox_event_group_custom_private_packet_destruct((Tox_Event_Group_Custom_Private_Packet * _Nonnull)group_custom_private_packet, mem);
}
mem_delete(mem, group_custom_private_packet);
}
@@ -186,11 +185,8 @@ bool tox_event_group_custom_private_packet_unpack(
return tox_event_group_custom_private_packet_unpack_into(*event, bu);
}
static Tox_Event_Group_Custom_Private_Packet *tox_event_group_custom_private_packet_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Custom_Private_Packet *tox_event_group_custom_private_packet_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -215,7 +211,8 @@ void tox_events_handle_group_custom_private_packet(
Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *data, size_t data_length,
void *user_data)
{
Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet = tox_event_group_custom_private_packet_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet = tox_event_group_custom_private_packet_alloc(state);
if (group_custom_private_packet == nullptr) {
return;
@@ -223,5 +220,5 @@ void tox_events_handle_group_custom_private_packet(
tox_event_group_custom_private_packet_set_group_number(group_custom_private_packet, group_number);
tox_event_group_custom_private_packet_set_peer_id(group_custom_private_packet, peer_id);
tox_event_group_custom_private_packet_set_data(group_custom_private_packet, data, data_length);
tox_event_group_custom_private_packet_set_data(group_custom_private_packet, state->mem, data, data_length);
}

33
toxcore/events/group_invite.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -43,11 +42,11 @@ uint32_t tox_event_group_invite_get_friend_number(const Tox_Event_Group_Invite *
}
static bool tox_event_group_invite_set_invite_data(Tox_Event_Group_Invite *_Nonnull group_invite,
const uint8_t *_Nullable invite_data, uint32_t invite_data_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable invite_data, uint32_t invite_data_length)
{
assert(group_invite != nullptr);
if (group_invite->invite_data != nullptr) {
free(group_invite->invite_data);
mem_delete(mem, group_invite->invite_data);
group_invite->invite_data = nullptr;
group_invite->invite_data_length = 0;
}
@@ -57,7 +56,7 @@ static bool tox_event_group_invite_set_invite_data(Tox_Event_Group_Invite *_Nonn
return true;
}
uint8_t *invite_data_copy = (uint8_t *)malloc(invite_data_length);
uint8_t *invite_data_copy = (uint8_t *)mem_balloc(mem, invite_data_length);
if (invite_data_copy == nullptr) {
return false;
@@ -80,11 +79,11 @@ const uint8_t *tox_event_group_invite_get_invite_data(const Tox_Event_Group_Invi
}
static bool tox_event_group_invite_set_group_name(Tox_Event_Group_Invite *_Nonnull group_invite,
const uint8_t *_Nullable group_name, uint32_t group_name_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable group_name, uint32_t group_name_length)
{
assert(group_invite != nullptr);
if (group_invite->group_name != nullptr) {
free(group_invite->group_name);
mem_delete(mem, group_invite->group_name);
group_invite->group_name = nullptr;
group_invite->group_name_length = 0;
}
@@ -94,7 +93,7 @@ static bool tox_event_group_invite_set_group_name(Tox_Event_Group_Invite *_Nonnu
return true;
}
uint8_t *group_name_copy = (uint8_t *)malloc(group_name_length);
uint8_t *group_name_copy = (uint8_t *)mem_balloc(mem, group_name_length);
if (group_name_copy == nullptr) {
return false;
@@ -124,8 +123,8 @@ static void tox_event_group_invite_construct(Tox_Event_Group_Invite *_Nonnull gr
}
static void tox_event_group_invite_destruct(Tox_Event_Group_Invite *_Nonnull group_invite, const Memory *_Nonnull mem)
{
free(group_invite->invite_data);
free(group_invite->group_name);
mem_delete(mem, group_invite->invite_data);
mem_delete(mem, group_invite->group_name);
}
bool tox_event_group_invite_pack(
@@ -176,7 +175,7 @@ Tox_Event_Group_Invite *tox_event_group_invite_new(const Memory *mem)
void tox_event_group_invite_free(Tox_Event_Group_Invite *group_invite, const Memory *mem)
{
if (group_invite != nullptr) {
tox_event_group_invite_destruct(group_invite, mem);
tox_event_group_invite_destruct((Tox_Event_Group_Invite * _Nonnull)group_invite, mem);
}
mem_delete(mem, group_invite);
}
@@ -214,11 +213,8 @@ bool tox_event_group_invite_unpack(
return tox_event_group_invite_unpack_into(*event, bu);
}
static Tox_Event_Group_Invite *tox_event_group_invite_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Invite *tox_event_group_invite_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -243,13 +239,14 @@ void tox_events_handle_group_invite(
Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t invite_data_length, const uint8_t *group_name, size_t group_name_length,
void *user_data)
{
Tox_Event_Group_Invite *group_invite = tox_event_group_invite_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Invite *group_invite = tox_event_group_invite_alloc(state);
if (group_invite == nullptr) {
return;
}
tox_event_group_invite_set_friend_number(group_invite, friend_number);
tox_event_group_invite_set_invite_data(group_invite, invite_data, invite_data_length);
tox_event_group_invite_set_group_name(group_invite, group_name, group_name_length);
tox_event_group_invite_set_invite_data(group_invite, state->mem, invite_data, invite_data_length);
tox_event_group_invite_set_group_name(group_invite, state->mem, group_name, group_name_length);
}

12
toxcore/events/group_join_fail.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -107,7 +107,7 @@ Tox_Event_Group_Join_Fail *tox_event_group_join_fail_new(const Memory *mem)
void tox_event_group_join_fail_free(Tox_Event_Group_Join_Fail *group_join_fail, const Memory *mem)
{
if (group_join_fail != nullptr) {
tox_event_group_join_fail_destruct(group_join_fail, mem);
tox_event_group_join_fail_destruct((Tox_Event_Group_Join_Fail * _Nonnull)group_join_fail, mem);
}
mem_delete(mem, group_join_fail);
}
@@ -145,11 +145,8 @@ bool tox_event_group_join_fail_unpack(
return tox_event_group_join_fail_unpack_into(*event, bu);
}
static Tox_Event_Group_Join_Fail *tox_event_group_join_fail_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Join_Fail *tox_event_group_join_fail_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -174,7 +171,8 @@ void tox_events_handle_group_join_fail(
Tox *tox, uint32_t group_number, Tox_Group_Join_Fail fail_type,
void *user_data)
{
Tox_Event_Group_Join_Fail *group_join_fail = tox_event_group_join_fail_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Join_Fail *group_join_fail = tox_event_group_join_fail_alloc(state);
if (group_join_fail == nullptr) {
return;

23
toxcore/events/group_message.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -68,11 +67,11 @@ Tox_Message_Type tox_event_group_message_get_message_type(const Tox_Event_Group_
}
static bool tox_event_group_message_set_message(Tox_Event_Group_Message *_Nonnull group_message,
const uint8_t *_Nullable message, uint32_t message_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable message, uint32_t message_length)
{
assert(group_message != nullptr);
if (group_message->message != nullptr) {
free(group_message->message);
mem_delete(mem, group_message->message);
group_message->message = nullptr;
group_message->message_length = 0;
}
@@ -82,7 +81,7 @@ static bool tox_event_group_message_set_message(Tox_Event_Group_Message *_Nonnul
return true;
}
uint8_t *message_copy = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
return false;
@@ -123,7 +122,7 @@ static void tox_event_group_message_construct(Tox_Event_Group_Message *_Nonnull
}
static void tox_event_group_message_destruct(Tox_Event_Group_Message *_Nonnull group_message, const Memory *_Nonnull mem)
{
free(group_message->message);
mem_delete(mem, group_message->message);
}
bool tox_event_group_message_pack(
@@ -178,7 +177,7 @@ Tox_Event_Group_Message *tox_event_group_message_new(const Memory *mem)
void tox_event_group_message_free(Tox_Event_Group_Message *group_message, const Memory *mem)
{
if (group_message != nullptr) {
tox_event_group_message_destruct(group_message, mem);
tox_event_group_message_destruct((Tox_Event_Group_Message * _Nonnull)group_message, mem);
}
mem_delete(mem, group_message);
}
@@ -216,11 +215,8 @@ bool tox_event_group_message_unpack(
return tox_event_group_message_unpack_into(*event, bu);
}
static Tox_Event_Group_Message *tox_event_group_message_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Message *tox_event_group_message_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -245,7 +241,8 @@ void tox_events_handle_group_message(
Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type message_type, const uint8_t *message, size_t message_length, uint32_t message_id,
void *user_data)
{
Tox_Event_Group_Message *group_message = tox_event_group_message_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Message *group_message = tox_event_group_message_alloc(state);
if (group_message == nullptr) {
return;
@@ -254,6 +251,6 @@ void tox_events_handle_group_message(
tox_event_group_message_set_group_number(group_message, group_number);
tox_event_group_message_set_peer_id(group_message, peer_id);
tox_event_group_message_set_message_type(group_message, message_type);
tox_event_group_message_set_message(group_message, message, message_length);
tox_event_group_message_set_message(group_message, state->mem, message, message_length);
tox_event_group_message_set_message_id(group_message, message_id);
}

12
toxcore/events/group_moderation.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -135,7 +135,7 @@ Tox_Event_Group_Moderation *tox_event_group_moderation_new(const Memory *mem)
void tox_event_group_moderation_free(Tox_Event_Group_Moderation *group_moderation, const Memory *mem)
{
if (group_moderation != nullptr) {
tox_event_group_moderation_destruct(group_moderation, mem);
tox_event_group_moderation_destruct((Tox_Event_Group_Moderation * _Nonnull)group_moderation, mem);
}
mem_delete(mem, group_moderation);
}
@@ -173,11 +173,8 @@ bool tox_event_group_moderation_unpack(
return tox_event_group_moderation_unpack_into(*event, bu);
}
static Tox_Event_Group_Moderation *tox_event_group_moderation_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Moderation *tox_event_group_moderation_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -202,7 +199,8 @@ void tox_events_handle_group_moderation(
Tox *tox, uint32_t group_number, uint32_t source_peer_id, uint32_t target_peer_id, Tox_Group_Mod_Event mod_type,
void *user_data)
{
Tox_Event_Group_Moderation *group_moderation = tox_event_group_moderation_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Moderation *group_moderation = tox_event_group_moderation_alloc(state);
if (group_moderation == nullptr) {
return;

23
toxcore/events/group_password.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -41,11 +40,11 @@ uint32_t tox_event_group_password_get_group_number(const Tox_Event_Group_Passwor
}
static bool tox_event_group_password_set_password(Tox_Event_Group_Password *_Nonnull group_password,
const uint8_t *_Nullable password, uint32_t password_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable password, uint32_t password_length)
{
assert(group_password != nullptr);
if (group_password->password != nullptr) {
free(group_password->password);
mem_delete(mem, group_password->password);
group_password->password = nullptr;
group_password->password_length = 0;
}
@@ -55,7 +54,7 @@ static bool tox_event_group_password_set_password(Tox_Event_Group_Password *_Non
return true;
}
uint8_t *password_copy = (uint8_t *)malloc(password_length);
uint8_t *password_copy = (uint8_t *)mem_balloc(mem, password_length);
if (password_copy == nullptr) {
return false;
@@ -85,7 +84,7 @@ static void tox_event_group_password_construct(Tox_Event_Group_Password *_Nonnul
}
static void tox_event_group_password_destruct(Tox_Event_Group_Password *_Nonnull group_password, const Memory *_Nonnull mem)
{
free(group_password->password);
mem_delete(mem, group_password->password);
}
bool tox_event_group_password_pack(
@@ -134,7 +133,7 @@ Tox_Event_Group_Password *tox_event_group_password_new(const Memory *mem)
void tox_event_group_password_free(Tox_Event_Group_Password *group_password, const Memory *mem)
{
if (group_password != nullptr) {
tox_event_group_password_destruct(group_password, mem);
tox_event_group_password_destruct((Tox_Event_Group_Password * _Nonnull)group_password, mem);
}
mem_delete(mem, group_password);
}
@@ -172,11 +171,8 @@ bool tox_event_group_password_unpack(
return tox_event_group_password_unpack_into(*event, bu);
}
static Tox_Event_Group_Password *tox_event_group_password_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Password *tox_event_group_password_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -201,12 +197,13 @@ void tox_events_handle_group_password(
Tox *tox, uint32_t group_number, const uint8_t *password, size_t password_length,
void *user_data)
{
Tox_Event_Group_Password *group_password = tox_event_group_password_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Password *group_password = tox_event_group_password_alloc(state);
if (group_password == nullptr) {
return;
}
tox_event_group_password_set_group_number(group_password, group_number);
tox_event_group_password_set_password(group_password, password, password_length);
tox_event_group_password_set_password(group_password, state->mem, password, password_length);
}

33
toxcore/events/group_peer_exit.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -69,11 +68,11 @@ Tox_Group_Exit_Type tox_event_group_peer_exit_get_exit_type(const Tox_Event_Grou
}
static bool tox_event_group_peer_exit_set_name(Tox_Event_Group_Peer_Exit *_Nonnull group_peer_exit,
const uint8_t *_Nullable name, uint32_t name_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable name, uint32_t name_length)
{
assert(group_peer_exit != nullptr);
if (group_peer_exit->name != nullptr) {
free(group_peer_exit->name);
mem_delete(mem, group_peer_exit->name);
group_peer_exit->name = nullptr;
group_peer_exit->name_length = 0;
}
@@ -83,7 +82,7 @@ static bool tox_event_group_peer_exit_set_name(Tox_Event_Group_Peer_Exit *_Nonnu
return true;
}
uint8_t *name_copy = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
return false;
@@ -106,11 +105,11 @@ const uint8_t *tox_event_group_peer_exit_get_name(const Tox_Event_Group_Peer_Exi
}
static bool tox_event_group_peer_exit_set_part_message(Tox_Event_Group_Peer_Exit *_Nonnull group_peer_exit,
const uint8_t *_Nullable part_message, uint32_t part_message_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable part_message, uint32_t part_message_length)
{
assert(group_peer_exit != nullptr);
if (group_peer_exit->part_message != nullptr) {
free(group_peer_exit->part_message);
mem_delete(mem, group_peer_exit->part_message);
group_peer_exit->part_message = nullptr;
group_peer_exit->part_message_length = 0;
}
@@ -120,7 +119,7 @@ static bool tox_event_group_peer_exit_set_part_message(Tox_Event_Group_Peer_Exit
return true;
}
uint8_t *part_message_copy = (uint8_t *)malloc(part_message_length);
uint8_t *part_message_copy = (uint8_t *)mem_balloc(mem, part_message_length);
if (part_message_copy == nullptr) {
return false;
@@ -150,8 +149,8 @@ static void tox_event_group_peer_exit_construct(Tox_Event_Group_Peer_Exit *_Nonn
}
static void tox_event_group_peer_exit_destruct(Tox_Event_Group_Peer_Exit *_Nonnull group_peer_exit, const Memory *_Nonnull mem)
{
free(group_peer_exit->name);
free(group_peer_exit->part_message);
mem_delete(mem, group_peer_exit->name);
mem_delete(mem, group_peer_exit->part_message);
}
bool tox_event_group_peer_exit_pack(
@@ -206,7 +205,7 @@ Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_new(const Memory *mem)
void tox_event_group_peer_exit_free(Tox_Event_Group_Peer_Exit *group_peer_exit, const Memory *mem)
{
if (group_peer_exit != nullptr) {
tox_event_group_peer_exit_destruct(group_peer_exit, mem);
tox_event_group_peer_exit_destruct((Tox_Event_Group_Peer_Exit * _Nonnull)group_peer_exit, mem);
}
mem_delete(mem, group_peer_exit);
}
@@ -244,11 +243,8 @@ bool tox_event_group_peer_exit_unpack(
return tox_event_group_peer_exit_unpack_into(*event, bu);
}
static Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -273,7 +269,8 @@ void tox_events_handle_group_peer_exit(
Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Group_Exit_Type exit_type, const uint8_t *name, size_t name_length, const uint8_t *part_message, size_t part_message_length,
void *user_data)
{
Tox_Event_Group_Peer_Exit *group_peer_exit = tox_event_group_peer_exit_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Peer_Exit *group_peer_exit = tox_event_group_peer_exit_alloc(state);
if (group_peer_exit == nullptr) {
return;
@@ -282,6 +279,6 @@ void tox_events_handle_group_peer_exit(
tox_event_group_peer_exit_set_group_number(group_peer_exit, group_number);
tox_event_group_peer_exit_set_peer_id(group_peer_exit, peer_id);
tox_event_group_peer_exit_set_exit_type(group_peer_exit, exit_type);
tox_event_group_peer_exit_set_name(group_peer_exit, name, name_length);
tox_event_group_peer_exit_set_part_message(group_peer_exit, part_message, part_message_length);
tox_event_group_peer_exit_set_name(group_peer_exit, state->mem, name, name_length);
tox_event_group_peer_exit_set_part_message(group_peer_exit, state->mem, part_message, part_message_length);
}

12
toxcore/events/group_peer_join.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -105,7 +105,7 @@ Tox_Event_Group_Peer_Join *tox_event_group_peer_join_new(const Memory *mem)
void tox_event_group_peer_join_free(Tox_Event_Group_Peer_Join *group_peer_join, const Memory *mem)
{
if (group_peer_join != nullptr) {
tox_event_group_peer_join_destruct(group_peer_join, mem);
tox_event_group_peer_join_destruct((Tox_Event_Group_Peer_Join * _Nonnull)group_peer_join, mem);
}
mem_delete(mem, group_peer_join);
}
@@ -143,11 +143,8 @@ bool tox_event_group_peer_join_unpack(
return tox_event_group_peer_join_unpack_into(*event, bu);
}
static Tox_Event_Group_Peer_Join *tox_event_group_peer_join_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Peer_Join *tox_event_group_peer_join_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -172,7 +169,8 @@ void tox_events_handle_group_peer_join(
Tox *tox, uint32_t group_number, uint32_t peer_id,
void *user_data)
{
Tox_Event_Group_Peer_Join *group_peer_join = tox_event_group_peer_join_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Peer_Join *group_peer_join = tox_event_group_peer_join_alloc(state);
if (group_peer_join == nullptr) {
return;

12
toxcore/events/group_peer_limit.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -105,7 +105,7 @@ Tox_Event_Group_Peer_Limit *tox_event_group_peer_limit_new(const Memory *mem)
void tox_event_group_peer_limit_free(Tox_Event_Group_Peer_Limit *group_peer_limit, const Memory *mem)
{
if (group_peer_limit != nullptr) {
tox_event_group_peer_limit_destruct(group_peer_limit, mem);
tox_event_group_peer_limit_destruct((Tox_Event_Group_Peer_Limit * _Nonnull)group_peer_limit, mem);
}
mem_delete(mem, group_peer_limit);
}
@@ -143,11 +143,8 @@ bool tox_event_group_peer_limit_unpack(
return tox_event_group_peer_limit_unpack_into(*event, bu);
}
static Tox_Event_Group_Peer_Limit *tox_event_group_peer_limit_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Peer_Limit *tox_event_group_peer_limit_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -172,7 +169,8 @@ void tox_events_handle_group_peer_limit(
Tox *tox, uint32_t group_number, uint32_t peer_limit,
void *user_data)
{
Tox_Event_Group_Peer_Limit *group_peer_limit = tox_event_group_peer_limit_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Peer_Limit *group_peer_limit = tox_event_group_peer_limit_alloc(state);
if (group_peer_limit == nullptr) {
return;

23
toxcore/events/group_peer_name.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -53,11 +52,11 @@ uint32_t tox_event_group_peer_name_get_peer_id(const Tox_Event_Group_Peer_Name *
}
static bool tox_event_group_peer_name_set_name(Tox_Event_Group_Peer_Name *_Nonnull group_peer_name,
const uint8_t *_Nullable name, uint32_t name_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable name, uint32_t name_length)
{
assert(group_peer_name != nullptr);
if (group_peer_name->name != nullptr) {
free(group_peer_name->name);
mem_delete(mem, group_peer_name->name);
group_peer_name->name = nullptr;
group_peer_name->name_length = 0;
}
@@ -67,7 +66,7 @@ static bool tox_event_group_peer_name_set_name(Tox_Event_Group_Peer_Name *_Nonnu
return true;
}
uint8_t *name_copy = (uint8_t *)malloc(name_length);
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
return false;
@@ -97,7 +96,7 @@ static void tox_event_group_peer_name_construct(Tox_Event_Group_Peer_Name *_Nonn
}
static void tox_event_group_peer_name_destruct(Tox_Event_Group_Peer_Name *_Nonnull group_peer_name, const Memory *_Nonnull mem)
{
free(group_peer_name->name);
mem_delete(mem, group_peer_name->name);
}
bool tox_event_group_peer_name_pack(
@@ -148,7 +147,7 @@ Tox_Event_Group_Peer_Name *tox_event_group_peer_name_new(const Memory *mem)
void tox_event_group_peer_name_free(Tox_Event_Group_Peer_Name *group_peer_name, const Memory *mem)
{
if (group_peer_name != nullptr) {
tox_event_group_peer_name_destruct(group_peer_name, mem);
tox_event_group_peer_name_destruct((Tox_Event_Group_Peer_Name * _Nonnull)group_peer_name, mem);
}
mem_delete(mem, group_peer_name);
}
@@ -186,11 +185,8 @@ bool tox_event_group_peer_name_unpack(
return tox_event_group_peer_name_unpack_into(*event, bu);
}
static Tox_Event_Group_Peer_Name *tox_event_group_peer_name_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Peer_Name *tox_event_group_peer_name_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -215,7 +211,8 @@ void tox_events_handle_group_peer_name(
Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *name, size_t name_length,
void *user_data)
{
Tox_Event_Group_Peer_Name *group_peer_name = tox_event_group_peer_name_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Peer_Name *group_peer_name = tox_event_group_peer_name_alloc(state);
if (group_peer_name == nullptr) {
return;
@@ -223,5 +220,5 @@ void tox_events_handle_group_peer_name(
tox_event_group_peer_name_set_group_number(group_peer_name, group_number);
tox_event_group_peer_name_set_peer_id(group_peer_name, peer_id);
tox_event_group_peer_name_set_name(group_peer_name, name, name_length);
tox_event_group_peer_name_set_name(group_peer_name, state->mem, name, name_length);
}

12
toxcore/events/group_peer_status.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -121,7 +121,7 @@ Tox_Event_Group_Peer_Status *tox_event_group_peer_status_new(const Memory *mem)
void tox_event_group_peer_status_free(Tox_Event_Group_Peer_Status *group_peer_status, const Memory *mem)
{
if (group_peer_status != nullptr) {
tox_event_group_peer_status_destruct(group_peer_status, mem);
tox_event_group_peer_status_destruct((Tox_Event_Group_Peer_Status * _Nonnull)group_peer_status, mem);
}
mem_delete(mem, group_peer_status);
}
@@ -159,11 +159,8 @@ bool tox_event_group_peer_status_unpack(
return tox_event_group_peer_status_unpack_into(*event, bu);
}
static Tox_Event_Group_Peer_Status *tox_event_group_peer_status_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Peer_Status *tox_event_group_peer_status_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -188,7 +185,8 @@ void tox_events_handle_group_peer_status(
Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_User_Status status,
void *user_data)
{
Tox_Event_Group_Peer_Status *group_peer_status = tox_event_group_peer_status_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Peer_Status *group_peer_status = tox_event_group_peer_status_alloc(state);
if (group_peer_status == nullptr) {
return;

12
toxcore/events/group_privacy_state.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -107,7 +107,7 @@ Tox_Event_Group_Privacy_State *tox_event_group_privacy_state_new(const Memory *m
void tox_event_group_privacy_state_free(Tox_Event_Group_Privacy_State *group_privacy_state, const Memory *mem)
{
if (group_privacy_state != nullptr) {
tox_event_group_privacy_state_destruct(group_privacy_state, mem);
tox_event_group_privacy_state_destruct((Tox_Event_Group_Privacy_State * _Nonnull)group_privacy_state, mem);
}
mem_delete(mem, group_privacy_state);
}
@@ -145,11 +145,8 @@ bool tox_event_group_privacy_state_unpack(
return tox_event_group_privacy_state_unpack_into(*event, bu);
}
static Tox_Event_Group_Privacy_State *tox_event_group_privacy_state_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Privacy_State *tox_event_group_privacy_state_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -174,7 +171,8 @@ void tox_events_handle_group_privacy_state(
Tox *tox, uint32_t group_number, Tox_Group_Privacy_State privacy_state,
void *user_data)
{
Tox_Event_Group_Privacy_State *group_privacy_state = tox_event_group_privacy_state_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Privacy_State *group_privacy_state = tox_event_group_privacy_state_alloc(state);
if (group_privacy_state == nullptr) {
return;

23
toxcore/events/group_private_message.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -68,11 +67,11 @@ Tox_Message_Type tox_event_group_private_message_get_message_type(const Tox_Even
}
static bool tox_event_group_private_message_set_message(Tox_Event_Group_Private_Message *_Nonnull group_private_message,
const uint8_t *_Nullable message, uint32_t message_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable message, uint32_t message_length)
{
assert(group_private_message != nullptr);
if (group_private_message->message != nullptr) {
free(group_private_message->message);
mem_delete(mem, group_private_message->message);
group_private_message->message = nullptr;
group_private_message->message_length = 0;
}
@@ -82,7 +81,7 @@ static bool tox_event_group_private_message_set_message(Tox_Event_Group_Private_
return true;
}
uint8_t *message_copy = (uint8_t *)malloc(message_length);
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
return false;
@@ -123,7 +122,7 @@ static void tox_event_group_private_message_construct(Tox_Event_Group_Private_Me
}
static void tox_event_group_private_message_destruct(Tox_Event_Group_Private_Message *_Nonnull group_private_message, const Memory *_Nonnull mem)
{
free(group_private_message->message);
mem_delete(mem, group_private_message->message);
}
bool tox_event_group_private_message_pack(
@@ -178,7 +177,7 @@ Tox_Event_Group_Private_Message *tox_event_group_private_message_new(const Memor
void tox_event_group_private_message_free(Tox_Event_Group_Private_Message *group_private_message, const Memory *mem)
{
if (group_private_message != nullptr) {
tox_event_group_private_message_destruct(group_private_message, mem);
tox_event_group_private_message_destruct((Tox_Event_Group_Private_Message * _Nonnull)group_private_message, mem);
}
mem_delete(mem, group_private_message);
}
@@ -216,11 +215,8 @@ bool tox_event_group_private_message_unpack(
return tox_event_group_private_message_unpack_into(*event, bu);
}
static Tox_Event_Group_Private_Message *tox_event_group_private_message_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Private_Message *tox_event_group_private_message_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -245,7 +241,8 @@ void tox_events_handle_group_private_message(
Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type message_type, const uint8_t *message, size_t message_length, uint32_t message_id,
void *user_data)
{
Tox_Event_Group_Private_Message *group_private_message = tox_event_group_private_message_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Private_Message *group_private_message = tox_event_group_private_message_alloc(state);
if (group_private_message == nullptr) {
return;
@@ -254,6 +251,6 @@ void tox_events_handle_group_private_message(
tox_event_group_private_message_set_group_number(group_private_message, group_number);
tox_event_group_private_message_set_peer_id(group_private_message, peer_id);
tox_event_group_private_message_set_message_type(group_private_message, message_type);
tox_event_group_private_message_set_message(group_private_message, message, message_length);
tox_event_group_private_message_set_message(group_private_message, state->mem, message, message_length);
tox_event_group_private_message_set_message_id(group_private_message, message_id);
}

12
toxcore/events/group_self_join.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -86,7 +86,7 @@ Tox_Event_Group_Self_Join *tox_event_group_self_join_new(const Memory *mem)
void tox_event_group_self_join_free(Tox_Event_Group_Self_Join *group_self_join, const Memory *mem)
{
if (group_self_join != nullptr) {
tox_event_group_self_join_destruct(group_self_join, mem);
tox_event_group_self_join_destruct((Tox_Event_Group_Self_Join * _Nonnull)group_self_join, mem);
}
mem_delete(mem, group_self_join);
}
@@ -124,11 +124,8 @@ bool tox_event_group_self_join_unpack(
return tox_event_group_self_join_unpack_into(*event, bu);
}
static Tox_Event_Group_Self_Join *tox_event_group_self_join_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Self_Join *tox_event_group_self_join_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -153,7 +150,8 @@ void tox_events_handle_group_self_join(
Tox *tox, uint32_t group_number,
void *user_data)
{
Tox_Event_Group_Self_Join *group_self_join = tox_event_group_self_join_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Self_Join *group_self_join = tox_event_group_self_join_alloc(state);
if (group_self_join == nullptr) {
return;

23
toxcore/events/group_topic.c
View File

@@ -1,11 +1,10 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "../attributes.h"
@@ -53,11 +52,11 @@ uint32_t tox_event_group_topic_get_peer_id(const Tox_Event_Group_Topic *group_to
}
static bool tox_event_group_topic_set_topic(Tox_Event_Group_Topic *_Nonnull group_topic,
const uint8_t *_Nullable topic, uint32_t topic_length)
const Memory *_Nonnull mem, const uint8_t *_Nullable topic, uint32_t topic_length)
{
assert(group_topic != nullptr);
if (group_topic->topic != nullptr) {
free(group_topic->topic);
mem_delete(mem, group_topic->topic);
group_topic->topic = nullptr;
group_topic->topic_length = 0;
}
@@ -67,7 +66,7 @@ static bool tox_event_group_topic_set_topic(Tox_Event_Group_Topic *_Nonnull grou
return true;
}
uint8_t *topic_copy = (uint8_t *)malloc(topic_length);
uint8_t *topic_copy = (uint8_t *)mem_balloc(mem, topic_length);
if (topic_copy == nullptr) {
return false;
@@ -97,7 +96,7 @@ static void tox_event_group_topic_construct(Tox_Event_Group_Topic *_Nonnull grou
}
static void tox_event_group_topic_destruct(Tox_Event_Group_Topic *_Nonnull group_topic, const Memory *_Nonnull mem)
{
free(group_topic->topic);
mem_delete(mem, group_topic->topic);
}
bool tox_event_group_topic_pack(
@@ -148,7 +147,7 @@ Tox_Event_Group_Topic *tox_event_group_topic_new(const Memory *mem)
void tox_event_group_topic_free(Tox_Event_Group_Topic *group_topic, const Memory *mem)
{
if (group_topic != nullptr) {
tox_event_group_topic_destruct(group_topic, mem);
tox_event_group_topic_destruct((Tox_Event_Group_Topic * _Nonnull)group_topic, mem);
}
mem_delete(mem, group_topic);
}
@@ -186,11 +185,8 @@ bool tox_event_group_topic_unpack(
return tox_event_group_topic_unpack_into(*event, bu);
}
static Tox_Event_Group_Topic *tox_event_group_topic_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Topic *tox_event_group_topic_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -215,7 +211,8 @@ void tox_events_handle_group_topic(
Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *topic, size_t topic_length,
void *user_data)
{
Tox_Event_Group_Topic *group_topic = tox_event_group_topic_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Topic *group_topic = tox_event_group_topic_alloc(state);
if (group_topic == nullptr) {
return;
@@ -223,5 +220,5 @@ void tox_events_handle_group_topic(
tox_event_group_topic_set_group_number(group_topic, group_number);
tox_event_group_topic_set_peer_id(group_topic, peer_id);
tox_event_group_topic_set_topic(group_topic, topic, topic_length);
tox_event_group_topic_set_topic(group_topic, state->mem, topic, topic_length);
}

12
toxcore/events/group_topic_lock.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -107,7 +107,7 @@ Tox_Event_Group_Topic_Lock *tox_event_group_topic_lock_new(const Memory *mem)
void tox_event_group_topic_lock_free(Tox_Event_Group_Topic_Lock *group_topic_lock, const Memory *mem)
{
if (group_topic_lock != nullptr) {
tox_event_group_topic_lock_destruct(group_topic_lock, mem);
tox_event_group_topic_lock_destruct((Tox_Event_Group_Topic_Lock * _Nonnull)group_topic_lock, mem);
}
mem_delete(mem, group_topic_lock);
}
@@ -145,11 +145,8 @@ bool tox_event_group_topic_lock_unpack(
return tox_event_group_topic_lock_unpack_into(*event, bu);
}
static Tox_Event_Group_Topic_Lock *tox_event_group_topic_lock_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Topic_Lock *tox_event_group_topic_lock_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -174,7 +171,8 @@ void tox_events_handle_group_topic_lock(
Tox *tox, uint32_t group_number, Tox_Group_Topic_Lock topic_lock,
void *user_data)
{
Tox_Event_Group_Topic_Lock *group_topic_lock = tox_event_group_topic_lock_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Topic_Lock *group_topic_lock = tox_event_group_topic_lock_alloc(state);
if (group_topic_lock == nullptr) {
return;

12
toxcore/events/group_voice_state.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -107,7 +107,7 @@ Tox_Event_Group_Voice_State *tox_event_group_voice_state_new(const Memory *mem)
void tox_event_group_voice_state_free(Tox_Event_Group_Voice_State *group_voice_state, const Memory *mem)
{
if (group_voice_state != nullptr) {
tox_event_group_voice_state_destruct(group_voice_state, mem);
tox_event_group_voice_state_destruct((Tox_Event_Group_Voice_State * _Nonnull)group_voice_state, mem);
}
mem_delete(mem, group_voice_state);
}
@@ -145,11 +145,8 @@ bool tox_event_group_voice_state_unpack(
return tox_event_group_voice_state_unpack_into(*event, bu);
}
static Tox_Event_Group_Voice_State *tox_event_group_voice_state_alloc(void *_Nonnull user_data)
static Tox_Event_Group_Voice_State *tox_event_group_voice_state_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -174,7 +171,8 @@ void tox_events_handle_group_voice_state(
Tox *tox, uint32_t group_number, Tox_Group_Voice_State voice_state,
void *user_data)
{
Tox_Event_Group_Voice_State *group_voice_state = tox_event_group_voice_state_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Group_Voice_State *group_voice_state = tox_event_group_voice_state_alloc(state);
if (group_voice_state == nullptr) {
return;

12
toxcore/events/self_connection_status.c
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2023-2025 The TokTok team.
* Copyright © 2023-2026 The TokTok team.
*/
#include "events_alloc.h"
@@ -88,7 +88,7 @@ Tox_Event_Self_Connection_Status *tox_event_self_connection_status_new(const Mem
void tox_event_self_connection_status_free(Tox_Event_Self_Connection_Status *self_connection_status, const Memory *mem)
{
if (self_connection_status != nullptr) {
tox_event_self_connection_status_destruct(self_connection_status, mem);
tox_event_self_connection_status_destruct((Tox_Event_Self_Connection_Status * _Nonnull)self_connection_status, mem);
}
mem_delete(mem, self_connection_status);
}
@@ -126,11 +126,8 @@ bool tox_event_self_connection_status_unpack(
return tox_event_self_connection_status_unpack_into(*event, bu);
}
static Tox_Event_Self_Connection_Status *tox_event_self_connection_status_alloc(void *_Nonnull user_data)
static Tox_Event_Self_Connection_Status *tox_event_self_connection_status_alloc(Tox_Events_State *_Nonnull state)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
@@ -155,7 +152,8 @@ void tox_events_handle_self_connection_status(
Tox *tox, Tox_Connection connection_status,
void *user_data)
{
Tox_Event_Self_Connection_Status *self_connection_status = tox_event_self_connection_status_alloc(user_data);
Tox_Events_State *state = tox_events_alloc(user_data);
Tox_Event_Self_Connection_Status *self_connection_status = tox_event_self_connection_status_alloc(state);
if (self_connection_status == nullptr) {
return;