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 c9cdae001..9ed2fa80d

Browse Source 
9ed2fa80d fix(toxav): remove extra copy of video frame on encode
de30cf3ad docs: Add new file kinds, that should be useful to all clients.
d5b5e879d fix(DHT): Correct node skipping logic timed out nodes.
30e71fe97 refactor: Generate event dispatch functions and add tox_events_dispatch.
8fdbb0b50 style: Format parameter lists in event handlers.
d00dee12b refactor: Add warning logs when losing chat invites.
b144e8db1 feat: Add a way to look up a file number by ID.
849281ea0 feat: Add a way to fetch groups by chat ID.
a2c177396 refactor: Harden event system and improve type safety.
8f5caa656 refactor: Add MessagePack string support to bin_pack.
34e8d5ad5 chore: Add GitHub CodeQL workflow and local Docker runner.
f7b068010 refactor: Add nullability annotations to event headers.
788abe651 refactor(toxav): Use system allocator for mutexes.
2e4b423eb refactor: Use specific typedefs for public API arrays.
2baf34775 docs(toxav): update idle iteration interval see 679444751876fa3882a717772918ebdc8f083354
2f87ac67b feat: Add Event Loop abstraction (Ev).
f8dfc38d8 test: Fix data race in ToxScenario virtual_clock.
38313921e test(TCP): Add regression test for TCP priority queue integrity.
f94a50d9a refactor(toxav): Replace mutable_mutex with dynamically allocated mutex.
ad054511e refactor: Internalize DHT structs and add debug helpers.
8b467cc96 fix: Prevent potential integer overflow in group chat handshake.
4962bdbb8 test: Improve TCP simulation and add tests
5f0227093 refactor: Allow nullable data in group chat handlers.
e97b18ea9 chore: Improve Windows Docker support.
b14943bbd refactor: Move Logger out of Messenger into Tox.
dd3136250 cleanup: Apply nullability qualifiers to C++ codebase.
1849f70fc refactor: Extract low-level networking code to net and os_network.
8fec75421 refactor: Delete tox_random, align on rng and os_random.
a03ae8051 refactor: Delete tox_memory, align on mem and os_memory.
4c88fed2c refactor: Use `std::` prefixes more consistently in C++ code.
72452f2ae test: Add some more tests for onion and shared key cache.
d5a51b09a cleanup: Use tox_attributes.h in tox_private.h and install it.
b6f5b9fc5 test: Add some benchmarks for various high level things.
8a8d02785 test(support): Introduce threaded Tox runner and simulation barrier
d68d1d095 perf(toxav): optimize audio and video intermediate buffers by keeping them around
REVERT: c9cdae001 fix(toxav): remove extra copy of video frame on encode

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: 9ed2fa80d582c714d6bdde6a7648220a92cddff8
This commit is contained in:
Green Sky
2026-02-01 14:26:52 +01:00
parent 565efa4f39
commit 9b36dd9d99
274 changed files with 11891 additions and 4292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
toxcore/events/conference_connected.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -86,7 +87,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((Tox_Event_Conference_Connected * _Nonnull)conference_connected, mem);
tox_event_conference_connected_destruct(conference_connected, mem);
}
mem_delete(mem, conference_connected);
}
@@ -147,7 +148,8 @@ static Tox_Event_Conference_Connected *tox_event_conference_connected_alloc(Tox_
*****************************************************/
void tox_events_handle_conference_connected(
Tox *tox, uint32_t conference_number,
Tox *tox,
uint32_t conference_number,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -159,3 +161,14 @@ void tox_events_handle_conference_connected(
tox_event_conference_connected_set_conference_number(conference_connected, conference_number);
}
void tox_events_handle_conference_connected_dispatch(Tox *tox, const Tox_Event_Conference_Connected *event, void *user_data)
{
if (tox->conference_connected_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->conference_connected_callback(tox, event->conference_number, user_data);
tox_lock(tox);
}

31
toxcore/events/conference_invite.c
View File

@@ -16,6 +16,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -27,7 +28,7 @@
struct Tox_Event_Conference_Invite {
uint32_t friend_number;
Tox_Conference_Type type;
uint8_t *cookie;
uint8_t *_Nullable cookie;
uint32_t cookie_length;
};
@@ -68,6 +69,12 @@ static bool tox_event_conference_invite_set_cookie(Tox_Event_Conference_Invite *
return true;
}
if (cookie_length == 0) {
conference_invite->cookie = nullptr;
conference_invite->cookie_length = 0;
return true;
}
uint8_t *cookie_copy = (uint8_t *)mem_balloc(mem, cookie_length);
if (cookie_copy == nullptr) {
@@ -149,7 +156,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((Tox_Event_Conference_Invite * _Nonnull)conference_invite, mem);
tox_event_conference_invite_destruct(conference_invite, mem);
}
mem_delete(mem, conference_invite);
}
@@ -210,7 +217,10 @@ static Tox_Event_Conference_Invite *tox_event_conference_invite_alloc(Tox_Events
*****************************************************/
void tox_events_handle_conference_invite(
Tox *tox, uint32_t friend_number, Tox_Conference_Type type, const uint8_t *cookie, size_t length,
Tox *tox,
uint32_t friend_number,
Tox_Conference_Type type,
const uint8_t *cookie, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -222,5 +232,18 @@ 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, state->mem, cookie, length);
if (!tox_event_conference_invite_set_cookie(conference_invite, state->mem, cookie, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_conference_invite_dispatch(Tox *tox, const Tox_Event_Conference_Invite *event, void *user_data)
{
if (tox->conference_invite_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->conference_invite_callback(tox, event->friend_number, event->type, event->cookie, event->cookie_length, user_data);
tox_lock(tox);
}

32
toxcore/events/conference_message.c
View File

@@ -16,6 +16,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -28,7 +29,7 @@ struct Tox_Event_Conference_Message {
uint32_t conference_number;
uint32_t peer_number;
Tox_Message_Type type;
uint8_t *message;
uint8_t *_Nullable message;
uint32_t message_length;
};
@@ -80,6 +81,12 @@ static bool tox_event_conference_message_set_message(Tox_Event_Conference_Messag
return true;
}
if (message_length == 0) {
conference_message->message = nullptr;
conference_message->message_length = 0;
return true;
}
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
@@ -163,7 +170,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((Tox_Event_Conference_Message * _Nonnull)conference_message, mem);
tox_event_conference_message_destruct(conference_message, mem);
}
mem_delete(mem, conference_message);
}
@@ -224,7 +231,11 @@ static Tox_Event_Conference_Message *tox_event_conference_message_alloc(Tox_Even
*****************************************************/
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,
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_Events_State *state = tox_events_alloc(user_data);
@@ -237,5 +248,18 @@ 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, state->mem, message, length);
if (!tox_event_conference_message_set_message(conference_message, state->mem, message, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_conference_message_dispatch(Tox *tox, const Tox_Event_Conference_Message *event, void *user_data)
{
if (tox->conference_message_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->conference_message_callback(tox, event->conference_number, event->peer_number, event->type, event->message, event->message_length, user_data);
tox_lock(tox);
}

17
toxcore/events/conference_peer_list_changed.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -86,7 +87,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((Tox_Event_Conference_Peer_List_Changed * _Nonnull)conference_peer_list_changed, mem);
tox_event_conference_peer_list_changed_destruct(conference_peer_list_changed, mem);
}
mem_delete(mem, conference_peer_list_changed);
}
@@ -147,7 +148,8 @@ static Tox_Event_Conference_Peer_List_Changed *tox_event_conference_peer_list_ch
*****************************************************/
void tox_events_handle_conference_peer_list_changed(
Tox *tox, uint32_t conference_number,
Tox *tox,
uint32_t conference_number,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -159,3 +161,14 @@ void tox_events_handle_conference_peer_list_changed(
tox_event_conference_peer_list_changed_set_conference_number(conference_peer_list_changed, conference_number);
}
void tox_events_handle_conference_peer_list_changed_dispatch(Tox *tox, const Tox_Event_Conference_Peer_List_Changed *event, void *user_data)
{
if (tox->conference_peer_list_changed_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->conference_peer_list_changed_callback(tox, event->conference_number, user_data);
tox_lock(tox);
}

31
toxcore/events/conference_peer_name.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -25,7 +26,7 @@
struct Tox_Event_Conference_Peer_Name {
uint32_t conference_number;
uint32_t peer_number;
uint8_t *name;
uint8_t *_Nullable name;
uint32_t name_length;
};
@@ -66,6 +67,12 @@ static bool tox_event_conference_peer_name_set_name(Tox_Event_Conference_Peer_Na
return true;
}
if (name_length == 0) {
conference_peer_name->name = nullptr;
conference_peer_name->name_length = 0;
return true;
}
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
@@ -147,7 +154,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((Tox_Event_Conference_Peer_Name * _Nonnull)conference_peer_name, mem);
tox_event_conference_peer_name_destruct(conference_peer_name, mem);
}
mem_delete(mem, conference_peer_name);
}
@@ -208,7 +215,10 @@ static Tox_Event_Conference_Peer_Name *tox_event_conference_peer_name_alloc(Tox_
*****************************************************/
void tox_events_handle_conference_peer_name(
Tox *tox, uint32_t conference_number, uint32_t peer_number, const uint8_t *name, size_t length,
Tox *tox,
uint32_t conference_number,
uint32_t peer_number,
const uint8_t *name, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -220,5 +230,18 @@ 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, state->mem, name, length);
if (!tox_event_conference_peer_name_set_name(conference_peer_name, state->mem, name, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_conference_peer_name_dispatch(Tox *tox, const Tox_Event_Conference_Peer_Name *event, void *user_data)
{
if (tox->conference_peer_name_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->conference_peer_name_callback(tox, event->conference_number, event->peer_number, event->name, event->name_length, user_data);
tox_lock(tox);
}

31
toxcore/events/conference_title.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -25,7 +26,7 @@
struct Tox_Event_Conference_Title {
uint32_t conference_number;
uint32_t peer_number;
uint8_t *title;
uint8_t *_Nullable title;
uint32_t title_length;
};
@@ -66,6 +67,12 @@ static bool tox_event_conference_title_set_title(Tox_Event_Conference_Title *_No
return true;
}
if (title_length == 0) {
conference_title->title = nullptr;
conference_title->title_length = 0;
return true;
}
uint8_t *title_copy = (uint8_t *)mem_balloc(mem, title_length);
if (title_copy == nullptr) {
@@ -147,7 +154,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((Tox_Event_Conference_Title * _Nonnull)conference_title, mem);
tox_event_conference_title_destruct(conference_title, mem);
}
mem_delete(mem, conference_title);
}
@@ -208,7 +215,10 @@ static Tox_Event_Conference_Title *tox_event_conference_title_alloc(Tox_Events_S
*****************************************************/
void tox_events_handle_conference_title(
Tox *tox, uint32_t conference_number, uint32_t peer_number, const uint8_t *title, size_t length,
Tox *tox,
uint32_t conference_number,
uint32_t peer_number,
const uint8_t *title, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -220,5 +230,18 @@ 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, state->mem, title, length);
if (!tox_event_conference_title_set_title(conference_title, state->mem, title, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_conference_title_dispatch(Tox *tox, const Tox_Event_Conference_Title *event, void *user_data)
{
if (tox->conference_title_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->conference_title_callback(tox, event->conference_number, event->peer_number, event->title, event->title_length, user_data);
tox_lock(tox);
}

39
toxcore/events/dht_nodes_response.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,7 +25,7 @@
struct Tox_Event_Dht_Nodes_Response {
uint8_t public_key[TOX_PUBLIC_KEY_SIZE];
uint8_t *ip;
char *_Nullable ip;
uint32_t ip_length;
uint16_t port;
};
@@ -42,7 +43,7 @@ const uint8_t *tox_event_dht_nodes_response_get_public_key(const Tox_Event_Dht_N
}
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)
const Memory *_Nonnull mem, const char *_Nullable ip, uint32_t ip_length)
{
assert(dht_nodes_response != nullptr);
if (dht_nodes_response->ip != nullptr) {
@@ -56,7 +57,11 @@ static bool tox_event_dht_nodes_response_set_ip(Tox_Event_Dht_Nodes_Response *_N
return true;
}
uint8_t *ip_copy = (uint8_t *)mem_balloc(mem, ip_length + 1);
if (ip_length == UINT32_MAX) {
return false;
}
char *ip_copy = (char *)mem_balloc(mem, ip_length + 1);
if (ip_copy == nullptr) {
return false;
@@ -73,7 +78,7 @@ uint32_t tox_event_dht_nodes_response_get_ip_length(const Tox_Event_Dht_Nodes_Re
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)
const char *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;
@@ -108,7 +113,7 @@ bool tox_event_dht_nodes_response_pack(
{
return bin_pack_array(bp, 3)
&& bin_pack_bin(bp, event->public_key, TOX_PUBLIC_KEY_SIZE)
&& bin_pack_bin(bp, event->ip, event->ip_length)
&& bin_pack_str(bp, event->ip, event->ip_length)
&& bin_pack_u16(bp, event->port);
}
@@ -120,7 +125,7 @@ static bool tox_event_dht_nodes_response_unpack_into(Tox_Event_Dht_Nodes_Respons
}
return bin_unpack_bin_fixed(bu, event->public_key, TOX_PUBLIC_KEY_SIZE)
&& bin_unpack_bin(bu, &event->ip, &event->ip_length)
&& bin_unpack_str(bu, &event->ip, &event->ip_length)
&& bin_unpack_u16(bu, &event->port);
}
@@ -151,7 +156,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((Tox_Event_Dht_Nodes_Response * _Nonnull)dht_nodes_response, mem);
tox_event_dht_nodes_response_destruct(dht_nodes_response, mem);
}
mem_delete(mem, dht_nodes_response);
}
@@ -212,7 +217,10 @@ static Tox_Event_Dht_Nodes_Response *tox_event_dht_nodes_response_alloc(Tox_Even
*****************************************************/
void tox_events_handle_dht_nodes_response(
Tox *tox, const uint8_t *public_key, const char *ip, uint32_t ip_length, uint16_t port,
Tox *tox,
const uint8_t *public_key,
const char *ip, uint32_t ip_length,
uint16_t port,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -223,6 +231,19 @@ void tox_events_handle_dht_nodes_response(
}
tox_event_dht_nodes_response_set_public_key(dht_nodes_response, public_key);
tox_event_dht_nodes_response_set_ip(dht_nodes_response, state->mem, (const uint8_t *)ip, ip_length);
if (!tox_event_dht_nodes_response_set_ip(dht_nodes_response, state->mem, ip, ip_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
tox_event_dht_nodes_response_set_port(dht_nodes_response, port);
}
void tox_events_handle_dht_nodes_response_dispatch(Tox *tox, const Tox_Event_Dht_Nodes_Response *event, void *user_data)
{
if (tox->dht_nodes_response_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->dht_nodes_response_callback(tox, event->public_key, (const char *)event->ip, event->ip_length, event->port, user_data);
tox_lock(tox);
}

8
toxcore/events/events_alloc.c
View File

@@ -61,7 +61,13 @@ bool tox_events_add(Tox_Events *events, const Tox_Event *event)
}
if (events->events_size == events->events_capacity) {
const uint32_t new_events_capacity = events->events_capacity * 2 + 1;
const uint64_t new_events_capacity_64 = (uint64_t)events->events_capacity * 2 + 1;
if (new_events_capacity_64 > UINT32_MAX) {
return false;
}
const uint32_t new_events_capacity = (uint32_t)new_events_capacity_64;
Tox_Event *new_events = (Tox_Event *)mem_vrealloc(
events->mem, events->events, new_events_capacity, sizeof(Tox_Event));

13
toxcore/events/events_alloc.h
View File

@@ -5,6 +5,9 @@
#ifndef C_TOXCORE_TOXCORE_EVENTS_EVENTS_ALLOC_H
#define C_TOXCORE_TOXCORE_EVENTS_EVENTS_ALLOC_H
#include <stdbool.h>
#include <stdint.h>
#include "../attributes.h"
#include "../tox.h"
#include "../tox_events.h"
@@ -14,20 +17,20 @@
extern "C" {
#endif
struct Tox_Memory;
struct Memory;
struct Tox_Events {
Tox_Event *_Nonnull events;
Tox_Event *_Nullable events;
uint32_t events_size;
uint32_t events_capacity;
const struct Tox_Memory *_Nonnull mem;
const struct Memory *_Nonnull mem;
};
typedef struct Tox_Events_State {
Tox_Err_Events_Iterate error;
const struct Tox_Memory *_Nonnull mem;
Tox_Events *_Nonnull events;
const struct Memory *_Nonnull mem;
Tox_Events *_Nullable events;
} Tox_Events_State;
tox_conference_connected_cb tox_events_handle_conference_connected;

20
toxcore/events/file_chunk_request.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -133,7 +134,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((Tox_Event_File_Chunk_Request * _Nonnull)file_chunk_request, mem);
tox_event_file_chunk_request_destruct(file_chunk_request, mem);
}
mem_delete(mem, file_chunk_request);
}
@@ -194,7 +195,11 @@ static Tox_Event_File_Chunk_Request *tox_event_file_chunk_request_alloc(Tox_Even
*****************************************************/
void tox_events_handle_file_chunk_request(
Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position, size_t length,
Tox *tox,
uint32_t friend_number,
uint32_t file_number,
uint64_t position,
size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -209,3 +214,14 @@ void tox_events_handle_file_chunk_request(
tox_event_file_chunk_request_set_position(file_chunk_request, position);
tox_event_file_chunk_request_set_length(file_chunk_request, length);
}
void tox_events_handle_file_chunk_request_dispatch(Tox *tox, const Tox_Event_File_Chunk_Request *event, void *user_data)
{
if (tox->file_chunk_request_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->file_chunk_request_callback(tox, event->friend_number, event->file_number, event->position, event->length, user_data);
tox_lock(tox);
}

33
toxcore/events/file_recv.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -27,7 +28,7 @@ struct Tox_Event_File_Recv {
uint32_t file_number;
uint32_t kind;
uint64_t file_size;
uint8_t *filename;
uint8_t *_Nullable filename;
uint32_t filename_length;
};
@@ -90,6 +91,12 @@ static bool tox_event_file_recv_set_filename(Tox_Event_File_Recv *_Nonnull file_
return true;
}
if (filename_length == 0) {
file_recv->filename = nullptr;
file_recv->filename_length = 0;
return true;
}
uint8_t *filename_copy = (uint8_t *)mem_balloc(mem, filename_length);
if (filename_copy == nullptr) {
@@ -175,7 +182,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((Tox_Event_File_Recv * _Nonnull)file_recv, mem);
tox_event_file_recv_destruct(file_recv, mem);
}
mem_delete(mem, file_recv);
}
@@ -236,7 +243,12 @@ static Tox_Event_File_Recv *tox_event_file_recv_alloc(Tox_Events_State *_Nonnull
*****************************************************/
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,
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_Events_State *state = tox_events_alloc(user_data);
@@ -250,5 +262,18 @@ 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, state->mem, filename, filename_length);
if (!tox_event_file_recv_set_filename(file_recv, state->mem, filename, filename_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_file_recv_dispatch(Tox *tox, const Tox_Event_File_Recv *event, void *user_data)
{
if (tox->file_recv_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->file_recv_callback(tox, event->friend_number, event->file_number, event->kind, event->file_size, event->filename, event->filename_length, user_data);
tox_lock(tox);
}

32
toxcore/events/file_recv_chunk.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -26,7 +27,7 @@ struct Tox_Event_File_Recv_Chunk {
uint32_t friend_number;
uint32_t file_number;
uint64_t position;
uint8_t *data;
uint8_t *_Nullable data;
uint32_t data_length;
};
@@ -78,6 +79,12 @@ static bool tox_event_file_recv_chunk_set_data(Tox_Event_File_Recv_Chunk *_Nonnu
return true;
}
if (data_length == 0) {
file_recv_chunk->data = nullptr;
file_recv_chunk->data_length = 0;
return true;
}
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
@@ -161,7 +168,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((Tox_Event_File_Recv_Chunk * _Nonnull)file_recv_chunk, mem);
tox_event_file_recv_chunk_destruct(file_recv_chunk, mem);
}
mem_delete(mem, file_recv_chunk);
}
@@ -222,7 +229,11 @@ static Tox_Event_File_Recv_Chunk *tox_event_file_recv_chunk_alloc(Tox_Events_Sta
*****************************************************/
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,
Tox *tox,
uint32_t friend_number,
uint32_t file_number,
uint64_t position,
const uint8_t *data, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -235,5 +246,18 @@ 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, state->mem, data, length);
if (!tox_event_file_recv_chunk_set_data(file_recv_chunk, state->mem, data, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_file_recv_chunk_dispatch(Tox *tox, const Tox_Event_File_Recv_Chunk *event, void *user_data)
{
if (tox->file_recv_chunk_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->file_recv_chunk_callback(tox, event->friend_number, event->file_number, event->position, event->data, event->data_length, user_data);
tox_lock(tox);
}

19
toxcore/events/file_recv_control.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -121,7 +122,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((Tox_Event_File_Recv_Control * _Nonnull)file_recv_control, mem);
tox_event_file_recv_control_destruct(file_recv_control, mem);
}
mem_delete(mem, file_recv_control);
}
@@ -182,7 +183,10 @@ static Tox_Event_File_Recv_Control *tox_event_file_recv_control_alloc(Tox_Events
*****************************************************/
void tox_events_handle_file_recv_control(
Tox *tox, uint32_t friend_number, uint32_t file_number, Tox_File_Control control,
Tox *tox,
uint32_t friend_number,
uint32_t file_number,
Tox_File_Control control,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -196,3 +200,14 @@ void tox_events_handle_file_recv_control(
tox_event_file_recv_control_set_file_number(file_recv_control, file_number);
tox_event_file_recv_control_set_control(file_recv_control, control);
}
void tox_events_handle_file_recv_control_dispatch(Tox *tox, const Tox_Event_File_Recv_Control *event, void *user_data)
{
if (tox->file_recv_control_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->file_recv_control_callback(tox, event->friend_number, event->file_number, event->control, user_data);
tox_lock(tox);
}

18
toxcore/events/friend_connection_status.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -107,7 +108,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((Tox_Event_Friend_Connection_Status * _Nonnull)friend_connection_status, mem);
tox_event_friend_connection_status_destruct(friend_connection_status, mem);
}
mem_delete(mem, friend_connection_status);
}
@@ -168,7 +169,9 @@ static Tox_Event_Friend_Connection_Status *tox_event_friend_connection_status_al
*****************************************************/
void tox_events_handle_friend_connection_status(
Tox *tox, uint32_t friend_number, Tox_Connection connection_status,
Tox *tox,
uint32_t friend_number,
Tox_Connection connection_status,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -181,3 +184,14 @@ void tox_events_handle_friend_connection_status(
tox_event_friend_connection_status_set_friend_number(friend_connection_status, friend_number);
tox_event_friend_connection_status_set_connection_status(friend_connection_status, connection_status);
}
void tox_events_handle_friend_connection_status_dispatch(Tox *tox, const Tox_Event_Friend_Connection_Status *event, void *user_data)
{
if (tox->friend_connection_status_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_connection_status_callback(tox, event->friend_number, event->connection_status, user_data);
tox_lock(tox);
}

30
toxcore/events/friend_lossless_packet.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,7 +25,7 @@
struct Tox_Event_Friend_Lossless_Packet {
uint32_t friend_number;
uint8_t *data;
uint8_t *_Nullable data;
uint32_t data_length;
};
@@ -54,6 +55,12 @@ static bool tox_event_friend_lossless_packet_set_data(Tox_Event_Friend_Lossless_
return true;
}
if (data_length == 0) {
friend_lossless_packet->data = nullptr;
friend_lossless_packet->data_length = 0;
return true;
}
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
@@ -133,7 +140,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((Tox_Event_Friend_Lossless_Packet * _Nonnull)friend_lossless_packet, mem);
tox_event_friend_lossless_packet_destruct(friend_lossless_packet, mem);
}
mem_delete(mem, friend_lossless_packet);
}
@@ -194,7 +201,9 @@ static Tox_Event_Friend_Lossless_Packet *tox_event_friend_lossless_packet_alloc(
*****************************************************/
void tox_events_handle_friend_lossless_packet(
Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
Tox *tox,
uint32_t friend_number,
const uint8_t *data, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -205,5 +214,18 @@ void tox_events_handle_friend_lossless_packet(
}
tox_event_friend_lossless_packet_set_friend_number(friend_lossless_packet, friend_number);
tox_event_friend_lossless_packet_set_data(friend_lossless_packet, state->mem, data, length);
if (!tox_event_friend_lossless_packet_set_data(friend_lossless_packet, state->mem, data, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_friend_lossless_packet_dispatch(Tox *tox, const Tox_Event_Friend_Lossless_Packet *event, void *user_data)
{
if (event->data_length == 0 || tox->friend_lossless_packet_callback_per_pktid[event->data[0]] == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_lossless_packet_callback_per_pktid[event->data[0]](tox, event->friend_number, event->data, event->data_length, user_data);
tox_lock(tox);
}

30
toxcore/events/friend_lossy_packet.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,7 +25,7 @@
struct Tox_Event_Friend_Lossy_Packet {
uint32_t friend_number;
uint8_t *data;
uint8_t *_Nullable data;
uint32_t data_length;
};
@@ -54,6 +55,12 @@ static bool tox_event_friend_lossy_packet_set_data(Tox_Event_Friend_Lossy_Packet
return true;
}
if (data_length == 0) {
friend_lossy_packet->data = nullptr;
friend_lossy_packet->data_length = 0;
return true;
}
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
@@ -133,7 +140,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((Tox_Event_Friend_Lossy_Packet * _Nonnull)friend_lossy_packet, mem);
tox_event_friend_lossy_packet_destruct(friend_lossy_packet, mem);
}
mem_delete(mem, friend_lossy_packet);
}
@@ -194,7 +201,9 @@ static Tox_Event_Friend_Lossy_Packet *tox_event_friend_lossy_packet_alloc(Tox_Ev
*****************************************************/
void tox_events_handle_friend_lossy_packet(
Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
Tox *tox,
uint32_t friend_number,
const uint8_t *data, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -205,5 +214,18 @@ void tox_events_handle_friend_lossy_packet(
}
tox_event_friend_lossy_packet_set_friend_number(friend_lossy_packet, friend_number);
tox_event_friend_lossy_packet_set_data(friend_lossy_packet, state->mem, data, length);
if (!tox_event_friend_lossy_packet_set_data(friend_lossy_packet, state->mem, data, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_friend_lossy_packet_dispatch(Tox *tox, const Tox_Event_Friend_Lossy_Packet *event, void *user_data)
{
if (event->data_length == 0 || tox->friend_lossy_packet_callback_per_pktid[event->data[0]] == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_lossy_packet_callback_per_pktid[event->data[0]](tox, event->friend_number, event->data, event->data_length, user_data);
tox_lock(tox);
}

31
toxcore/events/friend_message.c
View File

@@ -16,6 +16,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -27,7 +28,7 @@
struct Tox_Event_Friend_Message {
uint32_t friend_number;
Tox_Message_Type type;
uint8_t *message;
uint8_t *_Nullable message;
uint32_t message_length;
};
@@ -68,6 +69,12 @@ static bool tox_event_friend_message_set_message(Tox_Event_Friend_Message *_Nonn
return true;
}
if (message_length == 0) {
friend_message->message = nullptr;
friend_message->message_length = 0;
return true;
}
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
@@ -149,7 +156,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((Tox_Event_Friend_Message * _Nonnull)friend_message, mem);
tox_event_friend_message_destruct(friend_message, mem);
}
mem_delete(mem, friend_message);
}
@@ -210,7 +217,10 @@ static Tox_Event_Friend_Message *tox_event_friend_message_alloc(Tox_Events_State
*****************************************************/
void tox_events_handle_friend_message(
Tox *tox, uint32_t friend_number, Tox_Message_Type type, const uint8_t *message, size_t length,
Tox *tox,
uint32_t friend_number,
Tox_Message_Type type,
const uint8_t *message, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -222,5 +232,18 @@ 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, state->mem, message, length);
if (!tox_event_friend_message_set_message(friend_message, state->mem, message, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_friend_message_dispatch(Tox *tox, const Tox_Event_Friend_Message *event, void *user_data)
{
if (tox->friend_message_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_message_callback(tox, event->friend_number, event->type, event->message, event->message_length, user_data);
tox_lock(tox);
}

30
toxcore/events/friend_name.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,7 +25,7 @@
struct Tox_Event_Friend_Name {
uint32_t friend_number;
uint8_t *name;
uint8_t *_Nullable name;
uint32_t name_length;
};
@@ -54,6 +55,12 @@ static bool tox_event_friend_name_set_name(Tox_Event_Friend_Name *_Nonnull frien
return true;
}
if (name_length == 0) {
friend_name->name = nullptr;
friend_name->name_length = 0;
return true;
}
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
@@ -133,7 +140,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((Tox_Event_Friend_Name * _Nonnull)friend_name, mem);
tox_event_friend_name_destruct(friend_name, mem);
}
mem_delete(mem, friend_name);
}
@@ -194,7 +201,9 @@ static Tox_Event_Friend_Name *tox_event_friend_name_alloc(Tox_Events_State *_Non
*****************************************************/
void tox_events_handle_friend_name(
Tox *tox, uint32_t friend_number, const uint8_t *name, size_t length,
Tox *tox,
uint32_t friend_number,
const uint8_t *name, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -205,5 +214,18 @@ void tox_events_handle_friend_name(
}
tox_event_friend_name_set_friend_number(friend_name, friend_number);
tox_event_friend_name_set_name(friend_name, state->mem, name, length);
if (!tox_event_friend_name_set_name(friend_name, state->mem, name, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_friend_name_dispatch(Tox *tox, const Tox_Event_Friend_Name *event, void *user_data)
{
if (tox->friend_name_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_name_callback(tox, event->friend_number, event->name, event->name_length, user_data);
tox_lock(tox);
}

18
toxcore/events/friend_read_receipt.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -105,7 +106,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((Tox_Event_Friend_Read_Receipt * _Nonnull)friend_read_receipt, mem);
tox_event_friend_read_receipt_destruct(friend_read_receipt, mem);
}
mem_delete(mem, friend_read_receipt);
}
@@ -166,7 +167,9 @@ static Tox_Event_Friend_Read_Receipt *tox_event_friend_read_receipt_alloc(Tox_Ev
*****************************************************/
void tox_events_handle_friend_read_receipt(
Tox *tox, uint32_t friend_number, uint32_t message_id,
Tox *tox,
uint32_t friend_number,
uint32_t message_id,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -179,3 +182,14 @@ void tox_events_handle_friend_read_receipt(
tox_event_friend_read_receipt_set_friend_number(friend_read_receipt, friend_number);
tox_event_friend_read_receipt_set_message_id(friend_read_receipt, message_id);
}
void tox_events_handle_friend_read_receipt_dispatch(Tox *tox, const Tox_Event_Friend_Read_Receipt *event, void *user_data)
{
if (tox->friend_read_receipt_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_read_receipt_callback(tox, event->friend_number, event->message_id, user_data);
tox_lock(tox);
}

30
toxcore/events/friend_request.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,7 +25,7 @@
struct Tox_Event_Friend_Request {
uint8_t public_key[TOX_PUBLIC_KEY_SIZE];
uint8_t *message;
uint8_t *_Nullable message;
uint32_t message_length;
};
@@ -55,6 +56,12 @@ static bool tox_event_friend_request_set_message(Tox_Event_Friend_Request *_Nonn
return true;
}
if (message_length == 0) {
friend_request->message = nullptr;
friend_request->message_length = 0;
return true;
}
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
@@ -136,7 +143,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((Tox_Event_Friend_Request * _Nonnull)friend_request, mem);
tox_event_friend_request_destruct(friend_request, mem);
}
mem_delete(mem, friend_request);
}
@@ -197,7 +204,9 @@ static Tox_Event_Friend_Request *tox_event_friend_request_alloc(Tox_Events_State
*****************************************************/
void tox_events_handle_friend_request(
Tox *tox, const uint8_t *public_key, const uint8_t *message, size_t length,
Tox *tox,
const uint8_t *public_key,
const uint8_t *message, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -208,5 +217,18 @@ void tox_events_handle_friend_request(
}
tox_event_friend_request_set_public_key(friend_request, public_key);
tox_event_friend_request_set_message(friend_request, state->mem, message, length);
if (!tox_event_friend_request_set_message(friend_request, state->mem, message, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_friend_request_dispatch(Tox *tox, const Tox_Event_Friend_Request *event, void *user_data)
{
if (tox->friend_request_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_request_callback(tox, event->public_key, event->message, event->message_length, user_data);
tox_lock(tox);
}

18
toxcore/events/friend_status.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -107,7 +108,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((Tox_Event_Friend_Status * _Nonnull)friend_status, mem);
tox_event_friend_status_destruct(friend_status, mem);
}
mem_delete(mem, friend_status);
}
@@ -168,7 +169,9 @@ static Tox_Event_Friend_Status *tox_event_friend_status_alloc(Tox_Events_State *
*****************************************************/
void tox_events_handle_friend_status(
Tox *tox, uint32_t friend_number, Tox_User_Status status,
Tox *tox,
uint32_t friend_number,
Tox_User_Status status,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -181,3 +184,14 @@ void tox_events_handle_friend_status(
tox_event_friend_status_set_friend_number(friend_status, friend_number);
tox_event_friend_status_set_status(friend_status, status);
}
void tox_events_handle_friend_status_dispatch(Tox *tox, const Tox_Event_Friend_Status *event, void *user_data)
{
if (tox->friend_status_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_status_callback(tox, event->friend_number, event->status, user_data);
tox_lock(tox);
}

30
toxcore/events/friend_status_message.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,7 +25,7 @@
struct Tox_Event_Friend_Status_Message {
uint32_t friend_number;
uint8_t *message;
uint8_t *_Nullable message;
uint32_t message_length;
};
@@ -54,6 +55,12 @@ static bool tox_event_friend_status_message_set_message(Tox_Event_Friend_Status_
return true;
}
if (message_length == 0) {
friend_status_message->message = nullptr;
friend_status_message->message_length = 0;
return true;
}
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
@@ -133,7 +140,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((Tox_Event_Friend_Status_Message * _Nonnull)friend_status_message, mem);
tox_event_friend_status_message_destruct(friend_status_message, mem);
}
mem_delete(mem, friend_status_message);
}
@@ -194,7 +201,9 @@ static Tox_Event_Friend_Status_Message *tox_event_friend_status_message_alloc(To
*****************************************************/
void tox_events_handle_friend_status_message(
Tox *tox, uint32_t friend_number, const uint8_t *message, size_t length,
Tox *tox,
uint32_t friend_number,
const uint8_t *message, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -205,5 +214,18 @@ void tox_events_handle_friend_status_message(
}
tox_event_friend_status_message_set_friend_number(friend_status_message, friend_number);
tox_event_friend_status_message_set_message(friend_status_message, state->mem, message, length);
if (!tox_event_friend_status_message_set_message(friend_status_message, state->mem, message, length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_friend_status_message_dispatch(Tox *tox, const Tox_Event_Friend_Status_Message *event, void *user_data)
{
if (tox->friend_status_message_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_status_message_callback(tox, event->friend_number, event->message, event->message_length, user_data);
tox_lock(tox);
}

18
toxcore/events/friend_typing.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -105,7 +106,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((Tox_Event_Friend_Typing * _Nonnull)friend_typing, mem);
tox_event_friend_typing_destruct(friend_typing, mem);
}
mem_delete(mem, friend_typing);
}
@@ -166,7 +167,9 @@ static Tox_Event_Friend_Typing *tox_event_friend_typing_alloc(Tox_Events_State *
*****************************************************/
void tox_events_handle_friend_typing(
Tox *tox, uint32_t friend_number, bool typing,
Tox *tox,
uint32_t friend_number,
bool typing,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -179,3 +182,14 @@ void tox_events_handle_friend_typing(
tox_event_friend_typing_set_friend_number(friend_typing, friend_number);
tox_event_friend_typing_set_typing(friend_typing, typing);
}
void tox_events_handle_friend_typing_dispatch(Tox *tox, const Tox_Event_Friend_Typing *event, void *user_data)
{
if (tox->friend_typing_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->friend_typing_callback(tox, event->friend_number, event->typing, user_data);
tox_lock(tox);
}

31
toxcore/events/group_custom_packet.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -25,7 +26,7 @@
struct Tox_Event_Group_Custom_Packet {
uint32_t group_number;
uint32_t peer_id;
uint8_t *data;
uint8_t *_Nullable data;
uint32_t data_length;
};
@@ -66,6 +67,12 @@ static bool tox_event_group_custom_packet_set_data(Tox_Event_Group_Custom_Packet
return true;
}
if (data_length == 0) {
group_custom_packet->data = nullptr;
group_custom_packet->data_length = 0;
return true;
}
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
@@ -147,7 +154,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((Tox_Event_Group_Custom_Packet * _Nonnull)group_custom_packet, mem);
tox_event_group_custom_packet_destruct(group_custom_packet, mem);
}
mem_delete(mem, group_custom_packet);
}
@@ -208,7 +215,10 @@ static Tox_Event_Group_Custom_Packet *tox_event_group_custom_packet_alloc(Tox_Ev
*****************************************************/
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,
Tox *tox,
uint32_t group_number,
uint32_t peer_id,
const uint8_t *data, size_t data_length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -220,5 +230,18 @@ 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, state->mem, data, data_length);
if (!tox_event_group_custom_packet_set_data(group_custom_packet, state->mem, data, data_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_group_custom_packet_dispatch(Tox *tox, const Tox_Event_Group_Custom_Packet *event, void *user_data)
{
if (tox->group_custom_packet_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_custom_packet_callback(tox, event->group_number, event->peer_id, event->data, event->data_length, user_data);
tox_lock(tox);
}

31
toxcore/events/group_custom_private_packet.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -25,7 +26,7 @@
struct Tox_Event_Group_Custom_Private_Packet {
uint32_t group_number;
uint32_t peer_id;
uint8_t *data;
uint8_t *_Nullable data;
uint32_t data_length;
};
@@ -66,6 +67,12 @@ static bool tox_event_group_custom_private_packet_set_data(Tox_Event_Group_Custo
return true;
}
if (data_length == 0) {
group_custom_private_packet->data = nullptr;
group_custom_private_packet->data_length = 0;
return true;
}
uint8_t *data_copy = (uint8_t *)mem_balloc(mem, data_length);
if (data_copy == nullptr) {
@@ -147,7 +154,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((Tox_Event_Group_Custom_Private_Packet * _Nonnull)group_custom_private_packet, mem);
tox_event_group_custom_private_packet_destruct(group_custom_private_packet, mem);
}
mem_delete(mem, group_custom_private_packet);
}
@@ -208,7 +215,10 @@ static Tox_Event_Group_Custom_Private_Packet *tox_event_group_custom_private_pac
*****************************************************/
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,
Tox *tox,
uint32_t group_number,
uint32_t peer_id,
const uint8_t *data, size_t data_length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -220,5 +230,18 @@ 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, state->mem, data, data_length);
if (!tox_event_group_custom_private_packet_set_data(group_custom_private_packet, state->mem, data, data_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_group_custom_private_packet_dispatch(Tox *tox, const Tox_Event_Group_Custom_Private_Packet *event, void *user_data)
{
if (tox->group_custom_private_packet_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_custom_private_packet_callback(tox, event->group_number, event->peer_id, event->data, event->data_length, user_data);
tox_lock(tox);
}

43
toxcore/events/group_invite.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,9 +25,9 @@
struct Tox_Event_Group_Invite {
uint32_t friend_number;
uint8_t *invite_data;
uint8_t *_Nullable invite_data;
uint32_t invite_data_length;
uint8_t *group_name;
uint8_t *_Nullable group_name;
uint32_t group_name_length;
};
@@ -56,6 +57,12 @@ static bool tox_event_group_invite_set_invite_data(Tox_Event_Group_Invite *_Nonn
return true;
}
if (invite_data_length == 0) {
group_invite->invite_data = nullptr;
group_invite->invite_data_length = 0;
return true;
}
uint8_t *invite_data_copy = (uint8_t *)mem_balloc(mem, invite_data_length);
if (invite_data_copy == nullptr) {
@@ -93,6 +100,12 @@ static bool tox_event_group_invite_set_group_name(Tox_Event_Group_Invite *_Nonnu
return true;
}
if (group_name_length == 0) {
group_invite->group_name = nullptr;
group_invite->group_name_length = 0;
return true;
}
uint8_t *group_name_copy = (uint8_t *)mem_balloc(mem, group_name_length);
if (group_name_copy == nullptr) {
@@ -175,7 +188,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((Tox_Event_Group_Invite * _Nonnull)group_invite, mem);
tox_event_group_invite_destruct(group_invite, mem);
}
mem_delete(mem, group_invite);
}
@@ -236,7 +249,10 @@ static Tox_Event_Group_Invite *tox_event_group_invite_alloc(Tox_Events_State *_N
*****************************************************/
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,
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_Events_State *state = tox_events_alloc(user_data);
@@ -247,6 +263,21 @@ void tox_events_handle_group_invite(
}
tox_event_group_invite_set_friend_number(group_invite, friend_number);
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);
if (!tox_event_group_invite_set_invite_data(group_invite, state->mem, invite_data, invite_data_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
if (!tox_event_group_invite_set_group_name(group_invite, state->mem, group_name, group_name_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_group_invite_dispatch(Tox *tox, const Tox_Event_Group_Invite *event, void *user_data)
{
if (tox->group_invite_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_invite_callback(tox, event->friend_number, event->invite_data, event->invite_data_length, event->group_name, event->group_name_length, user_data);
tox_lock(tox);
}

18
toxcore/events/group_join_fail.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -107,7 +108,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((Tox_Event_Group_Join_Fail * _Nonnull)group_join_fail, mem);
tox_event_group_join_fail_destruct(group_join_fail, mem);
}
mem_delete(mem, group_join_fail);
}
@@ -168,7 +169,9 @@ static Tox_Event_Group_Join_Fail *tox_event_group_join_fail_alloc(Tox_Events_Sta
*****************************************************/
void tox_events_handle_group_join_fail(
Tox *tox, uint32_t group_number, Tox_Group_Join_Fail fail_type,
Tox *tox,
uint32_t group_number,
Tox_Group_Join_Fail fail_type,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -181,3 +184,14 @@ void tox_events_handle_group_join_fail(
tox_event_group_join_fail_set_group_number(group_join_fail, group_number);
tox_event_group_join_fail_set_fail_type(group_join_fail, fail_type);
}
void tox_events_handle_group_join_fail_dispatch(Tox *tox, const Tox_Event_Group_Join_Fail *event, void *user_data)
{
if (tox->group_join_fail_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_join_fail_callback(tox, event->group_number, event->fail_type, user_data);
tox_lock(tox);
}

33
toxcore/events/group_message.c
View File

@@ -16,6 +16,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -28,7 +29,7 @@ struct Tox_Event_Group_Message {
uint32_t group_number;
uint32_t peer_id;
Tox_Message_Type message_type;
uint8_t *message;
uint8_t *_Nullable message;
uint32_t message_length;
uint32_t message_id;
};
@@ -81,6 +82,12 @@ static bool tox_event_group_message_set_message(Tox_Event_Group_Message *_Nonnul
return true;
}
if (message_length == 0) {
group_message->message = nullptr;
group_message->message_length = 0;
return true;
}
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
@@ -177,7 +184,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((Tox_Event_Group_Message * _Nonnull)group_message, mem);
tox_event_group_message_destruct(group_message, mem);
}
mem_delete(mem, group_message);
}
@@ -238,7 +245,12 @@ static Tox_Event_Group_Message *tox_event_group_message_alloc(Tox_Events_State *
*****************************************************/
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,
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_Events_State *state = tox_events_alloc(user_data);
@@ -251,6 +263,19 @@ 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, state->mem, message, message_length);
if (!tox_event_group_message_set_message(group_message, state->mem, message, message_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
tox_event_group_message_set_message_id(group_message, message_id);
}
void tox_events_handle_group_message_dispatch(Tox *tox, const Tox_Event_Group_Message *event, void *user_data)
{
if (tox->group_message_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_message_callback(tox, event->group_number, event->peer_id, event->message_type, event->message, event->message_length, event->message_id, user_data);
tox_lock(tox);
}

20
toxcore/events/group_moderation.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -135,7 +136,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((Tox_Event_Group_Moderation * _Nonnull)group_moderation, mem);
tox_event_group_moderation_destruct(group_moderation, mem);
}
mem_delete(mem, group_moderation);
}
@@ -196,7 +197,11 @@ static Tox_Event_Group_Moderation *tox_event_group_moderation_alloc(Tox_Events_S
*****************************************************/
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,
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_Events_State *state = tox_events_alloc(user_data);
@@ -211,3 +216,14 @@ void tox_events_handle_group_moderation(
tox_event_group_moderation_set_target_peer_id(group_moderation, target_peer_id);
tox_event_group_moderation_set_mod_type(group_moderation, mod_type);
}
void tox_events_handle_group_moderation_dispatch(Tox *tox, const Tox_Event_Group_Moderation *event, void *user_data)
{
if (tox->group_moderation_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_moderation_callback(tox, event->group_number, event->source_peer_id, event->target_peer_id, event->mod_type, user_data);
tox_lock(tox);
}

30
toxcore/events/group_password.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -24,7 +25,7 @@
struct Tox_Event_Group_Password {
uint32_t group_number;
uint8_t *password;
uint8_t *_Nullable password;
uint32_t password_length;
};
@@ -54,6 +55,12 @@ static bool tox_event_group_password_set_password(Tox_Event_Group_Password *_Non
return true;
}
if (password_length == 0) {
group_password->password = nullptr;
group_password->password_length = 0;
return true;
}
uint8_t *password_copy = (uint8_t *)mem_balloc(mem, password_length);
if (password_copy == nullptr) {
@@ -133,7 +140,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((Tox_Event_Group_Password * _Nonnull)group_password, mem);
tox_event_group_password_destruct(group_password, mem);
}
mem_delete(mem, group_password);
}
@@ -194,7 +201,9 @@ static Tox_Event_Group_Password *tox_event_group_password_alloc(Tox_Events_State
*****************************************************/
void tox_events_handle_group_password(
Tox *tox, uint32_t group_number, const uint8_t *password, size_t password_length,
Tox *tox,
uint32_t group_number,
const uint8_t *password, size_t password_length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -205,5 +214,18 @@ void tox_events_handle_group_password(
}
tox_event_group_password_set_group_number(group_password, group_number);
tox_event_group_password_set_password(group_password, state->mem, password, password_length);
if (!tox_event_group_password_set_password(group_password, state->mem, password, password_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_group_password_dispatch(Tox *tox, const Tox_Event_Group_Password *event, void *user_data)
{
if (tox->group_password_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_password_callback(tox, event->group_number, event->password, event->password_length, user_data);
tox_lock(tox);
}

45
toxcore/events/group_peer_exit.c
View File

@@ -16,6 +16,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -28,9 +29,9 @@ struct Tox_Event_Group_Peer_Exit {
uint32_t group_number;
uint32_t peer_id;
Tox_Group_Exit_Type exit_type;
uint8_t *name;
uint8_t *_Nullable name;
uint32_t name_length;
uint8_t *part_message;
uint8_t *_Nullable part_message;
uint32_t part_message_length;
};
@@ -82,6 +83,12 @@ static bool tox_event_group_peer_exit_set_name(Tox_Event_Group_Peer_Exit *_Nonnu
return true;
}
if (name_length == 0) {
group_peer_exit->name = nullptr;
group_peer_exit->name_length = 0;
return true;
}
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
@@ -119,6 +126,12 @@ static bool tox_event_group_peer_exit_set_part_message(Tox_Event_Group_Peer_Exit
return true;
}
if (part_message_length == 0) {
group_peer_exit->part_message = nullptr;
group_peer_exit->part_message_length = 0;
return true;
}
uint8_t *part_message_copy = (uint8_t *)mem_balloc(mem, part_message_length);
if (part_message_copy == nullptr) {
@@ -205,7 +218,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((Tox_Event_Group_Peer_Exit * _Nonnull)group_peer_exit, mem);
tox_event_group_peer_exit_destruct(group_peer_exit, mem);
}
mem_delete(mem, group_peer_exit);
}
@@ -266,7 +279,12 @@ static Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_alloc(Tox_Events_Sta
*****************************************************/
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,
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_Events_State *state = tox_events_alloc(user_data);
@@ -279,6 +297,21 @@ 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, state->mem, name, name_length);
tox_event_group_peer_exit_set_part_message(group_peer_exit, state->mem, part_message, part_message_length);
if (!tox_event_group_peer_exit_set_name(group_peer_exit, state->mem, name, name_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
if (!tox_event_group_peer_exit_set_part_message(group_peer_exit, state->mem, part_message, part_message_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_group_peer_exit_dispatch(Tox *tox, const Tox_Event_Group_Peer_Exit *event, void *user_data)
{
if (tox->group_peer_exit_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_peer_exit_callback(tox, event->group_number, event->peer_id, event->exit_type, event->name, event->name_length, event->part_message, event->part_message_length, user_data);
tox_lock(tox);
}

18
toxcore/events/group_peer_join.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -105,7 +106,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((Tox_Event_Group_Peer_Join * _Nonnull)group_peer_join, mem);
tox_event_group_peer_join_destruct(group_peer_join, mem);
}
mem_delete(mem, group_peer_join);
}
@@ -166,7 +167,9 @@ static Tox_Event_Group_Peer_Join *tox_event_group_peer_join_alloc(Tox_Events_Sta
*****************************************************/
void tox_events_handle_group_peer_join(
Tox *tox, uint32_t group_number, uint32_t peer_id,
Tox *tox,
uint32_t group_number,
uint32_t peer_id,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -179,3 +182,14 @@ void tox_events_handle_group_peer_join(
tox_event_group_peer_join_set_group_number(group_peer_join, group_number);
tox_event_group_peer_join_set_peer_id(group_peer_join, peer_id);
}
void tox_events_handle_group_peer_join_dispatch(Tox *tox, const Tox_Event_Group_Peer_Join *event, void *user_data)
{
if (tox->group_peer_join_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_peer_join_callback(tox, event->group_number, event->peer_id, user_data);
tox_lock(tox);
}

18
toxcore/events/group_peer_limit.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -105,7 +106,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((Tox_Event_Group_Peer_Limit * _Nonnull)group_peer_limit, mem);
tox_event_group_peer_limit_destruct(group_peer_limit, mem);
}
mem_delete(mem, group_peer_limit);
}
@@ -166,7 +167,9 @@ static Tox_Event_Group_Peer_Limit *tox_event_group_peer_limit_alloc(Tox_Events_S
*****************************************************/
void tox_events_handle_group_peer_limit(
Tox *tox, uint32_t group_number, uint32_t peer_limit,
Tox *tox,
uint32_t group_number,
uint32_t peer_limit,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -179,3 +182,14 @@ void tox_events_handle_group_peer_limit(
tox_event_group_peer_limit_set_group_number(group_peer_limit, group_number);
tox_event_group_peer_limit_set_peer_limit(group_peer_limit, peer_limit);
}
void tox_events_handle_group_peer_limit_dispatch(Tox *tox, const Tox_Event_Group_Peer_Limit *event, void *user_data)
{
if (tox->group_peer_limit_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_peer_limit_callback(tox, event->group_number, event->peer_limit, user_data);
tox_lock(tox);
}

31
toxcore/events/group_peer_name.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -25,7 +26,7 @@
struct Tox_Event_Group_Peer_Name {
uint32_t group_number;
uint32_t peer_id;
uint8_t *name;
uint8_t *_Nullable name;
uint32_t name_length;
};
@@ -66,6 +67,12 @@ static bool tox_event_group_peer_name_set_name(Tox_Event_Group_Peer_Name *_Nonnu
return true;
}
if (name_length == 0) {
group_peer_name->name = nullptr;
group_peer_name->name_length = 0;
return true;
}
uint8_t *name_copy = (uint8_t *)mem_balloc(mem, name_length);
if (name_copy == nullptr) {
@@ -147,7 +154,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((Tox_Event_Group_Peer_Name * _Nonnull)group_peer_name, mem);
tox_event_group_peer_name_destruct(group_peer_name, mem);
}
mem_delete(mem, group_peer_name);
}
@@ -208,7 +215,10 @@ static Tox_Event_Group_Peer_Name *tox_event_group_peer_name_alloc(Tox_Events_Sta
*****************************************************/
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,
Tox *tox,
uint32_t group_number,
uint32_t peer_id,
const uint8_t *name, size_t name_length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -220,5 +230,18 @@ 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, state->mem, name, name_length);
if (!tox_event_group_peer_name_set_name(group_peer_name, state->mem, name, name_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_group_peer_name_dispatch(Tox *tox, const Tox_Event_Group_Peer_Name *event, void *user_data)
{
if (tox->group_peer_name_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_peer_name_callback(tox, event->group_number, event->peer_id, event->name, event->name_length, user_data);
tox_lock(tox);
}

19
toxcore/events/group_peer_status.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -121,7 +122,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((Tox_Event_Group_Peer_Status * _Nonnull)group_peer_status, mem);
tox_event_group_peer_status_destruct(group_peer_status, mem);
}
mem_delete(mem, group_peer_status);
}
@@ -182,7 +183,10 @@ static Tox_Event_Group_Peer_Status *tox_event_group_peer_status_alloc(Tox_Events
*****************************************************/
void tox_events_handle_group_peer_status(
Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_User_Status status,
Tox *tox,
uint32_t group_number,
uint32_t peer_id,
Tox_User_Status status,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -196,3 +200,14 @@ void tox_events_handle_group_peer_status(
tox_event_group_peer_status_set_peer_id(group_peer_status, peer_id);
tox_event_group_peer_status_set_status(group_peer_status, status);
}
void tox_events_handle_group_peer_status_dispatch(Tox *tox, const Tox_Event_Group_Peer_Status *event, void *user_data)
{
if (tox->group_peer_status_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_peer_status_callback(tox, event->group_number, event->peer_id, event->status, user_data);
tox_lock(tox);
}

18
toxcore/events/group_privacy_state.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -107,7 +108,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((Tox_Event_Group_Privacy_State * _Nonnull)group_privacy_state, mem);
tox_event_group_privacy_state_destruct(group_privacy_state, mem);
}
mem_delete(mem, group_privacy_state);
}
@@ -168,7 +169,9 @@ static Tox_Event_Group_Privacy_State *tox_event_group_privacy_state_alloc(Tox_Ev
*****************************************************/
void tox_events_handle_group_privacy_state(
Tox *tox, uint32_t group_number, Tox_Group_Privacy_State privacy_state,
Tox *tox,
uint32_t group_number,
Tox_Group_Privacy_State privacy_state,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -181,3 +184,14 @@ void tox_events_handle_group_privacy_state(
tox_event_group_privacy_state_set_group_number(group_privacy_state, group_number);
tox_event_group_privacy_state_set_privacy_state(group_privacy_state, privacy_state);
}
void tox_events_handle_group_privacy_state_dispatch(Tox *tox, const Tox_Event_Group_Privacy_State *event, void *user_data)
{
if (tox->group_privacy_state_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_privacy_state_callback(tox, event->group_number, event->privacy_state, user_data);
tox_lock(tox);
}

33
toxcore/events/group_private_message.c
View File

@@ -16,6 +16,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -28,7 +29,7 @@ struct Tox_Event_Group_Private_Message {
uint32_t group_number;
uint32_t peer_id;
Tox_Message_Type message_type;
uint8_t *message;
uint8_t *_Nullable message;
uint32_t message_length;
uint32_t message_id;
};
@@ -81,6 +82,12 @@ static bool tox_event_group_private_message_set_message(Tox_Event_Group_Private_
return true;
}
if (message_length == 0) {
group_private_message->message = nullptr;
group_private_message->message_length = 0;
return true;
}
uint8_t *message_copy = (uint8_t *)mem_balloc(mem, message_length);
if (message_copy == nullptr) {
@@ -177,7 +184,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((Tox_Event_Group_Private_Message * _Nonnull)group_private_message, mem);
tox_event_group_private_message_destruct(group_private_message, mem);
}
mem_delete(mem, group_private_message);
}
@@ -238,7 +245,12 @@ static Tox_Event_Group_Private_Message *tox_event_group_private_message_alloc(To
*****************************************************/
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,
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_Events_State *state = tox_events_alloc(user_data);
@@ -251,6 +263,19 @@ 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, state->mem, message, message_length);
if (!tox_event_group_private_message_set_message(group_private_message, state->mem, message, message_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
tox_event_group_private_message_set_message_id(group_private_message, message_id);
}
void tox_events_handle_group_private_message_dispatch(Tox *tox, const Tox_Event_Group_Private_Message *event, void *user_data)
{
if (tox->group_private_message_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_private_message_callback(tox, event->group_number, event->peer_id, event->message_type, event->message, event->message_length, event->message_id, user_data);
tox_lock(tox);
}

17
toxcore/events/group_self_join.c
View File

@@ -14,6 +14,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -86,7 +87,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((Tox_Event_Group_Self_Join * _Nonnull)group_self_join, mem);
tox_event_group_self_join_destruct(group_self_join, mem);
}
mem_delete(mem, group_self_join);
}
@@ -147,7 +148,8 @@ static Tox_Event_Group_Self_Join *tox_event_group_self_join_alloc(Tox_Events_Sta
*****************************************************/
void tox_events_handle_group_self_join(
Tox *tox, uint32_t group_number,
Tox *tox,
uint32_t group_number,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -159,3 +161,14 @@ void tox_events_handle_group_self_join(
tox_event_group_self_join_set_group_number(group_self_join, group_number);
}
void tox_events_handle_group_self_join_dispatch(Tox *tox, const Tox_Event_Group_Self_Join *event, void *user_data)
{
if (tox->group_self_join_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_self_join_callback(tox, event->group_number, user_data);
tox_lock(tox);
}

31
toxcore/events/group_topic.c
View File

@@ -15,6 +15,7 @@
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_struct.h"
/*****************************************************
*
@@ -25,7 +26,7 @@
struct Tox_Event_Group_Topic {
uint32_t group_number;
uint32_t peer_id;
uint8_t *topic;
uint8_t *_Nullable topic;
uint32_t topic_length;
};
@@ -66,6 +67,12 @@ static bool tox_event_group_topic_set_topic(Tox_Event_Group_Topic *_Nonnull grou
return true;
}
if (topic_length == 0) {
group_topic->topic = nullptr;
group_topic->topic_length = 0;
return true;
}
uint8_t *topic_copy = (uint8_t *)mem_balloc(mem, topic_length);
if (topic_copy == nullptr) {
@@ -147,7 +154,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((Tox_Event_Group_Topic * _Nonnull)group_topic, mem);
tox_event_group_topic_destruct(group_topic, mem);
}
mem_delete(mem, group_topic);
}
@@ -208,7 +215,10 @@ static Tox_Event_Group_Topic *tox_event_group_topic_alloc(Tox_Events_State *_Non
*****************************************************/
void tox_events_handle_group_topic(
Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *topic, size_t topic_length,
Tox *tox,
uint32_t group_number,
uint32_t peer_id,
const uint8_t *topic, size_t topic_length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -220,5 +230,18 @@ 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, state->mem, topic, topic_length);
if (!tox_event_group_topic_set_topic(group_topic, state->mem, topic, topic_length)) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
}
}
void tox_events_handle_group_topic_dispatch(Tox *tox, const Tox_Event_Group_Topic *event, void *user_data)
{
if (tox->group_topic_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_topic_callback(tox, event->group_number, event->peer_id, event->topic, event->topic_length, user_data);
tox_lock(tox);
}

18
toxcore/events/group_topic_lock.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -107,7 +108,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((Tox_Event_Group_Topic_Lock * _Nonnull)group_topic_lock, mem);
tox_event_group_topic_lock_destruct(group_topic_lock, mem);
}
mem_delete(mem, group_topic_lock);
}
@@ -168,7 +169,9 @@ static Tox_Event_Group_Topic_Lock *tox_event_group_topic_lock_alloc(Tox_Events_S
*****************************************************/
void tox_events_handle_group_topic_lock(
Tox *tox, uint32_t group_number, Tox_Group_Topic_Lock topic_lock,
Tox *tox,
uint32_t group_number,
Tox_Group_Topic_Lock topic_lock,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -181,3 +184,14 @@ void tox_events_handle_group_topic_lock(
tox_event_group_topic_lock_set_group_number(group_topic_lock, group_number);
tox_event_group_topic_lock_set_topic_lock(group_topic_lock, topic_lock);
}
void tox_events_handle_group_topic_lock_dispatch(Tox *tox, const Tox_Event_Group_Topic_Lock *event, void *user_data)
{
if (tox->group_topic_lock_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_topic_lock_callback(tox, event->group_number, event->topic_lock, user_data);
tox_lock(tox);
}

18
toxcore/events/group_voice_state.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -107,7 +108,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((Tox_Event_Group_Voice_State * _Nonnull)group_voice_state, mem);
tox_event_group_voice_state_destruct(group_voice_state, mem);
}
mem_delete(mem, group_voice_state);
}
@@ -168,7 +169,9 @@ static Tox_Event_Group_Voice_State *tox_event_group_voice_state_alloc(Tox_Events
*****************************************************/
void tox_events_handle_group_voice_state(
Tox *tox, uint32_t group_number, Tox_Group_Voice_State voice_state,
Tox *tox,
uint32_t group_number,
Tox_Group_Voice_State voice_state,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -181,3 +184,14 @@ void tox_events_handle_group_voice_state(
tox_event_group_voice_state_set_group_number(group_voice_state, group_number);
tox_event_group_voice_state_set_voice_state(group_voice_state, voice_state);
}
void tox_events_handle_group_voice_state_dispatch(Tox *tox, const Tox_Event_Group_Voice_State *event, void *user_data)
{
if (tox->group_voice_state_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->group_voice_state_callback(tox, event->group_number, event->voice_state, user_data);
tox_lock(tox);
}

17
toxcore/events/self_connection_status.c
View File

@@ -15,6 +15,7 @@
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_struct.h"
#include "../tox_unpack.h"
/*****************************************************
@@ -88,7 +89,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((Tox_Event_Self_Connection_Status * _Nonnull)self_connection_status, mem);
tox_event_self_connection_status_destruct(self_connection_status, mem);
}
mem_delete(mem, self_connection_status);
}
@@ -149,7 +150,8 @@ static Tox_Event_Self_Connection_Status *tox_event_self_connection_status_alloc(
*****************************************************/
void tox_events_handle_self_connection_status(
Tox *tox, Tox_Connection connection_status,
Tox *tox,
Tox_Connection connection_status,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
@@ -161,3 +163,14 @@ void tox_events_handle_self_connection_status(
tox_event_self_connection_status_set_connection_status(self_connection_status, connection_status);
}
void tox_events_handle_self_connection_status_dispatch(Tox *tox, const Tox_Event_Self_Connection_Status *event, void *user_data)
{
if (tox->self_connection_status_callback == nullptr) {
return;
}
tox_unlock(tox);
tox->self_connection_status_callback(tox, event->connection_status, user_data);
tox_lock(tox);
}