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

Merge commit 'b2ae9530a405e02a50476c04fc7196c5e9863ad6'

Browse Source
This commit is contained in:
Green Sky
2023-12-27 12:37:22 +01:00
parent 35ebbbef93 b2ae9530a4
commit ae1fb0fde3
173 changed files with 9191 additions and 5633 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
external/toxcore/c-toxcore/toxcore/BUILD.bazel vendored
View File

@ -838,11 +838,17 @@ cc_library(
cc_library(
name = "tox_events",
srcs = ["tox_events.c"] + glob([
srcs = [
"tox_event.c",
"tox_events.c",
] + glob([
"events/*.c",
"events/*.h",
]),
hdrs = ["tox_events.h"],
hdrs = [
"events/events_alloc.h",
"tox_event.h",
"tox_events.h",
],
visibility = ["//c-toxcore:__subpackages__"],
deps = [
":attributes",

13
external/toxcore/c-toxcore/toxcore/DHT.c vendored
View File

@ -1930,14 +1930,11 @@ static void do_close(DHT *dht)
for (size_t i = 0; i < LCLIENT_LIST; ++i) {
Client_data *const client = &dht->close_clientlist[i];
IPPTsPng *const assocs[] = { &client->assoc6, &client->assoc4, nullptr };
for (IPPTsPng * const *it = assocs; *it != nullptr; ++it) {
IPPTsPng *const assoc = *it;
if (assoc->timestamp != 0) {
assoc->timestamp = badonly;
}
if (client->assoc4.timestamp != 0) {
client->assoc4.timestamp = badonly;
}
if (client->assoc6.timestamp != 0) {
client->assoc6.timestamp = badonly;
}
}
}

3
external/toxcore/c-toxcore/toxcore/DHT_test.cc vendored
View File

@ -192,8 +192,11 @@ TEST(AnnounceNodes, SetAndTest)
const Memory *mem = system_memory();
Logger *log = logger_new();
ASSERT_NE(log, nullptr);
Mono_Time *mono_time = mono_time_new(mem, nullptr, nullptr);
ASSERT_NE(mono_time, nullptr);
Networking_Core *net = new_networking_no_udp(log, mem, ns);
ASSERT_NE(net, nullptr);
DHT *dht = new_dht(log, mem, rng, ns, mono_time, net, true, true);
ASSERT_NE(dht, nullptr);

10
external/toxcore/c-toxcore/toxcore/Makefile.inc vendored
View File

@ -21,6 +21,8 @@ libtoxcore_la_SOURCES = ../third_party/cmp/cmp.c \
../toxcore/events/conference_peer_list_changed.c \
../toxcore/events/conference_peer_name.c \
../toxcore/events/conference_title.c \
../toxcore/events/events_alloc.c \
../toxcore/events/events_alloc.h \
../toxcore/events/file_chunk_request.c \
../toxcore/events/file_recv.c \
../toxcore/events/file_recv_chunk.c \
@ -35,8 +37,6 @@ libtoxcore_la_SOURCES = ../third_party/cmp/cmp.c \
../toxcore/events/friend_status.c \
../toxcore/events/friend_status_message.c \
../toxcore/events/friend_typing.c \
../toxcore/events/events_alloc.c \
../toxcore/events/events_alloc.h \
../toxcore/events/self_connection_status.c \
../toxcore/events/group_custom_packet.c \
../toxcore/events/group_custom_private_packet.c \
@ -90,6 +90,8 @@ libtoxcore_la_SOURCES = ../third_party/cmp/cmp.c \
../toxcore/tox.c \
../toxcore/tox_dispatch.h \
../toxcore/tox_dispatch.c \
../toxcore/tox_event.h \
../toxcore/tox_event.c \
../toxcore/tox_events.h \
../toxcore/tox_events.c \
../toxcore/tox_unpack.h \
@ -141,7 +143,6 @@ libtoxcore_la_SOURCES = ../third_party/cmp/cmp.c \
libtoxcore_la_CFLAGS = -I$(top_srcdir) \
-I$(top_srcdir)/toxcore \
$(LIBSODIUM_CFLAGS) \
$(NACL_CFLAGS) \
$(MSGPACK_CFLAGS) \
$(PTHREAD_CFLAGS) \
-DCMP_NO_FLOAT=1
@ -149,15 +150,12 @@ libtoxcore_la_CFLAGS = -I$(top_srcdir) \
libtoxcore_la_LDFLAGS = $(LT_LDFLAGS) \
$(EXTRA_LT_LDFLAGS) \
$(LIBSODIUM_LDFLAGS) \
$(NACL_LDFLAGS) \
$(MSGPACK_LDFLAGS) \
$(MATH_LDFLAGS) \
$(RT_LIBS) \
$(WINSOCK2_LIBS)
libtoxcore_la_LIBADD = $(LIBSODIUM_LIBS) \
$(NACL_OBJECTS) \
$(NACL_LIBS) \
$(MSGPACK_LIBS) \
$(PTHREAD_LIBS)

86
external/toxcore/c-toxcore/toxcore/Messenger.c vendored
View File

@ -757,17 +757,34 @@ int m_set_statusmessage(Messenger *m, const uint8_t *status, uint16_t length)
return 0;
}
static Userstatus userstatus_from_int(uint8_t status)
non_null()
static bool userstatus_from_int(uint8_t status, Userstatus *out)
{
switch (status) {
case 0:
return USERSTATUS_NONE;
case 1:
return USERSTATUS_AWAY;
case 2:
return USERSTATUS_BUSY;
default:
return USERSTATUS_INVALID;
case USERSTATUS_NONE: {
*out = USERSTATUS_NONE;
return true;
}
case USERSTATUS_AWAY: {
*out = USERSTATUS_AWAY;
return true;
}
case USERSTATUS_BUSY: {
*out = USERSTATUS_BUSY;
return true;
}
case USERSTATUS_INVALID: {
*out = USERSTATUS_INVALID;
return true;
}
default: {
*out = USERSTATUS_INVALID;
return false;
}
}
}
@ -781,7 +798,7 @@ int m_set_userstatus(Messenger *m, uint8_t status)
return 0;
}
m->userstatus = userstatus_from_int(status);
userstatus_from_int(status, &m->userstatus);
for (uint32_t i = 0; i < m->numfriends; ++i) {
m->friendlist[i].userstatus_sent = false;
@ -937,7 +954,7 @@ static int set_friend_statusmessage(const Messenger *m, int32_t friendnumber, co
non_null()
static void set_friend_userstatus(const Messenger *m, int32_t friendnumber, uint8_t status)
{
m->friendlist[friendnumber].userstatus = userstatus_from_int(status);
userstatus_from_int(status, &m->friendlist[friendnumber].userstatus);
}
non_null()
@ -2095,9 +2112,8 @@ static int m_handle_packet_userstatus(Messenger *m, const int i, const uint8_t *
return 0;
}
const Userstatus status = userstatus_from_int(data[0]);
if (status == USERSTATUS_INVALID) {
Userstatus status;
if (!userstatus_from_int(data[0], &status)) {
return 0;
}
@ -2343,8 +2359,6 @@ static int m_handle_packet_msi(Messenger *m, const int i, const uint8_t *data, c
non_null(1, 3) nullable(5)
static int m_handle_packet_invite_groupchat(Messenger *m, const int i, const uint8_t *data, const uint16_t data_length, void *userdata)
{
#ifndef VANILLA_NACL
// first two bytes are messenger packet type and group invite type
if (data_length < 2 + GC_JOIN_DATA_LENGTH) {
return 0;
@ -2365,8 +2379,6 @@ static int m_handle_packet_invite_groupchat(Messenger *m, const int i, const uin
handle_gc_invite_confirmed_packet(m->group_handler, i, join_data, join_data_len);
}
#endif // VANILLA_NACL
return 0;
}
@ -2547,7 +2559,6 @@ uint32_t messenger_run_interval(const Messenger *m)
*
* @retval true if success.
*/
#ifndef VANILLA_NACL
non_null()
static bool self_announce_group(const Messenger *m, GC_Chat *chat, Onion_Friend *onion_friend)
{
@ -2623,7 +2634,6 @@ static void do_gc_onion_friends(const Messenger *m)
}
}
}
#endif // VANILLA_NACL
/** @brief The main loop that needs to be run at least 20 times per second. */
void do_messenger(Messenger *m, void *userdata)
@ -2661,11 +2671,9 @@ void do_messenger(Messenger *m, void *userdata)
do_onion_client(m->onion_c);
do_friend_connections(m->fr_c, userdata);
do_friends(m, userdata);
#ifndef VANILLA_NACL
do_gc(m->group_handler, userdata);
do_gca(m->mono_time, m->group_announce);
do_gc_onion_friends(m);
#endif
m_connection_status_callback(m, userdata);
if (mono_time_get(m->mono_time) > m->lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) {
@ -3148,7 +3156,6 @@ static State_Load_Status friends_list_load(Messenger *m, const uint8_t *data, ui
return STATE_LOAD_STATUS_CONTINUE;
}
#ifndef VANILLA_NACL
non_null()
static void pack_groupchats(const GC_Session *c, Bin_Pack *bp)
{
@ -3176,7 +3183,7 @@ static bool pack_groupchats_handler(Bin_Pack *bp, const Logger *log, const void
non_null()
static uint32_t saved_groups_size(const Messenger *m)
{
GC_Session *c = m->group_handler;
const GC_Session *c = m->group_handler;
return bin_pack_obj_size(pack_groupchats_handler, m->log, c);
}
@ -3245,7 +3252,6 @@ static State_Load_Status groups_load(Messenger *m, const uint8_t *data, uint32_t
return STATE_LOAD_STATUS_CONTINUE;
}
#endif /* VANILLA_NACL */
// name state plugin
non_null()
@ -3433,9 +3439,7 @@ static void m_register_default_plugins(Messenger *m)
m_register_state_plugin(m, STATE_TYPE_STATUSMESSAGE, status_message_size, load_status_message,
save_status_message);
m_register_state_plugin(m, STATE_TYPE_STATUS, status_size, load_status, save_status);
#ifndef VANILLA_NACL
m_register_state_plugin(m, STATE_TYPE_GROUPS, saved_groups_size, groups_load, groups_save);
#endif
m_register_state_plugin(m, STATE_TYPE_TCP_RELAY, tcp_relay_size, load_tcp_relays, save_tcp_relays);
m_register_state_plugin(m, STATE_TYPE_PATH_NODE, path_node_size, load_path_nodes, save_path_nodes);
}
@ -3579,14 +3583,14 @@ Messenger *new_messenger(Mono_Time *mono_time, const Memory *mem, const Random *
if (m->net == nullptr) {
friendreq_kill(m->fr);
logger_kill(m->log);
mem_delete(mem, m);
if (error != nullptr && net_err == 1) {
LOGGER_WARNING(m->log, "network initialisation failed (no ports available)");
*error = MESSENGER_ERROR_PORT;
}
logger_kill(m->log);
mem_delete(mem, m);
return nullptr;
}
@ -3613,7 +3617,6 @@ Messenger *new_messenger(Mono_Time *mono_time, const Memory *mem, const Random *
return nullptr;
}
#ifndef VANILLA_NACL
m->group_announce = new_gca_list();
if (m->group_announce == nullptr) {
@ -3628,11 +3631,13 @@ Messenger *new_messenger(Mono_Time *mono_time, const Memory *mem, const Random *
return nullptr;
}
#endif /* VANILLA_NACL */
if (options->dht_announcements_enabled) {
m->forwarding = new_forwarding(m->log, m->rng, m->mono_time, m->dht);
m->announce = new_announcements(m->log, m->mem, m->rng, m->mono_time, m->forwarding);
if (m->forwarding != nullptr) {
m->announce = new_announcements(m->log, m->mem, m->rng, m->mono_time, m->forwarding);
} else {
m->announce = nullptr;
}
} else {
m->forwarding = nullptr;
m->announce = nullptr;
@ -3652,9 +3657,7 @@ Messenger *new_messenger(Mono_Time *mono_time, const Memory *mem, const Random *
kill_onion(m->onion);
kill_onion_announce(m->onion_a);
kill_onion_client(m->onion_c);
#ifndef VANILLA_NACL
kill_gca(m->group_announce);
#endif /* VANILLA_NACL */
kill_friend_connections(m->fr_c);
kill_announcements(m->announce);
kill_forwarding(m->forwarding);
@ -3667,7 +3670,6 @@ Messenger *new_messenger(Mono_Time *mono_time, const Memory *mem, const Random *
return nullptr;
}
#ifndef VANILLA_NACL
gca_onion_init(m->group_announce, m->onion_a);
m->group_handler = new_dht_groupchats(m);
@ -3691,8 +3693,6 @@ Messenger *new_messenger(Mono_Time *mono_time, const Memory *mem, const Random *
return nullptr;
}
#endif /* VANILLA_NACL */
if (options->tcp_server_port != 0) {
m->tcp_server = new_tcp_server(m->log, m->mem, m->rng, m->ns, options->ipv6enabled, 1,
&options->tcp_server_port, dht_get_self_secret_key(m->dht),
@ -3703,14 +3703,10 @@ Messenger *new_messenger(Mono_Time *mono_time, const Memory *mem, const Random *
kill_onion(m->onion);
kill_onion_announce(m->onion_a);
#ifndef VANILLA_NACL
kill_dht_groupchats(m->group_handler);
#endif
kill_friend_connections(m->fr_c);
kill_onion_client(m->onion_c);
#ifndef VANILLA_NACL
kill_gca(m->group_announce);
#endif
kill_announcements(m->announce);
kill_forwarding(m->forwarding);
kill_net_crypto(m->net_crypto);
@ -3762,14 +3758,10 @@ void kill_messenger(Messenger *m)
kill_onion(m->onion);
kill_onion_announce(m->onion_a);
#ifndef VANILLA_NACL
kill_dht_groupchats(m->group_handler);
#endif
kill_friend_connections(m->fr_c);
kill_onion_client(m->onion_c);
#ifndef VANILLA_NACL
kill_gca(m->group_announce);
#endif
kill_announcements(m->announce);
kill_forwarding(m->forwarding);
kill_net_crypto(m->net_crypto);
@ -3780,11 +3772,11 @@ void kill_messenger(Messenger *m)
clear_receipts(m, i);
}
logger_kill(m->log);
mem_delete(m->mem, m->friendlist);
friendreq_kill(m->fr);
mem_delete(m->mem, m->options.state_plugins);
logger_kill(m->log);
mem_delete(m->mem, m);
}

2
external/toxcore/c-toxcore/toxcore/Messenger.h vendored
View File

@ -297,7 +297,7 @@ struct Messenger {
m_friend_connectionstatuschange_internal_cb *friend_connectionstatuschange_internal;
void *friend_connectionstatuschange_internal_userdata;
struct Group_Chats *conferences_object; /* Set by new_groupchats()*/
struct Group_Chats *conferences_object;
m_conference_invite_cb *conference_invite;
m_group_invite_cb *group_invite;

29
external/toxcore/c-toxcore/toxcore/TCP_client.c vendored
View File

@ -118,9 +118,9 @@ static bool connect_sock_to(const Logger *logger, const Memory *mem, Socket sock
non_null()
static int proxy_http_generate_connection_request(TCP_Client_Connection *tcp_conn)
{
char one[] = "CONNECT ";
char two[] = " HTTP/1.1\nHost: ";
char three[] = "\r\n\r\n";
const char one[] = "CONNECT ";
const char two[] = " HTTP/1.1\nHost: ";
const char three[] = "\r\n\r\n";
char ip[TOX_INET6_ADDRSTRLEN];
@ -149,7 +149,7 @@ static int proxy_http_generate_connection_request(TCP_Client_Connection *tcp_con
non_null()
static int proxy_http_read_connection_response(const Logger *logger, const TCP_Client_Connection *tcp_conn)
{
char success[] = "200";
const char success[] = "200";
uint8_t data[16]; // draining works the best if the length is a power of 2
const TCP_Connection *con0 = &tcp_conn->con;
@ -185,14 +185,16 @@ static int proxy_http_read_connection_response(const Logger *logger, const TCP_C
return -1;
}
#define TCP_SOCKS5_PROXY_HS_VERSION_SOCKS5 0x05
#define TCP_SOCKS5_PROXY_HS_COMM_ESTABLISH_REQUEST 0x01
#define TCP_SOCKS5_PROXY_HS_COMM_REQUEST_GRANTED 0x00
#define TCP_SOCKS5_PROXY_HS_AUTH_METHODS_SUPPORTED 0x01
#define TCP_SOCKS5_PROXY_HS_NO_AUTH 0x00
#define TCP_SOCKS5_PROXY_HS_RESERVED 0x00
#define TCP_SOCKS5_PROXY_HS_ADDR_TYPE_IPV4 0x01
#define TCP_SOCKS5_PROXY_HS_ADDR_TYPE_IPV6 0x04
enum Tcp_Socks5_Proxy_Hs {
TCP_SOCKS5_PROXY_HS_VERSION_SOCKS5 = 0x05,
TCP_SOCKS5_PROXY_HS_COMM_ESTABLISH_REQUEST = 0x01,
TCP_SOCKS5_PROXY_HS_COMM_REQUEST_GRANTED = 0x00,
TCP_SOCKS5_PROXY_HS_AUTH_METHODS_SUPPORTED = 0x01,
TCP_SOCKS5_PROXY_HS_NO_AUTH = 0x00,
TCP_SOCKS5_PROXY_HS_RESERVED = 0x00,
TCP_SOCKS5_PROXY_HS_ADDR_TYPE_IPV4 = 0x01,
TCP_SOCKS5_PROXY_HS_ADDR_TYPE_IPV6 = 0x04,
};
non_null()
static void proxy_socks5_generate_greetings(TCP_Client_Connection *tcp_conn)
@ -910,8 +912,7 @@ static int do_confirmed_tcp(const Logger *logger, TCP_Client_Connection *conn, c
}
while (tcp_process_packet(logger, conn, userdata)) {
// Keep reading until error or out of data.
continue;
/* Keep reading until error or out of data. */
}
return 0;

41
external/toxcore/c-toxcore/toxcore/TCP_common.h vendored
View File

@ -24,33 +24,20 @@ void wipe_priority_list(const Memory *mem, TCP_Priority_List *p);
#define NUM_RESERVED_PORTS 16
#define NUM_CLIENT_CONNECTIONS (256 - NUM_RESERVED_PORTS)
#ifdef USE_TEST_NETWORK
#define TCP_PACKET_FORWARD_REQUEST 11
#define TCP_PACKET_FORWARDING 10
#define TCP_PACKET_ROUTING_REQUEST 9
#define TCP_PACKET_ROUTING_RESPONSE 8
#define TCP_PACKET_CONNECTION_NOTIFICATION 7
#define TCP_PACKET_DISCONNECT_NOTIFICATION 6
#define TCP_PACKET_PING 5
#define TCP_PACKET_PONG 4
#define TCP_PACKET_OOB_SEND 3
#define TCP_PACKET_OOB_RECV 2
#define TCP_PACKET_ONION_REQUEST 1
#define TCP_PACKET_ONION_RESPONSE 0
#else
#define TCP_PACKET_ROUTING_REQUEST 0
#define TCP_PACKET_ROUTING_RESPONSE 1
#define TCP_PACKET_CONNECTION_NOTIFICATION 2
#define TCP_PACKET_DISCONNECT_NOTIFICATION 3
#define TCP_PACKET_PING 4
#define TCP_PACKET_PONG 5
#define TCP_PACKET_OOB_SEND 6
#define TCP_PACKET_OOB_RECV 7
#define TCP_PACKET_ONION_REQUEST 8
#define TCP_PACKET_ONION_RESPONSE 9
#define TCP_PACKET_FORWARD_REQUEST 10
#define TCP_PACKET_FORWARDING 11
#endif // test network
typedef enum Tcp_Packet {
TCP_PACKET_ROUTING_REQUEST = 0,
TCP_PACKET_ROUTING_RESPONSE = 1,
TCP_PACKET_CONNECTION_NOTIFICATION = 2,
TCP_PACKET_DISCONNECT_NOTIFICATION = 3,
TCP_PACKET_PING = 4,
TCP_PACKET_PONG = 5,
TCP_PACKET_OOB_SEND = 6,
TCP_PACKET_OOB_RECV = 7,
TCP_PACKET_ONION_REQUEST = 8,
TCP_PACKET_ONION_RESPONSE = 9,
TCP_PACKET_FORWARD_REQUEST = 10,
TCP_PACKET_FORWARDING = 11,
} Tcp_Packet;
#define TCP_HANDSHAKE_PLAIN_SIZE (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE)
#define TCP_SERVER_HANDSHAKE_SIZE (CRYPTO_NONCE_SIZE + TCP_HANDSHAKE_PLAIN_SIZE + CRYPTO_MAC_SIZE)

6
external/toxcore/c-toxcore/toxcore/TCP_connection.c vendored
View File

@ -407,7 +407,7 @@ int get_random_tcp_onion_conn_number(const TCP_Connections *tcp_c)
* return -1 on failure.
*/
non_null()
static int get_conn_number_by_ip_port(TCP_Connections *tcp_c, const IP_Port *ip_port)
static int get_conn_number_by_ip_port(const TCP_Connections *tcp_c, const IP_Port *ip_port)
{
for (uint32_t i = 0; i < tcp_c->tcp_connections_length; ++i) {
const IP_Port conn_ip_port = tcp_con_ip_port(tcp_c->tcp_connections[i].connection);
@ -1059,7 +1059,7 @@ static int send_tcp_relay_routing_request(const TCP_Connections *tcp_c, int tcp_
non_null()
static int tcp_response_callback(void *object, uint8_t connection_id, const uint8_t *public_key)
{
TCP_Client_Connection *tcp_client_con = (TCP_Client_Connection *)object;
const TCP_Client_Connection *tcp_client_con = (const TCP_Client_Connection *)object;
const TCP_Connections *tcp_c = (const TCP_Connections *)tcp_con_custom_object(tcp_client_con);
const unsigned int tcp_connections_number = tcp_con_custom_uint(tcp_client_con);
@ -1256,7 +1256,7 @@ static int tcp_relay_on_online(TCP_Connections *tcp_c, int tcp_connections_numbe
bool sent_any = false;
for (uint32_t i = 0; i < tcp_c->connections_length; ++i) {
TCP_Connection_to *con_to = get_connection(tcp_c, i);
const TCP_Connection_to *con_to = get_connection(tcp_c, i);
if (con_to != nullptr) {
if (tcp_connection_in_conn(con_to, tcp_connections_number)) {

3
external/toxcore/c-toxcore/toxcore/TCP_server.c vendored
View File

@ -1144,8 +1144,7 @@ non_null()
static void do_confirmed_recv(TCP_Server *tcp_server, uint32_t i)
{
while (tcp_process_secure_packet(tcp_server, i)) {
// Keep reading until an error occurs or there is no more data to read.
continue;
/* Keep reading until an error occurs or there is no more data to read. */
}
}

9
external/toxcore/c-toxcore/toxcore/announce.c vendored
View File

@ -302,7 +302,7 @@ static int create_reply_plain_data_search_request(Announcements *announce,
const IP_Port *source,
const uint8_t *data, uint16_t length,
uint8_t *reply, uint16_t reply_max_length,
uint8_t *to_auth, uint16_t to_auth_length)
const uint8_t *to_auth, uint16_t to_auth_length)
{
if (length != CRYPTO_PUBLIC_KEY_SIZE &&
length != CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_SHA256_SIZE) {
@ -377,11 +377,12 @@ static int create_reply_plain_data_search_request(Announcements *announce,
}
non_null()
static int create_reply_plain_data_retrieve_request(Announcements *announce,
static int create_reply_plain_data_retrieve_request(
const Announcements *announce,
const IP_Port *source,
const uint8_t *data, uint16_t length,
uint8_t *reply, uint16_t reply_max_length,
uint8_t *to_auth, uint16_t to_auth_length)
const uint8_t *to_auth, uint16_t to_auth_length)
{
if (length != CRYPTO_PUBLIC_KEY_SIZE + 1 + TIMED_AUTH_SIZE) {
return -1;
@ -423,7 +424,7 @@ static int create_reply_plain_store_announce_request(Announcements *announce,
const IP_Port *source,
const uint8_t *data, uint16_t length,
uint8_t *reply, uint16_t reply_max_length,
uint8_t *to_auth, uint16_t to_auth_length)
const uint8_t *to_auth, uint16_t to_auth_length)
{
const int plain_len = (int)length - (CRYPTO_PUBLIC_KEY_SIZE + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE);
const int announcement_len = (int)plain_len - (TIMED_AUTH_SIZE + sizeof(uint32_t) + 1);

50
external/toxcore/c-toxcore/toxcore/crypto_core.c vendored
View File

@ -14,19 +14,7 @@
#include <stdlib.h>
#include <string.h>
#ifndef VANILLA_NACL
// We use libsodium by default.
#include <sodium.h>
#else
#include <crypto_auth.h>
#include <crypto_box.h>
#include <crypto_hash_sha256.h>
#include <crypto_hash_sha512.h>
#include <crypto_scalarmult_curve25519.h>
#include <crypto_verify_16.h>
#include <crypto_verify_32.h>
#include <randombytes.h>
#endif
#include "ccompat.h"
@ -34,11 +22,9 @@
#define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
#endif
#ifndef VANILLA_NACL
// Need dht because of ENC_SECRET_KEY_SIZE and ENC_PUBLIC_KEY_SIZE
#define ENC_PUBLIC_KEY_SIZE CRYPTO_PUBLIC_KEY_SIZE
#define ENC_SECRET_KEY_SIZE CRYPTO_SECRET_KEY_SIZE
#endif
static_assert(CRYPTO_PUBLIC_KEY_SIZE == crypto_box_PUBLICKEYBYTES,
"CRYPTO_PUBLIC_KEY_SIZE should be equal to crypto_box_PUBLICKEYBYTES");
@ -63,20 +49,15 @@ static_assert(CRYPTO_SHA512_SIZE == crypto_hash_sha512_BYTES,
static_assert(CRYPTO_PUBLIC_KEY_SIZE == 32,
"CRYPTO_PUBLIC_KEY_SIZE is required to be 32 bytes for pk_equal to work");
#ifndef VANILLA_NACL
static_assert(CRYPTO_SIGNATURE_SIZE == crypto_sign_BYTES,
"CRYPTO_SIGNATURE_SIZE should be equal to crypto_sign_BYTES");
static_assert(CRYPTO_SIGN_PUBLIC_KEY_SIZE == crypto_sign_PUBLICKEYBYTES,
"CRYPTO_SIGN_PUBLIC_KEY_SIZE should be equal to crypto_sign_PUBLICKEYBYTES");
static_assert(CRYPTO_SIGN_SECRET_KEY_SIZE == crypto_sign_SECRETKEYBYTES,
"CRYPTO_SIGN_SECRET_KEY_SIZE should be equal to crypto_sign_SECRETKEYBYTES");
#endif /* VANILLA_NACL */
bool create_extended_keypair(uint8_t *pk, uint8_t *sk)
{
#ifdef VANILLA_NACL
return false;
#else
/* create signature key pair */
crypto_sign_keypair(pk + ENC_PUBLIC_KEY_SIZE, sk + ENC_SECRET_KEY_SIZE);
@ -87,7 +68,6 @@ bool create_extended_keypair(uint8_t *pk, uint8_t *sk)
const int res2 = crypto_sign_ed25519_sk_to_curve25519(sk, sk + ENC_SECRET_KEY_SIZE);
return res1 == 0 && res2 == 0;
#endif
}
const uint8_t *get_enc_key(const uint8_t *key)
@ -141,7 +121,7 @@ static void crypto_free(uint8_t *ptr, size_t bytes)
void crypto_memzero(void *data, size_t length)
{
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) || defined(VANILLA_NACL)
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
memset(data, 0, length);
#else
sodium_memzero(data, length);
@ -150,7 +130,7 @@ void crypto_memzero(void *data, size_t length)
bool crypto_memlock(void *data, size_t length)
{
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) || defined(VANILLA_NACL)
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
return false;
#else
@ -164,7 +144,7 @@ bool crypto_memlock(void *data, size_t length)
bool crypto_memunlock(void *data, size_t length)
{
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) || defined(VANILLA_NACL)
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
return false;
#else
@ -196,10 +176,6 @@ bool crypto_sha512_eq(const uint8_t *cksum1, const uint8_t *cksum2)
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
// Hope that this is better for the fuzzer
return memcmp(cksum1, cksum2, CRYPTO_SHA512_SIZE) == 0;
#elif defined(VANILLA_NACL)
const int lo = crypto_verify_32(cksum1, cksum2) == 0 ? 1 : 0;
const int hi = crypto_verify_32(cksum1 + 8, cksum2 + 8) == 0 ? 1 : 0;
return (lo & hi) == 1;
#else
return crypto_verify_64(cksum1, cksum2) == 0;
#endif
@ -251,21 +227,13 @@ uint32_t random_range_u32(const Random *rng, uint32_t upper_bound)
bool crypto_signature_create(uint8_t *signature, const uint8_t *message, uint64_t message_length,
const uint8_t *secret_key)
{
#ifdef VANILLA_NACL
return false;
#else
return crypto_sign_detached(signature, nullptr, message, message_length, secret_key) == 0;
#endif // VANILLA_NACL
}
bool crypto_signature_verify(const uint8_t *signature, const uint8_t *message, uint64_t message_length,
const uint8_t *public_key)
{
#ifdef VANILLA_NACL
return false;
#else
return crypto_sign_verify_detached(signature, message, message_length, public_key) == 0;
#endif
}
bool public_key_valid(const uint8_t *public_key)
@ -539,17 +507,7 @@ static void sys_random_bytes(void *obj, uint8_t *bytes, size_t length)
non_null()
static uint32_t sys_random_uniform(void *obj, uint32_t upper_bound)
{
#ifdef VANILLA_NACL
if (upper_bound == 0) {
return 0;
}
uint32_t randnum;
sys_random_bytes(obj, (uint8_t *)&randnum, sizeof(randnum));
return randnum % upper_bound;
#else
return randombytes_uniform(upper_bound);
#endif
}
static const Random_Funcs system_random_funcs = {
@ -566,13 +524,11 @@ const Random *system_random(void)
return nullptr;
}
#endif
#ifndef VANILLA_NACL
// It is safe to call this function more than once and from different
// threads -- subsequent calls won't have any effects.
if (sodium_init() == -1) {
return nullptr;
}
#endif
return &system_random_obj;
}

3
external/toxcore/c-toxcore/toxcore/crypto_core.h vendored
View File

@ -235,8 +235,7 @@ uint64_t random_u64(const Random *rng);
/**
* @brief Return a random 32 bit integer between 0 and upper_bound (excluded).
*
* On libsodium builds this function guarantees a uniform distribution of possible outputs.
* On vanilla NACL builds this function is equivalent to `random() % upper_bound`.
* This function guarantees a uniform distribution of possible outputs.
*/
non_null()
uint32_t random_range_u32(const Random *rng, uint32_t upper_bound);

182
external/toxcore/c-toxcore/toxcore/events/conference_connected.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -26,6 +27,19 @@ struct Tox_Event_Conference_Connected {
uint32_t conference_number;
};
non_null()
static void tox_event_conference_connected_set_conference_number(Tox_Event_Conference_Connected *conference_connected,
uint32_t conference_number)
{
assert(conference_connected != nullptr);
conference_connected->conference_number = conference_number;
}
uint32_t tox_event_conference_connected_get_conference_number(const Tox_Event_Conference_Connected *conference_connected)
{
assert(conference_connected != nullptr);
return conference_connected->conference_number;
}
non_null()
static void tox_event_conference_connected_construct(Tox_Event_Conference_Connected *conference_connected)
{
@ -34,27 +48,12 @@ static void tox_event_conference_connected_construct(Tox_Event_Conference_Connec
};
}
non_null()
static void tox_event_conference_connected_destruct(Tox_Event_Conference_Connected *conference_connected)
static void tox_event_conference_connected_destruct(Tox_Event_Conference_Connected *conference_connected, const Memory *mem)
{
return;
}
non_null()
static void tox_event_conference_connected_set_conference_number(
Tox_Event_Conference_Connected *conference_connected, uint32_t conference_number)
{
assert(conference_connected != nullptr);
conference_connected->conference_number = conference_number;
}
uint32_t tox_event_conference_connected_get_conference_number(
const Tox_Event_Conference_Connected *conference_connected)
{
assert(conference_connected != nullptr);
return conference_connected->conference_number;
}
non_null()
static bool tox_event_conference_connected_pack(
bool tox_event_conference_connected_pack(
const Tox_Event_Conference_Connected *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -64,7 +63,7 @@ static bool tox_event_conference_connected_pack(
}
non_null()
static bool tox_event_conference_connected_unpack(
static bool tox_event_conference_connected_unpack_into(
Tox_Event_Conference_Connected *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -74,93 +73,121 @@ static bool tox_event_conference_connected_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Conference_Connected *tox_events_add_conference_connected(Tox_Events *events)
const Tox_Event_Conference_Connected *tox_event_get_conference_connected(const Tox_Event *event)
{
if (events->conference_connected_size == UINT32_MAX) {
return event->type == TOX_EVENT_CONFERENCE_CONNECTED ? event->data.conference_connected : nullptr;
}
Tox_Event_Conference_Connected *tox_event_conference_connected_new(const Memory *mem)
{
Tox_Event_Conference_Connected *const conference_connected =
(Tox_Event_Conference_Connected *)mem_alloc(mem, sizeof(Tox_Event_Conference_Connected));
if (conference_connected == nullptr) {
return nullptr;
}
if (events->conference_connected_size == events->conference_connected_capacity) {
const uint32_t new_conference_connected_capacity = events->conference_connected_capacity * 2 + 1;
Tox_Event_Conference_Connected *new_conference_connected = (Tox_Event_Conference_Connected *)realloc(
events->conference_connected, new_conference_connected_capacity * sizeof(Tox_Event_Conference_Connected));
if (new_conference_connected == nullptr) {
return nullptr;
}
events->conference_connected = new_conference_connected;
events->conference_connected_capacity = new_conference_connected_capacity;
}
Tox_Event_Conference_Connected *const conference_connected =
&events->conference_connected[events->conference_connected_size];
tox_event_conference_connected_construct(conference_connected);
++events->conference_connected_size;
return conference_connected;
}
void tox_events_clear_conference_connected(Tox_Events *events)
void tox_event_conference_connected_free(Tox_Event_Conference_Connected *conference_connected, const Memory *mem)
{
if (events == nullptr) {
return;
if (conference_connected != nullptr) {
tox_event_conference_connected_destruct(conference_connected, mem);
}
for (uint32_t i = 0; i < events->conference_connected_size; ++i) {
tox_event_conference_connected_destruct(&events->conference_connected[i]);
}
free(events->conference_connected);
events->conference_connected = nullptr;
events->conference_connected_size = 0;
events->conference_connected_capacity = 0;
mem_delete(mem, conference_connected);
}
uint32_t tox_events_get_conference_connected_size(const Tox_Events *events)
non_null()
static Tox_Event_Conference_Connected *tox_events_add_conference_connected(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Conference_Connected *const conference_connected = tox_event_conference_connected_new(mem);
if (conference_connected == nullptr) {
return nullptr;
}
return events->conference_connected_size;
Tox_Event event;
event.type = TOX_EVENT_CONFERENCE_CONNECTED;
event.data.conference_connected = conference_connected;
tox_events_add(events, &event);
return conference_connected;
}
const Tox_Event_Conference_Connected *tox_events_get_conference_connected(const Tox_Events *events, uint32_t index)
{
assert(index < events->conference_connected_size);
assert(events->conference_connected != nullptr);
return &events->conference_connected[index];
}
bool tox_events_pack_conference_connected(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_conference_connected_size(events);
uint32_t conference_connected_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_conference_connected_pack(tox_events_get_conference_connected(events, i), bp)) {
return false;
if (conference_connected_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_CONNECTED) {
const Tox_Event_Conference_Connected *conference_connected = events->events[i].data.conference_connected;
if (conference_connected_index == index) {
return conference_connected;
}
++conference_connected_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_conference_connected(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_conference_connected_size(const Tox_Events *events)
{
Tox_Event_Conference_Connected *event = tox_events_add_conference_connected(events);
uint32_t conference_connected_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_CONNECTED) {
++conference_connected_size;
}
}
return conference_connected_size;
}
bool tox_event_conference_connected_unpack(
Tox_Event_Conference_Connected **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_conference_connected_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_conference_connected_unpack(event, bu);
return tox_event_conference_connected_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Conference_Connected *tox_event_conference_connected_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Conference_Connected *conference_connected = tox_events_add_conference_connected(state->events, state->mem);
if (conference_connected == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return conference_connected;
}
/*****************************************************
@ -170,19 +197,12 @@ bool tox_events_unpack_conference_connected(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
void tox_events_handle_conference_connected(Tox *tox, uint32_t conference_number, void *user_data)
void tox_events_handle_conference_connected(Tox *tox, uint32_t conference_number,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Conference_Connected *conference_connected = tox_events_add_conference_connected(state->events);
Tox_Event_Conference_Connected *conference_connected = tox_event_conference_connected_alloc(user_data);
if (conference_connected == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

179
external/toxcore/c-toxcore/toxcore/events/conference_invite.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -30,19 +30,6 @@ struct Tox_Event_Conference_Invite {
uint32_t cookie_length;
};
non_null()
static void tox_event_conference_invite_construct(Tox_Event_Conference_Invite *conference_invite)
{
*conference_invite = (Tox_Event_Conference_Invite) {
0
};
}
non_null()
static void tox_event_conference_invite_destruct(Tox_Event_Conference_Invite *conference_invite)
{
free(conference_invite->cookie);
}
non_null()
static void tox_event_conference_invite_set_friend_number(Tox_Event_Conference_Invite *conference_invite,
uint32_t friend_number)
@ -103,7 +90,19 @@ const uint8_t *tox_event_conference_invite_get_cookie(const Tox_Event_Conference
}
non_null()
static bool tox_event_conference_invite_pack(
static void tox_event_conference_invite_construct(Tox_Event_Conference_Invite *conference_invite)
{
*conference_invite = (Tox_Event_Conference_Invite) {
0
};
}
non_null()
static void tox_event_conference_invite_destruct(Tox_Event_Conference_Invite *conference_invite, const Memory *mem)
{
free(conference_invite->cookie);
}
bool tox_event_conference_invite_pack(
const Tox_Event_Conference_Invite *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -116,7 +115,7 @@ static bool tox_event_conference_invite_pack(
}
non_null()
static bool tox_event_conference_invite_unpack(
static bool tox_event_conference_invite_unpack_into(
Tox_Event_Conference_Invite *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -125,97 +124,127 @@ static bool tox_event_conference_invite_unpack(
}
return bin_unpack_u32(bu, &event->friend_number)
&& tox_unpack_conference_type(bu, &event->type)
&& tox_conference_type_unpack(bu, &event->type)
&& bin_unpack_bin(bu, &event->cookie, &event->cookie_length);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Conference_Invite *tox_events_add_conference_invite(Tox_Events *events)
const Tox_Event_Conference_Invite *tox_event_get_conference_invite(const Tox_Event *event)
{
if (events->conference_invite_size == UINT32_MAX) {
return event->type == TOX_EVENT_CONFERENCE_INVITE ? event->data.conference_invite : nullptr;
}
Tox_Event_Conference_Invite *tox_event_conference_invite_new(const Memory *mem)
{
Tox_Event_Conference_Invite *const conference_invite =
(Tox_Event_Conference_Invite *)mem_alloc(mem, sizeof(Tox_Event_Conference_Invite));
if (conference_invite == nullptr) {
return nullptr;
}
if (events->conference_invite_size == events->conference_invite_capacity) {
const uint32_t new_conference_invite_capacity = events->conference_invite_capacity * 2 + 1;
Tox_Event_Conference_Invite *new_conference_invite = (Tox_Event_Conference_Invite *)realloc(
events->conference_invite, new_conference_invite_capacity * sizeof(Tox_Event_Conference_Invite));
if (new_conference_invite == nullptr) {
return nullptr;
}
events->conference_invite = new_conference_invite;
events->conference_invite_capacity = new_conference_invite_capacity;
}
Tox_Event_Conference_Invite *const conference_invite = &events->conference_invite[events->conference_invite_size];
tox_event_conference_invite_construct(conference_invite);
++events->conference_invite_size;
return conference_invite;
}
void tox_events_clear_conference_invite(Tox_Events *events)
void tox_event_conference_invite_free(Tox_Event_Conference_Invite *conference_invite, const Memory *mem)
{
if (events == nullptr) {
return;
if (conference_invite != nullptr) {
tox_event_conference_invite_destruct(conference_invite, mem);
}
for (uint32_t i = 0; i < events->conference_invite_size; ++i) {
tox_event_conference_invite_destruct(&events->conference_invite[i]);
}
free(events->conference_invite);
events->conference_invite = nullptr;
events->conference_invite_size = 0;
events->conference_invite_capacity = 0;
mem_delete(mem, conference_invite);
}
uint32_t tox_events_get_conference_invite_size(const Tox_Events *events)
non_null()
static Tox_Event_Conference_Invite *tox_events_add_conference_invite(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Conference_Invite *const conference_invite = tox_event_conference_invite_new(mem);
if (conference_invite == nullptr) {
return nullptr;
}
return events->conference_invite_size;
Tox_Event event;
event.type = TOX_EVENT_CONFERENCE_INVITE;
event.data.conference_invite = conference_invite;
tox_events_add(events, &event);
return conference_invite;
}
const Tox_Event_Conference_Invite *tox_events_get_conference_invite(const Tox_Events *events, uint32_t index)
{
assert(index < events->conference_invite_size);
assert(events->conference_invite != nullptr);
return &events->conference_invite[index];
}
bool tox_events_pack_conference_invite(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_conference_invite_size(events);
uint32_t conference_invite_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_conference_invite_pack(tox_events_get_conference_invite(events, i), bp)) {
return false;
if (conference_invite_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_INVITE) {
const Tox_Event_Conference_Invite *conference_invite = events->events[i].data.conference_invite;
if (conference_invite_index == index) {
return conference_invite;
}
++conference_invite_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_conference_invite(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_conference_invite_size(const Tox_Events *events)
{
Tox_Event_Conference_Invite *event = tox_events_add_conference_invite(events);
uint32_t conference_invite_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_INVITE) {
++conference_invite_size;
}
}
return conference_invite_size;
}
bool tox_event_conference_invite_unpack(
Tox_Event_Conference_Invite **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_conference_invite_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_conference_invite_unpack(event, bu);
return tox_event_conference_invite_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Conference_Invite *tox_event_conference_invite_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Conference_Invite *conference_invite = tox_events_add_conference_invite(state->events, state->mem);
if (conference_invite == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return conference_invite;
}
@ -226,20 +255,12 @@ bool tox_events_unpack_conference_invite(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Conference_Invite *conference_invite = tox_events_add_conference_invite(state->events);
Tox_Event_Conference_Invite *conference_invite = tox_event_conference_invite_alloc(user_data);
if (conference_invite == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

179
external/toxcore/c-toxcore/toxcore/events/conference_message.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -31,19 +31,6 @@ struct Tox_Event_Conference_Message {
uint32_t message_length;
};
non_null()
static void tox_event_conference_message_construct(Tox_Event_Conference_Message *conference_message)
{
*conference_message = (Tox_Event_Conference_Message) {
0
};
}
non_null()
static void tox_event_conference_message_destruct(Tox_Event_Conference_Message *conference_message)
{
free(conference_message->message);
}
non_null()
static void tox_event_conference_message_set_conference_number(Tox_Event_Conference_Message *conference_message,
uint32_t conference_number)
@ -117,7 +104,19 @@ const uint8_t *tox_event_conference_message_get_message(const Tox_Event_Conferen
}
non_null()
static bool tox_event_conference_message_pack(
static void tox_event_conference_message_construct(Tox_Event_Conference_Message *conference_message)
{
*conference_message = (Tox_Event_Conference_Message) {
0
};
}
non_null()
static void tox_event_conference_message_destruct(Tox_Event_Conference_Message *conference_message, const Memory *mem)
{
free(conference_message->message);
}
bool tox_event_conference_message_pack(
const Tox_Event_Conference_Message *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -131,7 +130,7 @@ static bool tox_event_conference_message_pack(
}
non_null()
static bool tox_event_conference_message_unpack(
static bool tox_event_conference_message_unpack_into(
Tox_Event_Conference_Message *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -141,97 +140,127 @@ static bool tox_event_conference_message_unpack(
return bin_unpack_u32(bu, &event->conference_number)
&& bin_unpack_u32(bu, &event->peer_number)
&& tox_unpack_message_type(bu, &event->type)
&& tox_message_type_unpack(bu, &event->type)
&& bin_unpack_bin(bu, &event->message, &event->message_length);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Conference_Message *tox_events_add_conference_message(Tox_Events *events)
const Tox_Event_Conference_Message *tox_event_get_conference_message(const Tox_Event *event)
{
if (events->conference_message_size == UINT32_MAX) {
return event->type == TOX_EVENT_CONFERENCE_MESSAGE ? event->data.conference_message : nullptr;
}
Tox_Event_Conference_Message *tox_event_conference_message_new(const Memory *mem)
{
Tox_Event_Conference_Message *const conference_message =
(Tox_Event_Conference_Message *)mem_alloc(mem, sizeof(Tox_Event_Conference_Message));
if (conference_message == nullptr) {
return nullptr;
}
if (events->conference_message_size == events->conference_message_capacity) {
const uint32_t new_conference_message_capacity = events->conference_message_capacity * 2 + 1;
Tox_Event_Conference_Message *new_conference_message = (Tox_Event_Conference_Message *)realloc(
events->conference_message, new_conference_message_capacity * sizeof(Tox_Event_Conference_Message));
if (new_conference_message == nullptr) {
return nullptr;
}
events->conference_message = new_conference_message;
events->conference_message_capacity = new_conference_message_capacity;
}
Tox_Event_Conference_Message *const conference_message = &events->conference_message[events->conference_message_size];
tox_event_conference_message_construct(conference_message);
++events->conference_message_size;
return conference_message;
}
void tox_events_clear_conference_message(Tox_Events *events)
void tox_event_conference_message_free(Tox_Event_Conference_Message *conference_message, const Memory *mem)
{
if (events == nullptr) {
return;
if (conference_message != nullptr) {
tox_event_conference_message_destruct(conference_message, mem);
}
for (uint32_t i = 0; i < events->conference_message_size; ++i) {
tox_event_conference_message_destruct(&events->conference_message[i]);
}
free(events->conference_message);
events->conference_message = nullptr;
events->conference_message_size = 0;
events->conference_message_capacity = 0;
mem_delete(mem, conference_message);
}
uint32_t tox_events_get_conference_message_size(const Tox_Events *events)
non_null()
static Tox_Event_Conference_Message *tox_events_add_conference_message(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Conference_Message *const conference_message = tox_event_conference_message_new(mem);
if (conference_message == nullptr) {
return nullptr;
}
return events->conference_message_size;
Tox_Event event;
event.type = TOX_EVENT_CONFERENCE_MESSAGE;
event.data.conference_message = conference_message;
tox_events_add(events, &event);
return conference_message;
}
const Tox_Event_Conference_Message *tox_events_get_conference_message(const Tox_Events *events, uint32_t index)
{
assert(index < events->conference_message_size);
assert(events->conference_message != nullptr);
return &events->conference_message[index];
}
bool tox_events_pack_conference_message(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_conference_message_size(events);
uint32_t conference_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_conference_message_pack(tox_events_get_conference_message(events, i), bp)) {
return false;
if (conference_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_MESSAGE) {
const Tox_Event_Conference_Message *conference_message = events->events[i].data.conference_message;
if (conference_message_index == index) {
return conference_message;
}
++conference_message_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_conference_message(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_conference_message_size(const Tox_Events *events)
{
Tox_Event_Conference_Message *event = tox_events_add_conference_message(events);
uint32_t conference_message_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_MESSAGE) {
++conference_message_size;
}
}
return conference_message_size;
}
bool tox_event_conference_message_unpack(
Tox_Event_Conference_Message **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_conference_message_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_conference_message_unpack(event, bu);
return tox_event_conference_message_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Conference_Message *tox_event_conference_message_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Conference_Message *conference_message = tox_events_add_conference_message(state->events, state->mem);
if (conference_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return conference_message;
}
@ -242,20 +271,12 @@ bool tox_events_unpack_conference_message(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Conference_Message *conference_message = tox_events_add_conference_message(state->events);
Tox_Event_Conference_Message *conference_message = tox_event_conference_message_alloc(user_data);
if (conference_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

195
external/toxcore/c-toxcore/toxcore/events/conference_peer_list_changed.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -27,36 +28,32 @@ struct Tox_Event_Conference_Peer_List_Changed {
};
non_null()
static void tox_event_conference_peer_list_changed_construct(Tox_Event_Conference_Peer_List_Changed
*conference_peer_list_changed)
{
*conference_peer_list_changed = (Tox_Event_Conference_Peer_List_Changed) {
0
};
}
non_null()
static void tox_event_conference_peer_list_changed_destruct(Tox_Event_Conference_Peer_List_Changed
*conference_peer_list_changed)
{
return;
}
non_null()
static void tox_event_conference_peer_list_changed_set_conference_number(Tox_Event_Conference_Peer_List_Changed
*conference_peer_list_changed, uint32_t conference_number)
static void tox_event_conference_peer_list_changed_set_conference_number(Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed,
uint32_t conference_number)
{
assert(conference_peer_list_changed != nullptr);
conference_peer_list_changed->conference_number = conference_number;
}
uint32_t tox_event_conference_peer_list_changed_get_conference_number(const Tox_Event_Conference_Peer_List_Changed
*conference_peer_list_changed)
uint32_t tox_event_conference_peer_list_changed_get_conference_number(const Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed)
{
assert(conference_peer_list_changed != nullptr);
return conference_peer_list_changed->conference_number;
}
non_null()
static bool tox_event_conference_peer_list_changed_pack(
static void tox_event_conference_peer_list_changed_construct(Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed)
{
*conference_peer_list_changed = (Tox_Event_Conference_Peer_List_Changed) {
0
};
}
non_null()
static void tox_event_conference_peer_list_changed_destruct(Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed, const Memory *mem)
{
return;
}
bool tox_event_conference_peer_list_changed_pack(
const Tox_Event_Conference_Peer_List_Changed *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -66,7 +63,7 @@ static bool tox_event_conference_peer_list_changed_pack(
}
non_null()
static bool tox_event_conference_peer_list_changed_unpack(
static bool tox_event_conference_peer_list_changed_unpack_into(
Tox_Event_Conference_Peer_List_Changed *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -76,94 +73,120 @@ static bool tox_event_conference_peer_list_changed_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Conference_Peer_List_Changed *tox_events_add_conference_peer_list_changed(Tox_Events *events)
const Tox_Event_Conference_Peer_List_Changed *tox_event_get_conference_peer_list_changed(const Tox_Event *event)
{
if (events->conference_peer_list_changed_size == UINT32_MAX) {
return event->type == TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED ? event->data.conference_peer_list_changed : nullptr;
}
Tox_Event_Conference_Peer_List_Changed *tox_event_conference_peer_list_changed_new(const Memory *mem)
{
Tox_Event_Conference_Peer_List_Changed *const conference_peer_list_changed =
(Tox_Event_Conference_Peer_List_Changed *)mem_alloc(mem, sizeof(Tox_Event_Conference_Peer_List_Changed));
if (conference_peer_list_changed == nullptr) {
return nullptr;
}
if (events->conference_peer_list_changed_size == events->conference_peer_list_changed_capacity) {
const uint32_t new_conference_peer_list_changed_capacity = events->conference_peer_list_changed_capacity * 2 + 1;
Tox_Event_Conference_Peer_List_Changed *new_conference_peer_list_changed = (Tox_Event_Conference_Peer_List_Changed *)
realloc(
events->conference_peer_list_changed,
new_conference_peer_list_changed_capacity * sizeof(Tox_Event_Conference_Peer_List_Changed));
if (new_conference_peer_list_changed == nullptr) {
return nullptr;
}
events->conference_peer_list_changed = new_conference_peer_list_changed;
events->conference_peer_list_changed_capacity = new_conference_peer_list_changed_capacity;
}
Tox_Event_Conference_Peer_List_Changed *const conference_peer_list_changed =
&events->conference_peer_list_changed[events->conference_peer_list_changed_size];
tox_event_conference_peer_list_changed_construct(conference_peer_list_changed);
++events->conference_peer_list_changed_size;
return conference_peer_list_changed;
}
void tox_events_clear_conference_peer_list_changed(Tox_Events *events)
void tox_event_conference_peer_list_changed_free(Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed, const Memory *mem)
{
if (events == nullptr) {
return;
if (conference_peer_list_changed != nullptr) {
tox_event_conference_peer_list_changed_destruct(conference_peer_list_changed, mem);
}
mem_delete(mem, conference_peer_list_changed);
}
non_null()
static Tox_Event_Conference_Peer_List_Changed *tox_events_add_conference_peer_list_changed(Tox_Events *events, const Memory *mem)
{
Tox_Event_Conference_Peer_List_Changed *const conference_peer_list_changed = tox_event_conference_peer_list_changed_new(mem);
if (conference_peer_list_changed == nullptr) {
return nullptr;
}
for (uint32_t i = 0; i < events->conference_peer_list_changed_size; ++i) {
tox_event_conference_peer_list_changed_destruct(&events->conference_peer_list_changed[i]);
Tox_Event event;
event.type = TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED;
event.data.conference_peer_list_changed = conference_peer_list_changed;
tox_events_add(events, &event);
return conference_peer_list_changed;
}
const Tox_Event_Conference_Peer_List_Changed *tox_events_get_conference_peer_list_changed(const Tox_Events *events, uint32_t index)
{
uint32_t conference_peer_list_changed_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (conference_peer_list_changed_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED) {
const Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed = events->events[i].data.conference_peer_list_changed;
if (conference_peer_list_changed_index == index) {
return conference_peer_list_changed;
}
++conference_peer_list_changed_index;
}
}
free(events->conference_peer_list_changed);
events->conference_peer_list_changed = nullptr;
events->conference_peer_list_changed_size = 0;
events->conference_peer_list_changed_capacity = 0;
return nullptr;
}
uint32_t tox_events_get_conference_peer_list_changed_size(const Tox_Events *events)
{
if (events == nullptr) {
return 0;
}
return events->conference_peer_list_changed_size;
}
const Tox_Event_Conference_Peer_List_Changed *tox_events_get_conference_peer_list_changed(const Tox_Events *events,
uint32_t index)
{
assert(index < events->conference_peer_list_changed_size);
assert(events->conference_peer_list_changed != nullptr);
return &events->conference_peer_list_changed[index];
}
bool tox_events_pack_conference_peer_list_changed(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_conference_peer_list_changed_size(events);
uint32_t conference_peer_list_changed_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_conference_peer_list_changed_pack(tox_events_get_conference_peer_list_changed(events, i), bp)) {
return false;
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED) {
++conference_peer_list_changed_size;
}
}
return true;
return conference_peer_list_changed_size;
}
bool tox_events_unpack_conference_peer_list_changed(Tox_Events *events, Bin_Unpack *bu)
bool tox_event_conference_peer_list_changed_unpack(
Tox_Event_Conference_Peer_List_Changed **event, Bin_Unpack *bu, const Memory *mem)
{
Tox_Event_Conference_Peer_List_Changed *event = tox_events_add_conference_peer_list_changed(events);
assert(event != nullptr);
*event = tox_event_conference_peer_list_changed_new(mem);
if (event == nullptr) {
if (*event == nullptr) {
return false;
}
return tox_event_conference_peer_list_changed_unpack(event, bu);
return tox_event_conference_peer_list_changed_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Conference_Peer_List_Changed *tox_event_conference_peer_list_changed_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed = tox_events_add_conference_peer_list_changed(state->events, state->mem);
if (conference_peer_list_changed == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return conference_peer_list_changed;
}
@ -174,20 +197,12 @@ bool tox_events_unpack_conference_peer_list_changed(Tox_Events *events, Bin_Unpa
*****************************************************/
void tox_events_handle_conference_peer_list_changed(Tox *tox, uint32_t conference_number, void *user_data)
void tox_events_handle_conference_peer_list_changed(Tox *tox, uint32_t conference_number,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed = tox_events_add_conference_peer_list_changed(
state->events);
Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed = tox_event_conference_peer_list_changed_alloc(user_data);
if (conference_peer_list_changed == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

182
external/toxcore/c-toxcore/toxcore/events/conference_peer_name.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -29,19 +30,6 @@ struct Tox_Event_Conference_Peer_Name {
uint32_t name_length;
};
non_null()
static void tox_event_conference_peer_name_construct(Tox_Event_Conference_Peer_Name *conference_peer_name)
{
*conference_peer_name = (Tox_Event_Conference_Peer_Name) {
0
};
}
non_null()
static void tox_event_conference_peer_name_destruct(Tox_Event_Conference_Peer_Name *conference_peer_name)
{
free(conference_peer_name->name);
}
non_null()
static void tox_event_conference_peer_name_set_conference_number(Tox_Event_Conference_Peer_Name *conference_peer_name,
uint32_t conference_number)
@ -49,8 +37,7 @@ static void tox_event_conference_peer_name_set_conference_number(Tox_Event_Confe
assert(conference_peer_name != nullptr);
conference_peer_name->conference_number = conference_number;
}
uint32_t tox_event_conference_peer_name_get_conference_number(const Tox_Event_Conference_Peer_Name
*conference_peer_name)
uint32_t tox_event_conference_peer_name_get_conference_number(const Tox_Event_Conference_Peer_Name *conference_peer_name)
{
assert(conference_peer_name != nullptr);
return conference_peer_name->conference_number;
@ -103,7 +90,19 @@ const uint8_t *tox_event_conference_peer_name_get_name(const Tox_Event_Conferenc
}
non_null()
static bool tox_event_conference_peer_name_pack(
static void tox_event_conference_peer_name_construct(Tox_Event_Conference_Peer_Name *conference_peer_name)
{
*conference_peer_name = (Tox_Event_Conference_Peer_Name) {
0
};
}
non_null()
static void tox_event_conference_peer_name_destruct(Tox_Event_Conference_Peer_Name *conference_peer_name, const Memory *mem)
{
free(conference_peer_name->name);
}
bool tox_event_conference_peer_name_pack(
const Tox_Event_Conference_Peer_Name *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -116,7 +115,7 @@ static bool tox_event_conference_peer_name_pack(
}
non_null()
static bool tox_event_conference_peer_name_unpack(
static bool tox_event_conference_peer_name_unpack_into(
Tox_Event_Conference_Peer_Name *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -132,91 +131,120 @@ static bool tox_event_conference_peer_name_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Conference_Peer_Name *tox_events_add_conference_peer_name(Tox_Events *events)
const Tox_Event_Conference_Peer_Name *tox_event_get_conference_peer_name(const Tox_Event *event)
{
if (events->conference_peer_name_size == UINT32_MAX) {
return event->type == TOX_EVENT_CONFERENCE_PEER_NAME ? event->data.conference_peer_name : nullptr;
}
Tox_Event_Conference_Peer_Name *tox_event_conference_peer_name_new(const Memory *mem)
{
Tox_Event_Conference_Peer_Name *const conference_peer_name =
(Tox_Event_Conference_Peer_Name *)mem_alloc(mem, sizeof(Tox_Event_Conference_Peer_Name));
if (conference_peer_name == nullptr) {
return nullptr;
}
if (events->conference_peer_name_size == events->conference_peer_name_capacity) {
const uint32_t new_conference_peer_name_capacity = events->conference_peer_name_capacity * 2 + 1;
Tox_Event_Conference_Peer_Name *new_conference_peer_name = (Tox_Event_Conference_Peer_Name *)realloc(
events->conference_peer_name, new_conference_peer_name_capacity * sizeof(Tox_Event_Conference_Peer_Name));
if (new_conference_peer_name == nullptr) {
return nullptr;
}
events->conference_peer_name = new_conference_peer_name;
events->conference_peer_name_capacity = new_conference_peer_name_capacity;
}
Tox_Event_Conference_Peer_Name *const conference_peer_name =
&events->conference_peer_name[events->conference_peer_name_size];
tox_event_conference_peer_name_construct(conference_peer_name);
++events->conference_peer_name_size;
return conference_peer_name;
}
void tox_events_clear_conference_peer_name(Tox_Events *events)
void tox_event_conference_peer_name_free(Tox_Event_Conference_Peer_Name *conference_peer_name, const Memory *mem)
{
if (events == nullptr) {
return;
if (conference_peer_name != nullptr) {
tox_event_conference_peer_name_destruct(conference_peer_name, mem);
}
for (uint32_t i = 0; i < events->conference_peer_name_size; ++i) {
tox_event_conference_peer_name_destruct(&events->conference_peer_name[i]);
}
free(events->conference_peer_name);
events->conference_peer_name = nullptr;
events->conference_peer_name_size = 0;
events->conference_peer_name_capacity = 0;
mem_delete(mem, conference_peer_name);
}
uint32_t tox_events_get_conference_peer_name_size(const Tox_Events *events)
non_null()
static Tox_Event_Conference_Peer_Name *tox_events_add_conference_peer_name(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Conference_Peer_Name *const conference_peer_name = tox_event_conference_peer_name_new(mem);
if (conference_peer_name == nullptr) {
return nullptr;
}
return events->conference_peer_name_size;
Tox_Event event;
event.type = TOX_EVENT_CONFERENCE_PEER_NAME;
event.data.conference_peer_name = conference_peer_name;
tox_events_add(events, &event);
return conference_peer_name;
}
const Tox_Event_Conference_Peer_Name *tox_events_get_conference_peer_name(const Tox_Events *events, uint32_t index)
{
assert(index < events->conference_peer_name_size);
assert(events->conference_peer_name != nullptr);
return &events->conference_peer_name[index];
}
bool tox_events_pack_conference_peer_name(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_conference_peer_name_size(events);
uint32_t conference_peer_name_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_conference_peer_name_pack(tox_events_get_conference_peer_name(events, i), bp)) {
return false;
if (conference_peer_name_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_NAME) {
const Tox_Event_Conference_Peer_Name *conference_peer_name = events->events[i].data.conference_peer_name;
if (conference_peer_name_index == index) {
return conference_peer_name;
}
++conference_peer_name_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_conference_peer_name(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_conference_peer_name_size(const Tox_Events *events)
{
Tox_Event_Conference_Peer_Name *event = tox_events_add_conference_peer_name(events);
uint32_t conference_peer_name_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_PEER_NAME) {
++conference_peer_name_size;
}
}
return conference_peer_name_size;
}
bool tox_event_conference_peer_name_unpack(
Tox_Event_Conference_Peer_Name **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_conference_peer_name_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_conference_peer_name_unpack(event, bu);
return tox_event_conference_peer_name_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Conference_Peer_Name *tox_event_conference_peer_name_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Conference_Peer_Name *conference_peer_name = tox_events_add_conference_peer_name(state->events, state->mem);
if (conference_peer_name == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return conference_peer_name;
}
@ -227,20 +255,12 @@ bool tox_events_unpack_conference_peer_name(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Conference_Peer_Name *conference_peer_name = tox_events_add_conference_peer_name(state->events);
Tox_Event_Conference_Peer_Name *conference_peer_name = tox_event_conference_peer_name_alloc(user_data);
if (conference_peer_name == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

182
external/toxcore/c-toxcore/toxcore/events/conference_title.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -29,19 +30,6 @@ struct Tox_Event_Conference_Title {
uint32_t title_length;
};
non_null()
static void tox_event_conference_title_construct(Tox_Event_Conference_Title *conference_title)
{
*conference_title = (Tox_Event_Conference_Title) {
0
};
}
non_null()
static void tox_event_conference_title_destruct(Tox_Event_Conference_Title *conference_title)
{
free(conference_title->title);
}
non_null()
static void tox_event_conference_title_set_conference_number(Tox_Event_Conference_Title *conference_title,
uint32_t conference_number)
@ -69,8 +57,8 @@ uint32_t tox_event_conference_title_get_peer_number(const Tox_Event_Conference_T
}
non_null()
static bool tox_event_conference_title_set_title(Tox_Event_Conference_Title *conference_title, const uint8_t *title,
uint32_t title_length)
static bool tox_event_conference_title_set_title(Tox_Event_Conference_Title *conference_title,
const uint8_t *title, uint32_t title_length)
{
assert(conference_title != nullptr);
@ -102,7 +90,19 @@ const uint8_t *tox_event_conference_title_get_title(const Tox_Event_Conference_T
}
non_null()
static bool tox_event_conference_title_pack(
static void tox_event_conference_title_construct(Tox_Event_Conference_Title *conference_title)
{
*conference_title = (Tox_Event_Conference_Title) {
0
};
}
non_null()
static void tox_event_conference_title_destruct(Tox_Event_Conference_Title *conference_title, const Memory *mem)
{
free(conference_title->title);
}
bool tox_event_conference_title_pack(
const Tox_Event_Conference_Title *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -115,7 +115,7 @@ static bool tox_event_conference_title_pack(
}
non_null()
static bool tox_event_conference_title_unpack(
static bool tox_event_conference_title_unpack_into(
Tox_Event_Conference_Title *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -131,90 +131,120 @@ static bool tox_event_conference_title_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Conference_Title *tox_events_add_conference_title(Tox_Events *events)
const Tox_Event_Conference_Title *tox_event_get_conference_title(const Tox_Event *event)
{
if (events->conference_title_size == UINT32_MAX) {
return event->type == TOX_EVENT_CONFERENCE_TITLE ? event->data.conference_title : nullptr;
}
Tox_Event_Conference_Title *tox_event_conference_title_new(const Memory *mem)
{
Tox_Event_Conference_Title *const conference_title =
(Tox_Event_Conference_Title *)mem_alloc(mem, sizeof(Tox_Event_Conference_Title));
if (conference_title == nullptr) {
return nullptr;
}
if (events->conference_title_size == events->conference_title_capacity) {
const uint32_t new_conference_title_capacity = events->conference_title_capacity * 2 + 1;
Tox_Event_Conference_Title *new_conference_title = (Tox_Event_Conference_Title *)realloc(
events->conference_title, new_conference_title_capacity * sizeof(Tox_Event_Conference_Title));
if (new_conference_title == nullptr) {
return nullptr;
}
events->conference_title = new_conference_title;
events->conference_title_capacity = new_conference_title_capacity;
}
Tox_Event_Conference_Title *const conference_title = &events->conference_title[events->conference_title_size];
tox_event_conference_title_construct(conference_title);
++events->conference_title_size;
return conference_title;
}
void tox_events_clear_conference_title(Tox_Events *events)
void tox_event_conference_title_free(Tox_Event_Conference_Title *conference_title, const Memory *mem)
{
if (events == nullptr) {
return;
if (conference_title != nullptr) {
tox_event_conference_title_destruct(conference_title, mem);
}
for (uint32_t i = 0; i < events->conference_title_size; ++i) {
tox_event_conference_title_destruct(&events->conference_title[i]);
}
free(events->conference_title);
events->conference_title = nullptr;
events->conference_title_size = 0;
events->conference_title_capacity = 0;
mem_delete(mem, conference_title);
}
uint32_t tox_events_get_conference_title_size(const Tox_Events *events)
non_null()
static Tox_Event_Conference_Title *tox_events_add_conference_title(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Conference_Title *const conference_title = tox_event_conference_title_new(mem);
if (conference_title == nullptr) {
return nullptr;
}
return events->conference_title_size;
Tox_Event event;
event.type = TOX_EVENT_CONFERENCE_TITLE;
event.data.conference_title = conference_title;
tox_events_add(events, &event);
return conference_title;
}
const Tox_Event_Conference_Title *tox_events_get_conference_title(const Tox_Events *events, uint32_t index)
{
assert(index < events->conference_title_size);
assert(events->conference_title != nullptr);
return &events->conference_title[index];
}
bool tox_events_pack_conference_title(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_conference_title_size(events);
uint32_t conference_title_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_conference_title_pack(tox_events_get_conference_title(events, i), bp)) {
return false;
if (conference_title_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_CONFERENCE_TITLE) {
const Tox_Event_Conference_Title *conference_title = events->events[i].data.conference_title;
if (conference_title_index == index) {
return conference_title;
}
++conference_title_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_conference_title(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_conference_title_size(const Tox_Events *events)
{
Tox_Event_Conference_Title *event = tox_events_add_conference_title(events);
uint32_t conference_title_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_CONFERENCE_TITLE) {
++conference_title_size;
}
}
return conference_title_size;
}
bool tox_event_conference_title_unpack(
Tox_Event_Conference_Title **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_conference_title_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_conference_title_unpack(event, bu);
return tox_event_conference_title_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Conference_Title *tox_event_conference_title_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Conference_Title *conference_title = tox_events_add_conference_title(state->events, state->mem);
if (conference_title == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return conference_title;
}
@ -225,20 +255,12 @@ bool tox_events_unpack_conference_title(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Conference_Title *conference_title = tox_events_add_conference_title(state->events);
Tox_Event_Conference_Title *conference_title = tox_event_conference_title_alloc(user_data);
if (conference_title == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

75
external/toxcore/c-toxcore/toxcore/events/events_alloc.c vendored
View File

@ -13,13 +13,14 @@ Tox_Events_State *tox_events_alloc(void *user_data)
{
Tox_Events_State *state = (Tox_Events_State *)user_data;
assert(state != nullptr);
assert(state->mem != nullptr);
if (state->events != nullptr) {
// Already allocated.
return state;
}
state->events = (Tox_Events *)calloc(1, sizeof(Tox_Events));
state->events = (Tox_Events *)mem_alloc(state->mem, sizeof(Tox_Events));
if (state->events == nullptr) {
// It's still null => allocation failed.
@ -28,6 +29,7 @@ Tox_Events_State *tox_events_alloc(void *user_data)
*state->events = (Tox_Events) {
nullptr
};
state->events->mem = state->mem;
}
return state;
@ -39,44 +41,35 @@ void tox_events_free(Tox_Events *events)
return;
}
tox_events_clear_conference_connected(events);
tox_events_clear_conference_invite(events);
tox_events_clear_conference_message(events);
tox_events_clear_conference_peer_list_changed(events);
tox_events_clear_conference_peer_name(events);
tox_events_clear_conference_title(events);
tox_events_clear_file_chunk_request(events);
tox_events_clear_file_recv_chunk(events);
tox_events_clear_file_recv_control(events);
tox_events_clear_file_recv(events);
tox_events_clear_friend_connection_status(events);
tox_events_clear_friend_lossless_packet(events);
tox_events_clear_friend_lossy_packet(events);
tox_events_clear_friend_message(events);
tox_events_clear_friend_name(events);
tox_events_clear_friend_read_receipt(events);
tox_events_clear_friend_request(events);
tox_events_clear_friend_status(events);
tox_events_clear_friend_status_message(events);
tox_events_clear_friend_typing(events);
tox_events_clear_self_connection_status(events);
tox_events_clear_group_peer_name(events);
tox_events_clear_group_peer_status(events);
tox_events_clear_group_topic(events);
tox_events_clear_group_privacy_state(events);
tox_events_clear_group_voice_state(events);
tox_events_clear_group_topic_lock(events);
tox_events_clear_group_peer_limit(events);
tox_events_clear_group_password(events);
tox_events_clear_group_message(events);
tox_events_clear_group_private_message(events);
tox_events_clear_group_custom_packet(events);
tox_events_clear_group_custom_private_packet(events);
tox_events_clear_group_invite(events);
tox_events_clear_group_peer_join(events);
tox_events_clear_group_peer_exit(events);
tox_events_clear_group_self_join(events);
tox_events_clear_group_join_fail(events);
tox_events_clear_group_moderation(events);
free(events);
for (uint32_t i = 0; i < events->events_size; ++i) {
tox_event_destruct(&events->events[i], events->mem);
}
mem_delete(events->mem, events->events);
mem_delete(events->mem, events);
}
bool tox_events_add(Tox_Events *events, const Tox_Event *event)
{
if (events->events_size == UINT32_MAX) {
return false;
}
if (events->events_size == events->events_capacity) {
const uint32_t new_events_capacity = events->events_capacity * 2 + 1;
Tox_Event *new_events = (Tox_Event *)mem_vrealloc(
events->mem, events->events, new_events_capacity, sizeof(Tox_Event));
if (new_events == nullptr) {
return false;
}
events->events = new_events;
events->events_capacity = new_events_capacity;
}
events->events[events->events_size] = *event;
++events->events_size;
return true;
}

299
external/toxcore/c-toxcore/toxcore/events/events_alloc.h vendored
View File

@ -8,172 +8,23 @@
#include "../attributes.h"
#include "../bin_pack.h"
#include "../bin_unpack.h"
#include "../tox_events.h"
#include "../tox_event.h"
#ifdef __cplusplus
extern "C" {
#endif
struct Tox_Events {
Tox_Event_Conference_Connected *conference_connected;
uint32_t conference_connected_size;
uint32_t conference_connected_capacity;
Tox_Event *events;
uint32_t events_size;
uint32_t events_capacity;
Tox_Event_Conference_Invite *conference_invite;
uint32_t conference_invite_size;
uint32_t conference_invite_capacity;
Tox_Event_Conference_Message *conference_message;
uint32_t conference_message_size;
uint32_t conference_message_capacity;
Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed;
uint32_t conference_peer_list_changed_size;
uint32_t conference_peer_list_changed_capacity;
Tox_Event_Conference_Peer_Name *conference_peer_name;
uint32_t conference_peer_name_size;
uint32_t conference_peer_name_capacity;
Tox_Event_Conference_Title *conference_title;
uint32_t conference_title_size;
uint32_t conference_title_capacity;
Tox_Event_File_Chunk_Request *file_chunk_request;
uint32_t file_chunk_request_size;
uint32_t file_chunk_request_capacity;
Tox_Event_File_Recv *file_recv;
uint32_t file_recv_size;
uint32_t file_recv_capacity;
Tox_Event_File_Recv_Chunk *file_recv_chunk;
uint32_t file_recv_chunk_size;
uint32_t file_recv_chunk_capacity;
Tox_Event_File_Recv_Control *file_recv_control;
uint32_t file_recv_control_size;
uint32_t file_recv_control_capacity;
Tox_Event_Friend_Connection_Status *friend_connection_status;
uint32_t friend_connection_status_size;
uint32_t friend_connection_status_capacity;
Tox_Event_Friend_Lossless_Packet *friend_lossless_packet;
uint32_t friend_lossless_packet_size;
uint32_t friend_lossless_packet_capacity;
Tox_Event_Friend_Lossy_Packet *friend_lossy_packet;
uint32_t friend_lossy_packet_size;
uint32_t friend_lossy_packet_capacity;
Tox_Event_Friend_Message *friend_message;
uint32_t friend_message_size;
uint32_t friend_message_capacity;
Tox_Event_Friend_Name *friend_name;
uint32_t friend_name_size;
uint32_t friend_name_capacity;
Tox_Event_Friend_Read_Receipt *friend_read_receipt;
uint32_t friend_read_receipt_size;
uint32_t friend_read_receipt_capacity;
Tox_Event_Friend_Request *friend_request;
uint32_t friend_request_size;
uint32_t friend_request_capacity;
Tox_Event_Friend_Status *friend_status;
uint32_t friend_status_size;
uint32_t friend_status_capacity;
Tox_Event_Friend_Status_Message *friend_status_message;
uint32_t friend_status_message_size;
uint32_t friend_status_message_capacity;
Tox_Event_Friend_Typing *friend_typing;
uint32_t friend_typing_size;
uint32_t friend_typing_capacity;
Tox_Event_Self_Connection_Status *self_connection_status;
uint32_t self_connection_status_size;
uint32_t self_connection_status_capacity;
Tox_Event_Group_Peer_Name *group_peer_name;
uint32_t group_peer_name_size;
uint32_t group_peer_name_capacity;
Tox_Event_Group_Peer_Status *group_peer_status;
uint32_t group_peer_status_size;
uint32_t group_peer_status_capacity;
Tox_Event_Group_Topic *group_topic;
uint32_t group_topic_size;
uint32_t group_topic_capacity;
Tox_Event_Group_Privacy_State *group_privacy_state;
uint32_t group_privacy_state_size;
uint32_t group_privacy_state_capacity;
Tox_Event_Group_Voice_State *group_voice_state;
uint32_t group_voice_state_size;
uint32_t group_voice_state_capacity;
Tox_Event_Group_Topic_Lock *group_topic_lock;
uint32_t group_topic_lock_size;
uint32_t group_topic_lock_capacity;
Tox_Event_Group_Peer_Limit *group_peer_limit;
uint32_t group_peer_limit_size;
uint32_t group_peer_limit_capacity;
Tox_Event_Group_Password *group_password;
uint32_t group_password_size;
uint32_t group_password_capacity;
Tox_Event_Group_Message *group_message;
uint32_t group_message_size;
uint32_t group_message_capacity;
Tox_Event_Group_Private_Message *group_private_message;
uint32_t group_private_message_size;
uint32_t group_private_message_capacity;
Tox_Event_Group_Custom_Packet *group_custom_packet;
uint32_t group_custom_packet_size;
uint32_t group_custom_packet_capacity;
Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet;
uint32_t group_custom_private_packet_size;
uint32_t group_custom_private_packet_capacity;
Tox_Event_Group_Invite *group_invite;
uint32_t group_invite_size;
uint32_t group_invite_capacity;
Tox_Event_Group_Peer_Join *group_peer_join;
uint32_t group_peer_join_size;
uint32_t group_peer_join_capacity;
Tox_Event_Group_Peer_Exit *group_peer_exit;
uint32_t group_peer_exit_size;
uint32_t group_peer_exit_capacity;
Tox_Event_Group_Self_Join *group_self_join;
uint32_t group_self_join_size;
uint32_t group_self_join_capacity;
Tox_Event_Group_Join_Fail *group_join_fail;
uint32_t group_join_fail_size;
uint32_t group_join_fail_capacity;
Tox_Event_Group_Moderation *group_moderation;
uint32_t group_moderation_size;
uint32_t group_moderation_capacity;
const Memory *mem;
};
typedef struct Tox_Events_State {
Tox_Err_Events_Iterate error;
const Memory *mem;
Tox_Events *events;
} Tox_Events_State;
@ -217,142 +68,18 @@ tox_group_self_join_cb tox_events_handle_group_self_join;
tox_group_join_fail_cb tox_events_handle_group_join_fail;
tox_group_moderation_cb tox_events_handle_group_moderation;
// non_null()
typedef void tox_events_clear_cb(Tox_Events *events);
non_null(2) nullable(1)
bool tox_events_pack(const Tox_Events *events, Bin_Pack *bp);
tox_events_clear_cb tox_events_clear_conference_connected;
tox_events_clear_cb tox_events_clear_conference_invite;
tox_events_clear_cb tox_events_clear_conference_message;
tox_events_clear_cb tox_events_clear_conference_peer_list_changed;
tox_events_clear_cb tox_events_clear_conference_peer_name;
tox_events_clear_cb tox_events_clear_conference_title;
tox_events_clear_cb tox_events_clear_file_chunk_request;
tox_events_clear_cb tox_events_clear_file_recv_chunk;
tox_events_clear_cb tox_events_clear_file_recv_control;
tox_events_clear_cb tox_events_clear_file_recv;
tox_events_clear_cb tox_events_clear_friend_connection_status;
tox_events_clear_cb tox_events_clear_friend_lossless_packet;
tox_events_clear_cb tox_events_clear_friend_lossy_packet;
tox_events_clear_cb tox_events_clear_friend_message;
tox_events_clear_cb tox_events_clear_friend_name;
tox_events_clear_cb tox_events_clear_friend_read_receipt;
tox_events_clear_cb tox_events_clear_friend_request;
tox_events_clear_cb tox_events_clear_friend_status_message;
tox_events_clear_cb tox_events_clear_friend_status;
tox_events_clear_cb tox_events_clear_friend_typing;
tox_events_clear_cb tox_events_clear_self_connection_status;
tox_events_clear_cb tox_events_clear_group_peer_name;
tox_events_clear_cb tox_events_clear_group_peer_status;
tox_events_clear_cb tox_events_clear_group_topic;
tox_events_clear_cb tox_events_clear_group_privacy_state;
tox_events_clear_cb tox_events_clear_group_voice_state;
tox_events_clear_cb tox_events_clear_group_topic_lock;
tox_events_clear_cb tox_events_clear_group_peer_limit;
tox_events_clear_cb tox_events_clear_group_password;
tox_events_clear_cb tox_events_clear_group_message;
tox_events_clear_cb tox_events_clear_group_private_message;
tox_events_clear_cb tox_events_clear_group_custom_packet;
tox_events_clear_cb tox_events_clear_group_custom_private_packet;
tox_events_clear_cb tox_events_clear_group_invite;
tox_events_clear_cb tox_events_clear_group_peer_join;
tox_events_clear_cb tox_events_clear_group_peer_exit;
tox_events_clear_cb tox_events_clear_group_self_join;
tox_events_clear_cb tox_events_clear_group_join_fail;
tox_events_clear_cb tox_events_clear_group_moderation;
// non_null()
typedef bool tox_events_pack_cb(const Tox_Events *events, Bin_Pack *bp);
tox_events_pack_cb tox_events_pack_conference_connected;
tox_events_pack_cb tox_events_pack_conference_invite;
tox_events_pack_cb tox_events_pack_conference_message;
tox_events_pack_cb tox_events_pack_conference_peer_list_changed;
tox_events_pack_cb tox_events_pack_conference_peer_name;
tox_events_pack_cb tox_events_pack_conference_title;
tox_events_pack_cb tox_events_pack_file_chunk_request;
tox_events_pack_cb tox_events_pack_file_recv_chunk;
tox_events_pack_cb tox_events_pack_file_recv_control;
tox_events_pack_cb tox_events_pack_file_recv;
tox_events_pack_cb tox_events_pack_friend_connection_status;
tox_events_pack_cb tox_events_pack_friend_lossless_packet;
tox_events_pack_cb tox_events_pack_friend_lossy_packet;
tox_events_pack_cb tox_events_pack_friend_message;
tox_events_pack_cb tox_events_pack_friend_name;
tox_events_pack_cb tox_events_pack_friend_read_receipt;
tox_events_pack_cb tox_events_pack_friend_request;
tox_events_pack_cb tox_events_pack_friend_status_message;
tox_events_pack_cb tox_events_pack_friend_status;
tox_events_pack_cb tox_events_pack_friend_typing;
tox_events_pack_cb tox_events_pack_self_connection_status;
tox_events_pack_cb tox_events_pack_group_peer_name;
tox_events_pack_cb tox_events_pack_group_peer_status;
tox_events_pack_cb tox_events_pack_group_topic;
tox_events_pack_cb tox_events_pack_group_privacy_state;
tox_events_pack_cb tox_events_pack_group_voice_state;
tox_events_pack_cb tox_events_pack_group_topic_lock;
tox_events_pack_cb tox_events_pack_group_peer_limit;
tox_events_pack_cb tox_events_pack_group_password;
tox_events_pack_cb tox_events_pack_group_message;
tox_events_pack_cb tox_events_pack_group_private_message;
tox_events_pack_cb tox_events_pack_group_custom_packet;
tox_events_pack_cb tox_events_pack_group_custom_private_packet;
tox_events_pack_cb tox_events_pack_group_invite;
tox_events_pack_cb tox_events_pack_group_peer_join;
tox_events_pack_cb tox_events_pack_group_peer_exit;
tox_events_pack_cb tox_events_pack_group_self_join;
tox_events_pack_cb tox_events_pack_group_join_fail;
tox_events_pack_cb tox_events_pack_group_moderation;
tox_events_pack_cb tox_events_pack;
// non_null()
typedef bool tox_events_unpack_cb(Tox_Events *events, Bin_Unpack *bu);
tox_events_unpack_cb tox_events_unpack_conference_connected;
tox_events_unpack_cb tox_events_unpack_conference_invite;
tox_events_unpack_cb tox_events_unpack_conference_message;
tox_events_unpack_cb tox_events_unpack_conference_peer_list_changed;
tox_events_unpack_cb tox_events_unpack_conference_peer_name;
tox_events_unpack_cb tox_events_unpack_conference_title;
tox_events_unpack_cb tox_events_unpack_file_chunk_request;
tox_events_unpack_cb tox_events_unpack_file_recv_chunk;
tox_events_unpack_cb tox_events_unpack_file_recv_control;
tox_events_unpack_cb tox_events_unpack_file_recv;
tox_events_unpack_cb tox_events_unpack_friend_connection_status;
tox_events_unpack_cb tox_events_unpack_friend_lossless_packet;
tox_events_unpack_cb tox_events_unpack_friend_lossy_packet;
tox_events_unpack_cb tox_events_unpack_friend_message;
tox_events_unpack_cb tox_events_unpack_friend_name;
tox_events_unpack_cb tox_events_unpack_friend_read_receipt;
tox_events_unpack_cb tox_events_unpack_friend_request;
tox_events_unpack_cb tox_events_unpack_friend_status_message;
tox_events_unpack_cb tox_events_unpack_friend_status;
tox_events_unpack_cb tox_events_unpack_friend_typing;
tox_events_unpack_cb tox_events_unpack_self_connection_status;
tox_events_unpack_cb tox_events_unpack_group_peer_name;
tox_events_unpack_cb tox_events_unpack_group_peer_status;
tox_events_unpack_cb tox_events_unpack_group_topic;
tox_events_unpack_cb tox_events_unpack_group_privacy_state;
tox_events_unpack_cb tox_events_unpack_group_voice_state;
tox_events_unpack_cb tox_events_unpack_group_topic_lock;
tox_events_unpack_cb tox_events_unpack_group_peer_limit;
tox_events_unpack_cb tox_events_unpack_group_password;
tox_events_unpack_cb tox_events_unpack_group_message;
tox_events_unpack_cb tox_events_unpack_group_private_message;
tox_events_unpack_cb tox_events_unpack_group_custom_packet;
tox_events_unpack_cb tox_events_unpack_group_custom_private_packet;
tox_events_unpack_cb tox_events_unpack_group_invite;
tox_events_unpack_cb tox_events_unpack_group_peer_join;
tox_events_unpack_cb tox_events_unpack_group_peer_exit;
tox_events_unpack_cb tox_events_unpack_group_self_join;
tox_events_unpack_cb tox_events_unpack_group_join_fail;
tox_events_unpack_cb tox_events_unpack_group_moderation;
tox_events_unpack_cb tox_events_unpack;
non_null()
bool tox_events_unpack(Tox_Events *events, Bin_Unpack *bu, const Memory *mem);
non_null()
Tox_Events_State *tox_events_alloc(void *user_data);
non_null()
bool tox_events_add(Tox_Events *events, const Tox_Event *event);
#ifdef __cplusplus
}
#endif

181
external/toxcore/c-toxcore/toxcore/events/file_chunk_request.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -29,19 +30,6 @@ struct Tox_Event_File_Chunk_Request {
uint16_t length;
};
non_null()
static void tox_event_file_chunk_request_construct(Tox_Event_File_Chunk_Request *file_chunk_request)
{
*file_chunk_request = (Tox_Event_File_Chunk_Request) {
0
};
}
non_null()
static void tox_event_file_chunk_request_destruct(Tox_Event_File_Chunk_Request *file_chunk_request)
{
return;
}
non_null()
static void tox_event_file_chunk_request_set_friend_number(Tox_Event_File_Chunk_Request *file_chunk_request,
uint32_t friend_number)
@ -82,7 +70,8 @@ uint64_t tox_event_file_chunk_request_get_position(const Tox_Event_File_Chunk_Re
}
non_null()
static void tox_event_file_chunk_request_set_length(Tox_Event_File_Chunk_Request *file_chunk_request, uint16_t length)
static void tox_event_file_chunk_request_set_length(Tox_Event_File_Chunk_Request *file_chunk_request,
uint16_t length)
{
assert(file_chunk_request != nullptr);
file_chunk_request->length = length;
@ -94,7 +83,19 @@ uint16_t tox_event_file_chunk_request_get_length(const Tox_Event_File_Chunk_Requ
}
non_null()
static bool tox_event_file_chunk_request_pack(
static void tox_event_file_chunk_request_construct(Tox_Event_File_Chunk_Request *file_chunk_request)
{
*file_chunk_request = (Tox_Event_File_Chunk_Request) {
0
};
}
non_null()
static void tox_event_file_chunk_request_destruct(Tox_Event_File_Chunk_Request *file_chunk_request, const Memory *mem)
{
return;
}
bool tox_event_file_chunk_request_pack(
const Tox_Event_File_Chunk_Request *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -108,7 +109,7 @@ static bool tox_event_file_chunk_request_pack(
}
non_null()
static bool tox_event_file_chunk_request_unpack(
static bool tox_event_file_chunk_request_unpack_into(
Tox_Event_File_Chunk_Request *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -125,90 +126,120 @@ static bool tox_event_file_chunk_request_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_File_Chunk_Request *tox_events_add_file_chunk_request(Tox_Events *events)
const Tox_Event_File_Chunk_Request *tox_event_get_file_chunk_request(const Tox_Event *event)
{
if (events->file_chunk_request_size == UINT32_MAX) {
return event->type == TOX_EVENT_FILE_CHUNK_REQUEST ? event->data.file_chunk_request : nullptr;
}
Tox_Event_File_Chunk_Request *tox_event_file_chunk_request_new(const Memory *mem)
{
Tox_Event_File_Chunk_Request *const file_chunk_request =
(Tox_Event_File_Chunk_Request *)mem_alloc(mem, sizeof(Tox_Event_File_Chunk_Request));
if (file_chunk_request == nullptr) {
return nullptr;
}
if (events->file_chunk_request_size == events->file_chunk_request_capacity) {
const uint32_t new_file_chunk_request_capacity = events->file_chunk_request_capacity * 2 + 1;
Tox_Event_File_Chunk_Request *new_file_chunk_request = (Tox_Event_File_Chunk_Request *)realloc(
events->file_chunk_request, new_file_chunk_request_capacity * sizeof(Tox_Event_File_Chunk_Request));
if (new_file_chunk_request == nullptr) {
return nullptr;
}
events->file_chunk_request = new_file_chunk_request;
events->file_chunk_request_capacity = new_file_chunk_request_capacity;
}
Tox_Event_File_Chunk_Request *const file_chunk_request = &events->file_chunk_request[events->file_chunk_request_size];
tox_event_file_chunk_request_construct(file_chunk_request);
++events->file_chunk_request_size;
return file_chunk_request;
}
void tox_events_clear_file_chunk_request(Tox_Events *events)
void tox_event_file_chunk_request_free(Tox_Event_File_Chunk_Request *file_chunk_request, const Memory *mem)
{
if (events == nullptr) {
return;
if (file_chunk_request != nullptr) {
tox_event_file_chunk_request_destruct(file_chunk_request, mem);
}
for (uint32_t i = 0; i < events->file_chunk_request_size; ++i) {
tox_event_file_chunk_request_destruct(&events->file_chunk_request[i]);
}
free(events->file_chunk_request);
events->file_chunk_request = nullptr;
events->file_chunk_request_size = 0;
events->file_chunk_request_capacity = 0;
mem_delete(mem, file_chunk_request);
}
uint32_t tox_events_get_file_chunk_request_size(const Tox_Events *events)
non_null()
static Tox_Event_File_Chunk_Request *tox_events_add_file_chunk_request(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_File_Chunk_Request *const file_chunk_request = tox_event_file_chunk_request_new(mem);
if (file_chunk_request == nullptr) {
return nullptr;
}
return events->file_chunk_request_size;
Tox_Event event;
event.type = TOX_EVENT_FILE_CHUNK_REQUEST;
event.data.file_chunk_request = file_chunk_request;
tox_events_add(events, &event);
return file_chunk_request;
}
const Tox_Event_File_Chunk_Request *tox_events_get_file_chunk_request(const Tox_Events *events, uint32_t index)
{
assert(index < events->file_chunk_request_size);
assert(events->file_chunk_request != nullptr);
return &events->file_chunk_request[index];
}
bool tox_events_pack_file_chunk_request(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_file_chunk_request_size(events);
uint32_t file_chunk_request_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_file_chunk_request_pack(tox_events_get_file_chunk_request(events, i), bp)) {
return false;
if (file_chunk_request_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_CHUNK_REQUEST) {
const Tox_Event_File_Chunk_Request *file_chunk_request = events->events[i].data.file_chunk_request;
if (file_chunk_request_index == index) {
return file_chunk_request;
}
++file_chunk_request_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_file_chunk_request(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_file_chunk_request_size(const Tox_Events *events)
{
Tox_Event_File_Chunk_Request *event = tox_events_add_file_chunk_request(events);
uint32_t file_chunk_request_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_CHUNK_REQUEST) {
++file_chunk_request_size;
}
}
return file_chunk_request_size;
}
bool tox_event_file_chunk_request_unpack(
Tox_Event_File_Chunk_Request **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_file_chunk_request_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_file_chunk_request_unpack(event, bu);
return tox_event_file_chunk_request_unpack_into(*event, bu);
}
non_null()
static Tox_Event_File_Chunk_Request *tox_event_file_chunk_request_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_File_Chunk_Request *file_chunk_request = tox_events_add_file_chunk_request(state->events, state->mem);
if (file_chunk_request == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return file_chunk_request;
}
@ -219,20 +250,12 @@ bool tox_events_unpack_file_chunk_request(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_File_Chunk_Request *file_chunk_request = tox_events_add_file_chunk_request(state->events);
Tox_Event_File_Chunk_Request *file_chunk_request = tox_event_file_chunk_request_alloc(user_data);
if (file_chunk_request == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

182
external/toxcore/c-toxcore/toxcore/events/file_recv.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -31,19 +32,6 @@ struct Tox_Event_File_Recv {
uint32_t filename_length;
};
non_null()
static void tox_event_file_recv_construct(Tox_Event_File_Recv *file_recv)
{
*file_recv = (Tox_Event_File_Recv) {
0
};
}
non_null()
static void tox_event_file_recv_destruct(Tox_Event_File_Recv *file_recv)
{
free(file_recv->filename);
}
non_null()
static void tox_event_file_recv_set_friend_number(Tox_Event_File_Recv *file_recv,
uint32_t friend_number)
@ -97,8 +85,8 @@ uint64_t tox_event_file_recv_get_file_size(const Tox_Event_File_Recv *file_recv)
}
non_null()
static bool tox_event_file_recv_set_filename(Tox_Event_File_Recv *file_recv, const uint8_t *filename,
uint32_t filename_length)
static bool tox_event_file_recv_set_filename(Tox_Event_File_Recv *file_recv,
const uint8_t *filename, uint32_t filename_length)
{
assert(file_recv != nullptr);
@ -130,7 +118,19 @@ const uint8_t *tox_event_file_recv_get_filename(const Tox_Event_File_Recv *file_
}
non_null()
static bool tox_event_file_recv_pack(
static void tox_event_file_recv_construct(Tox_Event_File_Recv *file_recv)
{
*file_recv = (Tox_Event_File_Recv) {
0
};
}
non_null()
static void tox_event_file_recv_destruct(Tox_Event_File_Recv *file_recv, const Memory *mem)
{
free(file_recv->filename);
}
bool tox_event_file_recv_pack(
const Tox_Event_File_Recv *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -145,7 +145,7 @@ static bool tox_event_file_recv_pack(
}
non_null()
static bool tox_event_file_recv_unpack(
static bool tox_event_file_recv_unpack_into(
Tox_Event_File_Recv *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -163,90 +163,120 @@ static bool tox_event_file_recv_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_File_Recv *tox_events_add_file_recv(Tox_Events *events)
const Tox_Event_File_Recv *tox_event_get_file_recv(const Tox_Event *event)
{
if (events->file_recv_size == UINT32_MAX) {
return event->type == TOX_EVENT_FILE_RECV ? event->data.file_recv : nullptr;
}
Tox_Event_File_Recv *tox_event_file_recv_new(const Memory *mem)
{
Tox_Event_File_Recv *const file_recv =
(Tox_Event_File_Recv *)mem_alloc(mem, sizeof(Tox_Event_File_Recv));
if (file_recv == nullptr) {
return nullptr;
}
if (events->file_recv_size == events->file_recv_capacity) {
const uint32_t new_file_recv_capacity = events->file_recv_capacity * 2 + 1;
Tox_Event_File_Recv *new_file_recv = (Tox_Event_File_Recv *)realloc(
events->file_recv, new_file_recv_capacity * sizeof(Tox_Event_File_Recv));
if (new_file_recv == nullptr) {
return nullptr;
}
events->file_recv = new_file_recv;
events->file_recv_capacity = new_file_recv_capacity;
}
Tox_Event_File_Recv *const file_recv = &events->file_recv[events->file_recv_size];
tox_event_file_recv_construct(file_recv);
++events->file_recv_size;
return file_recv;
}
void tox_events_clear_file_recv(Tox_Events *events)
void tox_event_file_recv_free(Tox_Event_File_Recv *file_recv, const Memory *mem)
{
if (events == nullptr) {
return;
if (file_recv != nullptr) {
tox_event_file_recv_destruct(file_recv, mem);
}
for (uint32_t i = 0; i < events->file_recv_size; ++i) {
tox_event_file_recv_destruct(&events->file_recv[i]);
}
free(events->file_recv);
events->file_recv = nullptr;
events->file_recv_size = 0;
events->file_recv_capacity = 0;
mem_delete(mem, file_recv);
}
uint32_t tox_events_get_file_recv_size(const Tox_Events *events)
non_null()
static Tox_Event_File_Recv *tox_events_add_file_recv(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_File_Recv *const file_recv = tox_event_file_recv_new(mem);
if (file_recv == nullptr) {
return nullptr;
}
return events->file_recv_size;
Tox_Event event;
event.type = TOX_EVENT_FILE_RECV;
event.data.file_recv = file_recv;
tox_events_add(events, &event);
return file_recv;
}
const Tox_Event_File_Recv *tox_events_get_file_recv(const Tox_Events *events, uint32_t index)
{
assert(index < events->file_recv_size);
assert(events->file_recv != nullptr);
return &events->file_recv[index];
}
bool tox_events_pack_file_recv(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_file_recv_size(events);
uint32_t file_recv_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_file_recv_pack(tox_events_get_file_recv(events, i), bp)) {
return false;
if (file_recv_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_RECV) {
const Tox_Event_File_Recv *file_recv = events->events[i].data.file_recv;
if (file_recv_index == index) {
return file_recv;
}
++file_recv_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_file_recv(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_file_recv_size(const Tox_Events *events)
{
Tox_Event_File_Recv *event = tox_events_add_file_recv(events);
uint32_t file_recv_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_RECV) {
++file_recv_size;
}
}
return file_recv_size;
}
bool tox_event_file_recv_unpack(
Tox_Event_File_Recv **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_file_recv_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_file_recv_unpack(event, bu);
return tox_event_file_recv_unpack_into(*event, bu);
}
non_null()
static Tox_Event_File_Recv *tox_event_file_recv_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_File_Recv *file_recv = tox_events_add_file_recv(state->events, state->mem);
if (file_recv == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return file_recv;
}
@ -257,20 +287,12 @@ bool tox_events_unpack_file_recv(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_File_Recv *file_recv = tox_events_add_file_recv(state->events);
Tox_Event_File_Recv *file_recv = tox_event_file_recv_alloc(user_data);
if (file_recv == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

184
external/toxcore/c-toxcore/toxcore/events/file_recv_chunk.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -30,19 +31,6 @@ struct Tox_Event_File_Recv_Chunk {
uint32_t data_length;
};
non_null()
static void tox_event_file_recv_chunk_construct(Tox_Event_File_Recv_Chunk *file_recv_chunk)
{
*file_recv_chunk = (Tox_Event_File_Recv_Chunk) {
0
};
}
non_null()
static void tox_event_file_recv_chunk_destruct(Tox_Event_File_Recv_Chunk *file_recv_chunk)
{
free(file_recv_chunk->data);
}
non_null()
static void tox_event_file_recv_chunk_set_friend_number(Tox_Event_File_Recv_Chunk *file_recv_chunk,
uint32_t friend_number)
@ -83,8 +71,8 @@ uint64_t tox_event_file_recv_chunk_get_position(const Tox_Event_File_Recv_Chunk
}
non_null()
static bool tox_event_file_recv_chunk_set_data(Tox_Event_File_Recv_Chunk *file_recv_chunk, const uint8_t *data,
uint32_t data_length)
static bool tox_event_file_recv_chunk_set_data(Tox_Event_File_Recv_Chunk *file_recv_chunk,
const uint8_t *data, uint32_t data_length)
{
assert(file_recv_chunk != nullptr);
@ -104,7 +92,7 @@ static bool tox_event_file_recv_chunk_set_data(Tox_Event_File_Recv_Chunk *file_r
file_recv_chunk->data_length = data_length;
return true;
}
uint32_t tox_event_file_recv_chunk_get_length(const Tox_Event_File_Recv_Chunk *file_recv_chunk)
uint32_t tox_event_file_recv_chunk_get_data_length(const Tox_Event_File_Recv_Chunk *file_recv_chunk)
{
assert(file_recv_chunk != nullptr);
return file_recv_chunk->data_length;
@ -116,7 +104,19 @@ const uint8_t *tox_event_file_recv_chunk_get_data(const Tox_Event_File_Recv_Chun
}
non_null()
static bool tox_event_file_recv_chunk_pack(
static void tox_event_file_recv_chunk_construct(Tox_Event_File_Recv_Chunk *file_recv_chunk)
{
*file_recv_chunk = (Tox_Event_File_Recv_Chunk) {
0
};
}
non_null()
static void tox_event_file_recv_chunk_destruct(Tox_Event_File_Recv_Chunk *file_recv_chunk, const Memory *mem)
{
free(file_recv_chunk->data);
}
bool tox_event_file_recv_chunk_pack(
const Tox_Event_File_Recv_Chunk *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -130,7 +130,7 @@ static bool tox_event_file_recv_chunk_pack(
}
non_null()
static bool tox_event_file_recv_chunk_unpack(
static bool tox_event_file_recv_chunk_unpack_into(
Tox_Event_File_Recv_Chunk *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -147,90 +147,120 @@ static bool tox_event_file_recv_chunk_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_File_Recv_Chunk *tox_events_add_file_recv_chunk(Tox_Events *events)
const Tox_Event_File_Recv_Chunk *tox_event_get_file_recv_chunk(const Tox_Event *event)
{
if (events->file_recv_chunk_size == UINT32_MAX) {
return event->type == TOX_EVENT_FILE_RECV_CHUNK ? event->data.file_recv_chunk : nullptr;
}
Tox_Event_File_Recv_Chunk *tox_event_file_recv_chunk_new(const Memory *mem)
{
Tox_Event_File_Recv_Chunk *const file_recv_chunk =
(Tox_Event_File_Recv_Chunk *)mem_alloc(mem, sizeof(Tox_Event_File_Recv_Chunk));
if (file_recv_chunk == nullptr) {
return nullptr;
}
if (events->file_recv_chunk_size == events->file_recv_chunk_capacity) {
const uint32_t new_file_recv_chunk_capacity = events->file_recv_chunk_capacity * 2 + 1;
Tox_Event_File_Recv_Chunk *new_file_recv_chunk = (Tox_Event_File_Recv_Chunk *)realloc(
events->file_recv_chunk, new_file_recv_chunk_capacity * sizeof(Tox_Event_File_Recv_Chunk));
if (new_file_recv_chunk == nullptr) {
return nullptr;
}
events->file_recv_chunk = new_file_recv_chunk;
events->file_recv_chunk_capacity = new_file_recv_chunk_capacity;
}
Tox_Event_File_Recv_Chunk *const file_recv_chunk = &events->file_recv_chunk[events->file_recv_chunk_size];
tox_event_file_recv_chunk_construct(file_recv_chunk);
++events->file_recv_chunk_size;
return file_recv_chunk;
}
void tox_events_clear_file_recv_chunk(Tox_Events *events)
void tox_event_file_recv_chunk_free(Tox_Event_File_Recv_Chunk *file_recv_chunk, const Memory *mem)
{
if (events == nullptr) {
return;
if (file_recv_chunk != nullptr) {
tox_event_file_recv_chunk_destruct(file_recv_chunk, mem);
}
for (uint32_t i = 0; i < events->file_recv_chunk_size; ++i) {
tox_event_file_recv_chunk_destruct(&events->file_recv_chunk[i]);
}
free(events->file_recv_chunk);
events->file_recv_chunk = nullptr;
events->file_recv_chunk_size = 0;
events->file_recv_chunk_capacity = 0;
mem_delete(mem, file_recv_chunk);
}
uint32_t tox_events_get_file_recv_chunk_size(const Tox_Events *events)
non_null()
static Tox_Event_File_Recv_Chunk *tox_events_add_file_recv_chunk(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_File_Recv_Chunk *const file_recv_chunk = tox_event_file_recv_chunk_new(mem);
if (file_recv_chunk == nullptr) {
return nullptr;
}
return events->file_recv_chunk_size;
Tox_Event event;
event.type = TOX_EVENT_FILE_RECV_CHUNK;
event.data.file_recv_chunk = file_recv_chunk;
tox_events_add(events, &event);
return file_recv_chunk;
}
const Tox_Event_File_Recv_Chunk *tox_events_get_file_recv_chunk(const Tox_Events *events, uint32_t index)
{
assert(index < events->file_recv_chunk_size);
assert(events->file_recv_chunk != nullptr);
return &events->file_recv_chunk[index];
}
bool tox_events_pack_file_recv_chunk(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_file_recv_chunk_size(events);
uint32_t file_recv_chunk_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_file_recv_chunk_pack(tox_events_get_file_recv_chunk(events, i), bp)) {
return false;
if (file_recv_chunk_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_RECV_CHUNK) {
const Tox_Event_File_Recv_Chunk *file_recv_chunk = events->events[i].data.file_recv_chunk;
if (file_recv_chunk_index == index) {
return file_recv_chunk;
}
++file_recv_chunk_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_file_recv_chunk(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_file_recv_chunk_size(const Tox_Events *events)
{
Tox_Event_File_Recv_Chunk *event = tox_events_add_file_recv_chunk(events);
uint32_t file_recv_chunk_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_RECV_CHUNK) {
++file_recv_chunk_size;
}
}
return file_recv_chunk_size;
}
bool tox_event_file_recv_chunk_unpack(
Tox_Event_File_Recv_Chunk **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_file_recv_chunk_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_file_recv_chunk_unpack(event, bu);
return tox_event_file_recv_chunk_unpack_into(*event, bu);
}
non_null()
static Tox_Event_File_Recv_Chunk *tox_event_file_recv_chunk_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_File_Recv_Chunk *file_recv_chunk = tox_events_add_file_recv_chunk(state->events, state->mem);
if (file_recv_chunk == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return file_recv_chunk;
}
@ -241,20 +271,12 @@ bool tox_events_unpack_file_recv_chunk(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_File_Recv_Chunk *file_recv_chunk = tox_events_add_file_recv_chunk(state->events);
Tox_Event_File_Recv_Chunk *file_recv_chunk = tox_event_file_recv_chunk_alloc(user_data);
if (file_recv_chunk == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

179
external/toxcore/c-toxcore/toxcore/events/file_recv_control.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -29,19 +29,6 @@ struct Tox_Event_File_Recv_Control {
Tox_File_Control control;
};
non_null()
static void tox_event_file_recv_control_construct(Tox_Event_File_Recv_Control *file_recv_control)
{
*file_recv_control = (Tox_Event_File_Recv_Control) {
0
};
}
non_null()
static void tox_event_file_recv_control_destruct(Tox_Event_File_Recv_Control *file_recv_control)
{
return;
}
non_null()
static void tox_event_file_recv_control_set_friend_number(Tox_Event_File_Recv_Control *file_recv_control,
uint32_t friend_number)
@ -82,7 +69,19 @@ Tox_File_Control tox_event_file_recv_control_get_control(const Tox_Event_File_Re
}
non_null()
static bool tox_event_file_recv_control_pack(
static void tox_event_file_recv_control_construct(Tox_Event_File_Recv_Control *file_recv_control)
{
*file_recv_control = (Tox_Event_File_Recv_Control) {
0
};
}
non_null()
static void tox_event_file_recv_control_destruct(Tox_Event_File_Recv_Control *file_recv_control, const Memory *mem)
{
return;
}
bool tox_event_file_recv_control_pack(
const Tox_Event_File_Recv_Control *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -95,7 +94,7 @@ static bool tox_event_file_recv_control_pack(
}
non_null()
static bool tox_event_file_recv_control_unpack(
static bool tox_event_file_recv_control_unpack_into(
Tox_Event_File_Recv_Control *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -105,96 +104,126 @@ static bool tox_event_file_recv_control_unpack(
return bin_unpack_u32(bu, &event->friend_number)
&& bin_unpack_u32(bu, &event->file_number)
&& tox_unpack_file_control(bu, &event->control);
&& tox_file_control_unpack(bu, &event->control);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_File_Recv_Control *tox_events_add_file_recv_control(Tox_Events *events)
const Tox_Event_File_Recv_Control *tox_event_get_file_recv_control(const Tox_Event *event)
{
if (events->file_recv_control_size == UINT32_MAX) {
return event->type == TOX_EVENT_FILE_RECV_CONTROL ? event->data.file_recv_control : nullptr;
}
Tox_Event_File_Recv_Control *tox_event_file_recv_control_new(const Memory *mem)
{
Tox_Event_File_Recv_Control *const file_recv_control =
(Tox_Event_File_Recv_Control *)mem_alloc(mem, sizeof(Tox_Event_File_Recv_Control));
if (file_recv_control == nullptr) {
return nullptr;
}
if (events->file_recv_control_size == events->file_recv_control_capacity) {
const uint32_t new_file_recv_control_capacity = events->file_recv_control_capacity * 2 + 1;
Tox_Event_File_Recv_Control *new_file_recv_control = (Tox_Event_File_Recv_Control *)realloc(
events->file_recv_control, new_file_recv_control_capacity * sizeof(Tox_Event_File_Recv_Control));
if (new_file_recv_control == nullptr) {
return nullptr;
}
events->file_recv_control = new_file_recv_control;
events->file_recv_control_capacity = new_file_recv_control_capacity;
}
Tox_Event_File_Recv_Control *const file_recv_control = &events->file_recv_control[events->file_recv_control_size];
tox_event_file_recv_control_construct(file_recv_control);
++events->file_recv_control_size;
return file_recv_control;
}
void tox_events_clear_file_recv_control(Tox_Events *events)
void tox_event_file_recv_control_free(Tox_Event_File_Recv_Control *file_recv_control, const Memory *mem)
{
if (events == nullptr) {
return;
if (file_recv_control != nullptr) {
tox_event_file_recv_control_destruct(file_recv_control, mem);
}
for (uint32_t i = 0; i < events->file_recv_control_size; ++i) {
tox_event_file_recv_control_destruct(&events->file_recv_control[i]);
}
free(events->file_recv_control);
events->file_recv_control = nullptr;
events->file_recv_control_size = 0;
events->file_recv_control_capacity = 0;
mem_delete(mem, file_recv_control);
}
uint32_t tox_events_get_file_recv_control_size(const Tox_Events *events)
non_null()
static Tox_Event_File_Recv_Control *tox_events_add_file_recv_control(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_File_Recv_Control *const file_recv_control = tox_event_file_recv_control_new(mem);
if (file_recv_control == nullptr) {
return nullptr;
}
return events->file_recv_control_size;
Tox_Event event;
event.type = TOX_EVENT_FILE_RECV_CONTROL;
event.data.file_recv_control = file_recv_control;
tox_events_add(events, &event);
return file_recv_control;
}
const Tox_Event_File_Recv_Control *tox_events_get_file_recv_control(const Tox_Events *events, uint32_t index)
{
assert(index < events->file_recv_control_size);
assert(events->file_recv_control != nullptr);
return &events->file_recv_control[index];
}
bool tox_events_pack_file_recv_control(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_file_recv_control_size(events);
uint32_t file_recv_control_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_file_recv_control_pack(tox_events_get_file_recv_control(events, i), bp)) {
return false;
if (file_recv_control_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FILE_RECV_CONTROL) {
const Tox_Event_File_Recv_Control *file_recv_control = events->events[i].data.file_recv_control;
if (file_recv_control_index == index) {
return file_recv_control;
}
++file_recv_control_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_file_recv_control(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_file_recv_control_size(const Tox_Events *events)
{
Tox_Event_File_Recv_Control *event = tox_events_add_file_recv_control(events);
uint32_t file_recv_control_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FILE_RECV_CONTROL) {
++file_recv_control_size;
}
}
return file_recv_control_size;
}
bool tox_event_file_recv_control_unpack(
Tox_Event_File_Recv_Control **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_file_recv_control_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_file_recv_control_unpack(event, bu);
return tox_event_file_recv_control_unpack_into(*event, bu);
}
non_null()
static Tox_Event_File_Recv_Control *tox_event_file_recv_control_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_File_Recv_Control *file_recv_control = tox_events_add_file_recv_control(state->events, state->mem);
if (file_recv_control == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return file_recv_control;
}
@ -205,20 +234,12 @@ bool tox_events_unpack_file_recv_control(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
void tox_events_handle_file_recv_control(Tox *tox, uint32_t friend_number, uint32_t file_number,
Tox_File_Control control, void *user_data)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_File_Recv_Control *file_recv_control = tox_events_add_file_recv_control(state->events);
Tox_Event_File_Recv_Control *file_recv_control = tox_event_file_recv_control_alloc(user_data);
if (file_recv_control == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

213
external/toxcore/c-toxcore/toxcore/events/friend_connection_status.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -28,6 +28,32 @@ struct Tox_Event_Friend_Connection_Status {
Tox_Connection connection_status;
};
non_null()
static void tox_event_friend_connection_status_set_friend_number(Tox_Event_Friend_Connection_Status *friend_connection_status,
uint32_t friend_number)
{
assert(friend_connection_status != nullptr);
friend_connection_status->friend_number = friend_number;
}
uint32_t tox_event_friend_connection_status_get_friend_number(const Tox_Event_Friend_Connection_Status *friend_connection_status)
{
assert(friend_connection_status != nullptr);
return friend_connection_status->friend_number;
}
non_null()
static void tox_event_friend_connection_status_set_connection_status(Tox_Event_Friend_Connection_Status *friend_connection_status,
Tox_Connection connection_status)
{
assert(friend_connection_status != nullptr);
friend_connection_status->connection_status = connection_status;
}
Tox_Connection tox_event_friend_connection_status_get_connection_status(const Tox_Event_Friend_Connection_Status *friend_connection_status)
{
assert(friend_connection_status != nullptr);
return friend_connection_status->connection_status;
}
non_null()
static void tox_event_friend_connection_status_construct(Tox_Event_Friend_Connection_Status *friend_connection_status)
{
@ -36,41 +62,12 @@ static void tox_event_friend_connection_status_construct(Tox_Event_Friend_Connec
};
}
non_null()
static void tox_event_friend_connection_status_destruct(Tox_Event_Friend_Connection_Status *friend_connection_status)
static void tox_event_friend_connection_status_destruct(Tox_Event_Friend_Connection_Status *friend_connection_status, const Memory *mem)
{
return;
}
non_null()
static void tox_event_friend_connection_status_set_friend_number(Tox_Event_Friend_Connection_Status
*friend_connection_status, uint32_t friend_number)
{
assert(friend_connection_status != nullptr);
friend_connection_status->friend_number = friend_number;
}
uint32_t tox_event_friend_connection_status_get_friend_number(const Tox_Event_Friend_Connection_Status
*friend_connection_status)
{
assert(friend_connection_status != nullptr);
return friend_connection_status->friend_number;
}
non_null()
static void tox_event_friend_connection_status_set_connection_status(Tox_Event_Friend_Connection_Status
*friend_connection_status, Tox_Connection connection_status)
{
assert(friend_connection_status != nullptr);
friend_connection_status->connection_status = connection_status;
}
Tox_Connection tox_event_friend_connection_status_get_connection_status(const Tox_Event_Friend_Connection_Status
*friend_connection_status)
{
assert(friend_connection_status != nullptr);
return friend_connection_status->connection_status;
}
non_null()
static bool tox_event_friend_connection_status_pack(
bool tox_event_friend_connection_status_pack(
const Tox_Event_Friend_Connection_Status *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -82,7 +79,7 @@ static bool tox_event_friend_connection_status_pack(
}
non_null()
static bool tox_event_friend_connection_status_unpack(
static bool tox_event_friend_connection_status_unpack_into(
Tox_Event_Friend_Connection_Status *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -91,98 +88,126 @@ static bool tox_event_friend_connection_status_unpack(
}
return bin_unpack_u32(bu, &event->friend_number)
&& tox_unpack_connection(bu, &event->connection_status);
&& tox_connection_unpack(bu, &event->connection_status);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Connection_Status *tox_events_add_friend_connection_status(Tox_Events *events)
const Tox_Event_Friend_Connection_Status *tox_event_get_friend_connection_status(const Tox_Event *event)
{
if (events->friend_connection_status_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_CONNECTION_STATUS ? event->data.friend_connection_status : nullptr;
}
Tox_Event_Friend_Connection_Status *tox_event_friend_connection_status_new(const Memory *mem)
{
Tox_Event_Friend_Connection_Status *const friend_connection_status =
(Tox_Event_Friend_Connection_Status *)mem_alloc(mem, sizeof(Tox_Event_Friend_Connection_Status));
if (friend_connection_status == nullptr) {
return nullptr;
}
if (events->friend_connection_status_size == events->friend_connection_status_capacity) {
const uint32_t new_friend_connection_status_capacity = events->friend_connection_status_capacity * 2 + 1;
Tox_Event_Friend_Connection_Status *new_friend_connection_status = (Tox_Event_Friend_Connection_Status *)realloc(
events->friend_connection_status, new_friend_connection_status_capacity * sizeof(Tox_Event_Friend_Connection_Status));
if (new_friend_connection_status == nullptr) {
return nullptr;
}
events->friend_connection_status = new_friend_connection_status;
events->friend_connection_status_capacity = new_friend_connection_status_capacity;
}
Tox_Event_Friend_Connection_Status *const friend_connection_status =
&events->friend_connection_status[events->friend_connection_status_size];
tox_event_friend_connection_status_construct(friend_connection_status);
++events->friend_connection_status_size;
return friend_connection_status;
}
void tox_events_clear_friend_connection_status(Tox_Events *events)
void tox_event_friend_connection_status_free(Tox_Event_Friend_Connection_Status *friend_connection_status, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_connection_status != nullptr) {
tox_event_friend_connection_status_destruct(friend_connection_status, mem);
}
mem_delete(mem, friend_connection_status);
}
non_null()
static Tox_Event_Friend_Connection_Status *tox_events_add_friend_connection_status(Tox_Events *events, const Memory *mem)
{
Tox_Event_Friend_Connection_Status *const friend_connection_status = tox_event_friend_connection_status_new(mem);
if (friend_connection_status == nullptr) {
return nullptr;
}
for (uint32_t i = 0; i < events->friend_connection_status_size; ++i) {
tox_event_friend_connection_status_destruct(&events->friend_connection_status[i]);
Tox_Event event;
event.type = TOX_EVENT_FRIEND_CONNECTION_STATUS;
event.data.friend_connection_status = friend_connection_status;
tox_events_add(events, &event);
return friend_connection_status;
}
const Tox_Event_Friend_Connection_Status *tox_events_get_friend_connection_status(const Tox_Events *events, uint32_t index)
{
uint32_t friend_connection_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (friend_connection_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_CONNECTION_STATUS) {
const Tox_Event_Friend_Connection_Status *friend_connection_status = events->events[i].data.friend_connection_status;
if (friend_connection_status_index == index) {
return friend_connection_status;
}
++friend_connection_status_index;
}
}
free(events->friend_connection_status);
events->friend_connection_status = nullptr;
events->friend_connection_status_size = 0;
events->friend_connection_status_capacity = 0;
return nullptr;
}
uint32_t tox_events_get_friend_connection_status_size(const Tox_Events *events)
{
if (events == nullptr) {
return 0;
}
return events->friend_connection_status_size;
}
const Tox_Event_Friend_Connection_Status *tox_events_get_friend_connection_status(const Tox_Events *events,
uint32_t index)
{
assert(index < events->friend_connection_status_size);
assert(events->friend_connection_status != nullptr);
return &events->friend_connection_status[index];
}
bool tox_events_pack_friend_connection_status(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_connection_status_size(events);
uint32_t friend_connection_status_size = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_connection_status_pack(tox_events_get_friend_connection_status(events, i), bp)) {
return false;
if (events->events[i].type == TOX_EVENT_FRIEND_CONNECTION_STATUS) {
++friend_connection_status_size;
}
}
return true;
return friend_connection_status_size;
}
bool tox_events_unpack_friend_connection_status(Tox_Events *events, Bin_Unpack *bu)
bool tox_event_friend_connection_status_unpack(
Tox_Event_Friend_Connection_Status **event, Bin_Unpack *bu, const Memory *mem)
{
Tox_Event_Friend_Connection_Status *event = tox_events_add_friend_connection_status(events);
assert(event != nullptr);
*event = tox_event_friend_connection_status_new(mem);
if (event == nullptr) {
if (*event == nullptr) {
return false;
}
return tox_event_friend_connection_status_unpack(event, bu);
return tox_event_friend_connection_status_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Connection_Status *tox_event_friend_connection_status_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Connection_Status *friend_connection_status = tox_events_add_friend_connection_status(state->events, state->mem);
if (friend_connection_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_connection_status;
}
@ -196,17 +221,9 @@ bool tox_events_unpack_friend_connection_status(Tox_Events *events, Bin_Unpack *
void tox_events_handle_friend_connection_status(Tox *tox, uint32_t friend_number, Tox_Connection connection_status,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Connection_Status *friend_connection_status = tox_events_add_friend_connection_status(state->events);
Tox_Event_Friend_Connection_Status *friend_connection_status = tox_event_friend_connection_status_alloc(user_data);
if (friend_connection_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

178
external/toxcore/c-toxcore/toxcore/events/friend_lossless_packet.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -28,19 +29,6 @@ struct Tox_Event_Friend_Lossless_Packet {
uint32_t data_length;
};
non_null()
static void tox_event_friend_lossless_packet_construct(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet)
{
*friend_lossless_packet = (Tox_Event_Friend_Lossless_Packet) {
0
};
}
non_null()
static void tox_event_friend_lossless_packet_destruct(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet)
{
free(friend_lossless_packet->data);
}
non_null()
static void tox_event_friend_lossless_packet_set_friend_number(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet,
uint32_t friend_number)
@ -48,8 +36,7 @@ static void tox_event_friend_lossless_packet_set_friend_number(Tox_Event_Friend_
assert(friend_lossless_packet != nullptr);
friend_lossless_packet->friend_number = friend_number;
}
uint32_t tox_event_friend_lossless_packet_get_friend_number(const Tox_Event_Friend_Lossless_Packet
*friend_lossless_packet)
uint32_t tox_event_friend_lossless_packet_get_friend_number(const Tox_Event_Friend_Lossless_Packet *friend_lossless_packet)
{
assert(friend_lossless_packet != nullptr);
return friend_lossless_packet->friend_number;
@ -89,7 +76,19 @@ const uint8_t *tox_event_friend_lossless_packet_get_data(const Tox_Event_Friend_
}
non_null()
static bool tox_event_friend_lossless_packet_pack(
static void tox_event_friend_lossless_packet_construct(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet)
{
*friend_lossless_packet = (Tox_Event_Friend_Lossless_Packet) {
0
};
}
non_null()
static void tox_event_friend_lossless_packet_destruct(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet, const Memory *mem)
{
free(friend_lossless_packet->data);
}
bool tox_event_friend_lossless_packet_pack(
const Tox_Event_Friend_Lossless_Packet *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -101,7 +100,7 @@ static bool tox_event_friend_lossless_packet_pack(
}
non_null()
static bool tox_event_friend_lossless_packet_unpack(
static bool tox_event_friend_lossless_packet_unpack_into(
Tox_Event_Friend_Lossless_Packet *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -116,91 +115,120 @@ static bool tox_event_friend_lossless_packet_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Lossless_Packet *tox_events_add_friend_lossless_packet(Tox_Events *events)
const Tox_Event_Friend_Lossless_Packet *tox_event_get_friend_lossless_packet(const Tox_Event *event)
{
if (events->friend_lossless_packet_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_LOSSLESS_PACKET ? event->data.friend_lossless_packet : nullptr;
}
Tox_Event_Friend_Lossless_Packet *tox_event_friend_lossless_packet_new(const Memory *mem)
{
Tox_Event_Friend_Lossless_Packet *const friend_lossless_packet =
(Tox_Event_Friend_Lossless_Packet *)mem_alloc(mem, sizeof(Tox_Event_Friend_Lossless_Packet));
if (friend_lossless_packet == nullptr) {
return nullptr;
}
if (events->friend_lossless_packet_size == events->friend_lossless_packet_capacity) {
const uint32_t new_friend_lossless_packet_capacity = events->friend_lossless_packet_capacity * 2 + 1;
Tox_Event_Friend_Lossless_Packet *new_friend_lossless_packet = (Tox_Event_Friend_Lossless_Packet *)realloc(
events->friend_lossless_packet, new_friend_lossless_packet_capacity * sizeof(Tox_Event_Friend_Lossless_Packet));
if (new_friend_lossless_packet == nullptr) {
return nullptr;
}
events->friend_lossless_packet = new_friend_lossless_packet;
events->friend_lossless_packet_capacity = new_friend_lossless_packet_capacity;
}
Tox_Event_Friend_Lossless_Packet *const friend_lossless_packet =
&events->friend_lossless_packet[events->friend_lossless_packet_size];
tox_event_friend_lossless_packet_construct(friend_lossless_packet);
++events->friend_lossless_packet_size;
return friend_lossless_packet;
}
void tox_events_clear_friend_lossless_packet(Tox_Events *events)
void tox_event_friend_lossless_packet_free(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_lossless_packet != nullptr) {
tox_event_friend_lossless_packet_destruct(friend_lossless_packet, mem);
}
for (uint32_t i = 0; i < events->friend_lossless_packet_size; ++i) {
tox_event_friend_lossless_packet_destruct(&events->friend_lossless_packet[i]);
}
free(events->friend_lossless_packet);
events->friend_lossless_packet = nullptr;
events->friend_lossless_packet_size = 0;
events->friend_lossless_packet_capacity = 0;
mem_delete(mem, friend_lossless_packet);
}
uint32_t tox_events_get_friend_lossless_packet_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Lossless_Packet *tox_events_add_friend_lossless_packet(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Lossless_Packet *const friend_lossless_packet = tox_event_friend_lossless_packet_new(mem);
if (friend_lossless_packet == nullptr) {
return nullptr;
}
return events->friend_lossless_packet_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_LOSSLESS_PACKET;
event.data.friend_lossless_packet = friend_lossless_packet;
tox_events_add(events, &event);
return friend_lossless_packet;
}
const Tox_Event_Friend_Lossless_Packet *tox_events_get_friend_lossless_packet(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_lossless_packet_size);
assert(events->friend_lossless_packet != nullptr);
return &events->friend_lossless_packet[index];
}
bool tox_events_pack_friend_lossless_packet(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_lossless_packet_size(events);
uint32_t friend_lossless_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_lossless_packet_pack(tox_events_get_friend_lossless_packet(events, i), bp)) {
return false;
if (friend_lossless_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSLESS_PACKET) {
const Tox_Event_Friend_Lossless_Packet *friend_lossless_packet = events->events[i].data.friend_lossless_packet;
if (friend_lossless_packet_index == index) {
return friend_lossless_packet;
}
++friend_lossless_packet_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_lossless_packet(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_lossless_packet_size(const Tox_Events *events)
{
Tox_Event_Friend_Lossless_Packet *event = tox_events_add_friend_lossless_packet(events);
uint32_t friend_lossless_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSLESS_PACKET) {
++friend_lossless_packet_size;
}
}
return friend_lossless_packet_size;
}
bool tox_event_friend_lossless_packet_unpack(
Tox_Event_Friend_Lossless_Packet **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_lossless_packet_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_lossless_packet_unpack(event, bu);
return tox_event_friend_lossless_packet_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Lossless_Packet *tox_event_friend_lossless_packet_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Lossless_Packet *friend_lossless_packet = tox_events_add_friend_lossless_packet(state->events, state->mem);
if (friend_lossless_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_lossless_packet;
}
@ -214,17 +242,9 @@ bool tox_events_unpack_friend_lossless_packet(Tox_Events *events, Bin_Unpack *bu
void tox_events_handle_friend_lossless_packet(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);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Lossless_Packet *friend_lossless_packet = tox_events_add_friend_lossless_packet(state->events);
Tox_Event_Friend_Lossless_Packet *friend_lossless_packet = tox_event_friend_lossless_packet_alloc(user_data);
if (friend_lossless_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

175
external/toxcore/c-toxcore/toxcore/events/friend_lossy_packet.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -28,19 +29,6 @@ struct Tox_Event_Friend_Lossy_Packet {
uint32_t data_length;
};
non_null()
static void tox_event_friend_lossy_packet_construct(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet)
{
*friend_lossy_packet = (Tox_Event_Friend_Lossy_Packet) {
0
};
}
non_null()
static void tox_event_friend_lossy_packet_destruct(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet)
{
free(friend_lossy_packet->data);
}
non_null()
static void tox_event_friend_lossy_packet_set_friend_number(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet,
uint32_t friend_number)
@ -88,7 +76,19 @@ const uint8_t *tox_event_friend_lossy_packet_get_data(const Tox_Event_Friend_Los
}
non_null()
static bool tox_event_friend_lossy_packet_pack(
static void tox_event_friend_lossy_packet_construct(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet)
{
*friend_lossy_packet = (Tox_Event_Friend_Lossy_Packet) {
0
};
}
non_null()
static void tox_event_friend_lossy_packet_destruct(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet, const Memory *mem)
{
free(friend_lossy_packet->data);
}
bool tox_event_friend_lossy_packet_pack(
const Tox_Event_Friend_Lossy_Packet *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -100,7 +100,7 @@ static bool tox_event_friend_lossy_packet_pack(
}
non_null()
static bool tox_event_friend_lossy_packet_unpack(
static bool tox_event_friend_lossy_packet_unpack_into(
Tox_Event_Friend_Lossy_Packet *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -115,91 +115,120 @@ static bool tox_event_friend_lossy_packet_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Lossy_Packet *tox_events_add_friend_lossy_packet(Tox_Events *events)
const Tox_Event_Friend_Lossy_Packet *tox_event_get_friend_lossy_packet(const Tox_Event *event)
{
if (events->friend_lossy_packet_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_LOSSY_PACKET ? event->data.friend_lossy_packet : nullptr;
}
Tox_Event_Friend_Lossy_Packet *tox_event_friend_lossy_packet_new(const Memory *mem)
{
Tox_Event_Friend_Lossy_Packet *const friend_lossy_packet =
(Tox_Event_Friend_Lossy_Packet *)mem_alloc(mem, sizeof(Tox_Event_Friend_Lossy_Packet));
if (friend_lossy_packet == nullptr) {
return nullptr;
}
if (events->friend_lossy_packet_size == events->friend_lossy_packet_capacity) {
const uint32_t new_friend_lossy_packet_capacity = events->friend_lossy_packet_capacity * 2 + 1;
Tox_Event_Friend_Lossy_Packet *new_friend_lossy_packet = (Tox_Event_Friend_Lossy_Packet *)realloc(
events->friend_lossy_packet, new_friend_lossy_packet_capacity * sizeof(Tox_Event_Friend_Lossy_Packet));
if (new_friend_lossy_packet == nullptr) {
return nullptr;
}
events->friend_lossy_packet = new_friend_lossy_packet;
events->friend_lossy_packet_capacity = new_friend_lossy_packet_capacity;
}
Tox_Event_Friend_Lossy_Packet *const friend_lossy_packet =
&events->friend_lossy_packet[events->friend_lossy_packet_size];
tox_event_friend_lossy_packet_construct(friend_lossy_packet);
++events->friend_lossy_packet_size;
return friend_lossy_packet;
}
void tox_events_clear_friend_lossy_packet(Tox_Events *events)
void tox_event_friend_lossy_packet_free(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_lossy_packet != nullptr) {
tox_event_friend_lossy_packet_destruct(friend_lossy_packet, mem);
}
for (uint32_t i = 0; i < events->friend_lossy_packet_size; ++i) {
tox_event_friend_lossy_packet_destruct(&events->friend_lossy_packet[i]);
}
free(events->friend_lossy_packet);
events->friend_lossy_packet = nullptr;
events->friend_lossy_packet_size = 0;
events->friend_lossy_packet_capacity = 0;
mem_delete(mem, friend_lossy_packet);
}
uint32_t tox_events_get_friend_lossy_packet_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Lossy_Packet *tox_events_add_friend_lossy_packet(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Lossy_Packet *const friend_lossy_packet = tox_event_friend_lossy_packet_new(mem);
if (friend_lossy_packet == nullptr) {
return nullptr;
}
return events->friend_lossy_packet_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_LOSSY_PACKET;
event.data.friend_lossy_packet = friend_lossy_packet;
tox_events_add(events, &event);
return friend_lossy_packet;
}
const Tox_Event_Friend_Lossy_Packet *tox_events_get_friend_lossy_packet(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_lossy_packet_size);
assert(events->friend_lossy_packet != nullptr);
return &events->friend_lossy_packet[index];
}
bool tox_events_pack_friend_lossy_packet(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_lossy_packet_size(events);
uint32_t friend_lossy_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_lossy_packet_pack(tox_events_get_friend_lossy_packet(events, i), bp)) {
return false;
if (friend_lossy_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSY_PACKET) {
const Tox_Event_Friend_Lossy_Packet *friend_lossy_packet = events->events[i].data.friend_lossy_packet;
if (friend_lossy_packet_index == index) {
return friend_lossy_packet;
}
++friend_lossy_packet_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_lossy_packet(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_lossy_packet_size(const Tox_Events *events)
{
Tox_Event_Friend_Lossy_Packet *event = tox_events_add_friend_lossy_packet(events);
uint32_t friend_lossy_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_LOSSY_PACKET) {
++friend_lossy_packet_size;
}
}
return friend_lossy_packet_size;
}
bool tox_event_friend_lossy_packet_unpack(
Tox_Event_Friend_Lossy_Packet **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_lossy_packet_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_lossy_packet_unpack(event, bu);
return tox_event_friend_lossy_packet_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Lossy_Packet *tox_event_friend_lossy_packet_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Lossy_Packet *friend_lossy_packet = tox_events_add_friend_lossy_packet(state->events, state->mem);
if (friend_lossy_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_lossy_packet;
}
@ -213,17 +242,9 @@ bool tox_events_unpack_friend_lossy_packet(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_friend_lossy_packet(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);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Lossy_Packet *friend_lossy_packet = tox_events_add_friend_lossy_packet(state->events);
Tox_Event_Friend_Lossy_Packet *friend_lossy_packet = tox_event_friend_lossy_packet_alloc(user_data);
if (friend_lossy_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

186
external/toxcore/c-toxcore/toxcore/events/friend_message.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -30,19 +30,6 @@ struct Tox_Event_Friend_Message {
uint32_t message_length;
};
non_null()
static void tox_event_friend_message_construct(Tox_Event_Friend_Message *friend_message)
{
*friend_message = (Tox_Event_Friend_Message) {
0
};
}
non_null()
static void tox_event_friend_message_destruct(Tox_Event_Friend_Message *friend_message)
{
free(friend_message->message);
}
non_null()
static void tox_event_friend_message_set_friend_number(Tox_Event_Friend_Message *friend_message,
uint32_t friend_number)
@ -57,7 +44,8 @@ uint32_t tox_event_friend_message_get_friend_number(const Tox_Event_Friend_Messa
}
non_null()
static void tox_event_friend_message_set_type(Tox_Event_Friend_Message *friend_message, Tox_Message_Type type)
static void tox_event_friend_message_set_type(Tox_Event_Friend_Message *friend_message,
Tox_Message_Type type)
{
assert(friend_message != nullptr);
friend_message->type = type;
@ -69,8 +57,8 @@ Tox_Message_Type tox_event_friend_message_get_type(const Tox_Event_Friend_Messag
}
non_null()
static bool tox_event_friend_message_set_message(Tox_Event_Friend_Message *friend_message, const uint8_t *message,
uint32_t message_length)
static bool tox_event_friend_message_set_message(Tox_Event_Friend_Message *friend_message,
const uint8_t *message, uint32_t message_length)
{
assert(friend_message != nullptr);
@ -102,7 +90,19 @@ const uint8_t *tox_event_friend_message_get_message(const Tox_Event_Friend_Messa
}
non_null()
static bool tox_event_friend_message_pack(
static void tox_event_friend_message_construct(Tox_Event_Friend_Message *friend_message)
{
*friend_message = (Tox_Event_Friend_Message) {
0
};
}
non_null()
static void tox_event_friend_message_destruct(Tox_Event_Friend_Message *friend_message, const Memory *mem)
{
free(friend_message->message);
}
bool tox_event_friend_message_pack(
const Tox_Event_Friend_Message *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -115,7 +115,7 @@ static bool tox_event_friend_message_pack(
}
non_null()
static bool tox_event_friend_message_unpack(
static bool tox_event_friend_message_unpack_into(
Tox_Event_Friend_Message *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -124,97 +124,127 @@ static bool tox_event_friend_message_unpack(
}
return bin_unpack_u32(bu, &event->friend_number)
&& tox_unpack_message_type(bu, &event->type)
&& tox_message_type_unpack(bu, &event->type)
&& bin_unpack_bin(bu, &event->message, &event->message_length);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Message *tox_events_add_friend_message(Tox_Events *events)
const Tox_Event_Friend_Message *tox_event_get_friend_message(const Tox_Event *event)
{
if (events->friend_message_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_MESSAGE ? event->data.friend_message : nullptr;
}
Tox_Event_Friend_Message *tox_event_friend_message_new(const Memory *mem)
{
Tox_Event_Friend_Message *const friend_message =
(Tox_Event_Friend_Message *)mem_alloc(mem, sizeof(Tox_Event_Friend_Message));
if (friend_message == nullptr) {
return nullptr;
}
if (events->friend_message_size == events->friend_message_capacity) {
const uint32_t new_friend_message_capacity = events->friend_message_capacity * 2 + 1;
Tox_Event_Friend_Message *new_friend_message = (Tox_Event_Friend_Message *)realloc(
events->friend_message, new_friend_message_capacity * sizeof(Tox_Event_Friend_Message));
if (new_friend_message == nullptr) {
return nullptr;
}
events->friend_message = new_friend_message;
events->friend_message_capacity = new_friend_message_capacity;
}
Tox_Event_Friend_Message *const friend_message = &events->friend_message[events->friend_message_size];
tox_event_friend_message_construct(friend_message);
++events->friend_message_size;
return friend_message;
}
void tox_events_clear_friend_message(Tox_Events *events)
void tox_event_friend_message_free(Tox_Event_Friend_Message *friend_message, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_message != nullptr) {
tox_event_friend_message_destruct(friend_message, mem);
}
for (uint32_t i = 0; i < events->friend_message_size; ++i) {
tox_event_friend_message_destruct(&events->friend_message[i]);
}
free(events->friend_message);
events->friend_message = nullptr;
events->friend_message_size = 0;
events->friend_message_capacity = 0;
mem_delete(mem, friend_message);
}
uint32_t tox_events_get_friend_message_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Message *tox_events_add_friend_message(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Message *const friend_message = tox_event_friend_message_new(mem);
if (friend_message == nullptr) {
return nullptr;
}
return events->friend_message_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_MESSAGE;
event.data.friend_message = friend_message;
tox_events_add(events, &event);
return friend_message;
}
const Tox_Event_Friend_Message *tox_events_get_friend_message(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_message_size);
assert(events->friend_message != nullptr);
return &events->friend_message[index];
}
bool tox_events_pack_friend_message(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_message_size(events);
uint32_t friend_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_message_pack(tox_events_get_friend_message(events, i), bp)) {
return false;
if (friend_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_MESSAGE) {
const Tox_Event_Friend_Message *friend_message = events->events[i].data.friend_message;
if (friend_message_index == index) {
return friend_message;
}
++friend_message_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_message(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_message_size(const Tox_Events *events)
{
Tox_Event_Friend_Message *event = tox_events_add_friend_message(events);
uint32_t friend_message_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_MESSAGE) {
++friend_message_size;
}
}
return friend_message_size;
}
bool tox_event_friend_message_unpack(
Tox_Event_Friend_Message **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_message_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_message_unpack(event, bu);
return tox_event_friend_message_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Message *tox_event_friend_message_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Message *friend_message = tox_events_add_friend_message(state->events, state->mem);
if (friend_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_message;
}
@ -225,20 +255,12 @@ bool tox_events_unpack_friend_message(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
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)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Message *friend_message = tox_events_add_friend_message(state->events);
Tox_Event_Friend_Message *friend_message = tox_event_friend_message_alloc(user_data);
if (friend_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

180
external/toxcore/c-toxcore/toxcore/events/friend_name.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -28,19 +29,6 @@ struct Tox_Event_Friend_Name {
uint32_t name_length;
};
non_null()
static void tox_event_friend_name_construct(Tox_Event_Friend_Name *friend_name)
{
*friend_name = (Tox_Event_Friend_Name) {
0
};
}
non_null()
static void tox_event_friend_name_destruct(Tox_Event_Friend_Name *friend_name)
{
free(friend_name->name);
}
non_null()
static void tox_event_friend_name_set_friend_number(Tox_Event_Friend_Name *friend_name,
uint32_t friend_number)
@ -55,8 +43,8 @@ uint32_t tox_event_friend_name_get_friend_number(const Tox_Event_Friend_Name *fr
}
non_null()
static bool tox_event_friend_name_set_name(Tox_Event_Friend_Name *friend_name, const uint8_t *name,
uint32_t name_length)
static bool tox_event_friend_name_set_name(Tox_Event_Friend_Name *friend_name,
const uint8_t *name, uint32_t name_length)
{
assert(friend_name != nullptr);
@ -88,7 +76,19 @@ const uint8_t *tox_event_friend_name_get_name(const Tox_Event_Friend_Name *frien
}
non_null()
static bool tox_event_friend_name_pack(
static void tox_event_friend_name_construct(Tox_Event_Friend_Name *friend_name)
{
*friend_name = (Tox_Event_Friend_Name) {
0
};
}
non_null()
static void tox_event_friend_name_destruct(Tox_Event_Friend_Name *friend_name, const Memory *mem)
{
free(friend_name->name);
}
bool tox_event_friend_name_pack(
const Tox_Event_Friend_Name *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -100,7 +100,7 @@ static bool tox_event_friend_name_pack(
}
non_null()
static bool tox_event_friend_name_unpack(
static bool tox_event_friend_name_unpack_into(
Tox_Event_Friend_Name *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -115,90 +115,120 @@ static bool tox_event_friend_name_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Name *tox_events_add_friend_name(Tox_Events *events)
const Tox_Event_Friend_Name *tox_event_get_friend_name(const Tox_Event *event)
{
if (events->friend_name_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_NAME ? event->data.friend_name : nullptr;
}
Tox_Event_Friend_Name *tox_event_friend_name_new(const Memory *mem)
{
Tox_Event_Friend_Name *const friend_name =
(Tox_Event_Friend_Name *)mem_alloc(mem, sizeof(Tox_Event_Friend_Name));
if (friend_name == nullptr) {
return nullptr;
}
if (events->friend_name_size == events->friend_name_capacity) {
const uint32_t new_friend_name_capacity = events->friend_name_capacity * 2 + 1;
Tox_Event_Friend_Name *new_friend_name = (Tox_Event_Friend_Name *)realloc(
events->friend_name, new_friend_name_capacity * sizeof(Tox_Event_Friend_Name));
if (new_friend_name == nullptr) {
return nullptr;
}
events->friend_name = new_friend_name;
events->friend_name_capacity = new_friend_name_capacity;
}
Tox_Event_Friend_Name *const friend_name = &events->friend_name[events->friend_name_size];
tox_event_friend_name_construct(friend_name);
++events->friend_name_size;
return friend_name;
}
void tox_events_clear_friend_name(Tox_Events *events)
void tox_event_friend_name_free(Tox_Event_Friend_Name *friend_name, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_name != nullptr) {
tox_event_friend_name_destruct(friend_name, mem);
}
for (uint32_t i = 0; i < events->friend_name_size; ++i) {
tox_event_friend_name_destruct(&events->friend_name[i]);
}
free(events->friend_name);
events->friend_name = nullptr;
events->friend_name_size = 0;
events->friend_name_capacity = 0;
mem_delete(mem, friend_name);
}
uint32_t tox_events_get_friend_name_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Name *tox_events_add_friend_name(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Name *const friend_name = tox_event_friend_name_new(mem);
if (friend_name == nullptr) {
return nullptr;
}
return events->friend_name_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_NAME;
event.data.friend_name = friend_name;
tox_events_add(events, &event);
return friend_name;
}
const Tox_Event_Friend_Name *tox_events_get_friend_name(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_name_size);
assert(events->friend_name != nullptr);
return &events->friend_name[index];
}
bool tox_events_pack_friend_name(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_name_size(events);
uint32_t friend_name_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_name_pack(tox_events_get_friend_name(events, i), bp)) {
return false;
if (friend_name_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_NAME) {
const Tox_Event_Friend_Name *friend_name = events->events[i].data.friend_name;
if (friend_name_index == index) {
return friend_name;
}
++friend_name_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_name(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_name_size(const Tox_Events *events)
{
Tox_Event_Friend_Name *event = tox_events_add_friend_name(events);
uint32_t friend_name_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_NAME) {
++friend_name_size;
}
}
return friend_name_size;
}
bool tox_event_friend_name_unpack(
Tox_Event_Friend_Name **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_name_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_name_unpack(event, bu);
return tox_event_friend_name_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Name *tox_event_friend_name_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Name *friend_name = tox_events_add_friend_name(state->events, state->mem);
if (friend_name == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_name;
}
@ -210,19 +240,11 @@ bool tox_events_unpack_friend_name(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_friend_name(Tox *tox, uint32_t friend_number, const uint8_t *name, size_t length,
void *user_data)
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Name *friend_name = tox_events_add_friend_name(state->events);
Tox_Event_Friend_Name *friend_name = tox_event_friend_name_alloc(user_data);
if (friend_name == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

178
external/toxcore/c-toxcore/toxcore/events/friend_read_receipt.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -27,19 +28,6 @@ struct Tox_Event_Friend_Read_Receipt {
uint32_t message_id;
};
non_null()
static void tox_event_friend_read_receipt_construct(Tox_Event_Friend_Read_Receipt *friend_read_receipt)
{
*friend_read_receipt = (Tox_Event_Friend_Read_Receipt) {
0
};
}
non_null()
static void tox_event_friend_read_receipt_destruct(Tox_Event_Friend_Read_Receipt *friend_read_receipt)
{
return;
}
non_null()
static void tox_event_friend_read_receipt_set_friend_number(Tox_Event_Friend_Read_Receipt *friend_read_receipt,
uint32_t friend_number)
@ -67,7 +55,19 @@ uint32_t tox_event_friend_read_receipt_get_message_id(const Tox_Event_Friend_Rea
}
non_null()
static bool tox_event_friend_read_receipt_pack(
static void tox_event_friend_read_receipt_construct(Tox_Event_Friend_Read_Receipt *friend_read_receipt)
{
*friend_read_receipt = (Tox_Event_Friend_Read_Receipt) {
0
};
}
non_null()
static void tox_event_friend_read_receipt_destruct(Tox_Event_Friend_Read_Receipt *friend_read_receipt, const Memory *mem)
{
return;
}
bool tox_event_friend_read_receipt_pack(
const Tox_Event_Friend_Read_Receipt *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -79,7 +79,7 @@ static bool tox_event_friend_read_receipt_pack(
}
non_null()
static bool tox_event_friend_read_receipt_unpack(
static bool tox_event_friend_read_receipt_unpack_into(
Tox_Event_Friend_Read_Receipt *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -94,91 +94,120 @@ static bool tox_event_friend_read_receipt_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Read_Receipt *tox_events_add_friend_read_receipt(Tox_Events *events)
const Tox_Event_Friend_Read_Receipt *tox_event_get_friend_read_receipt(const Tox_Event *event)
{
if (events->friend_read_receipt_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_READ_RECEIPT ? event->data.friend_read_receipt : nullptr;
}
Tox_Event_Friend_Read_Receipt *tox_event_friend_read_receipt_new(const Memory *mem)
{
Tox_Event_Friend_Read_Receipt *const friend_read_receipt =
(Tox_Event_Friend_Read_Receipt *)mem_alloc(mem, sizeof(Tox_Event_Friend_Read_Receipt));
if (friend_read_receipt == nullptr) {
return nullptr;
}
if (events->friend_read_receipt_size == events->friend_read_receipt_capacity) {
const uint32_t new_friend_read_receipt_capacity = events->friend_read_receipt_capacity * 2 + 1;
Tox_Event_Friend_Read_Receipt *new_friend_read_receipt = (Tox_Event_Friend_Read_Receipt *)realloc(
events->friend_read_receipt, new_friend_read_receipt_capacity * sizeof(Tox_Event_Friend_Read_Receipt));
if (new_friend_read_receipt == nullptr) {
return nullptr;
}
events->friend_read_receipt = new_friend_read_receipt;
events->friend_read_receipt_capacity = new_friend_read_receipt_capacity;
}
Tox_Event_Friend_Read_Receipt *const friend_read_receipt =
&events->friend_read_receipt[events->friend_read_receipt_size];
tox_event_friend_read_receipt_construct(friend_read_receipt);
++events->friend_read_receipt_size;
return friend_read_receipt;
}
void tox_events_clear_friend_read_receipt(Tox_Events *events)
void tox_event_friend_read_receipt_free(Tox_Event_Friend_Read_Receipt *friend_read_receipt, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_read_receipt != nullptr) {
tox_event_friend_read_receipt_destruct(friend_read_receipt, mem);
}
for (uint32_t i = 0; i < events->friend_read_receipt_size; ++i) {
tox_event_friend_read_receipt_destruct(&events->friend_read_receipt[i]);
}
free(events->friend_read_receipt);
events->friend_read_receipt = nullptr;
events->friend_read_receipt_size = 0;
events->friend_read_receipt_capacity = 0;
mem_delete(mem, friend_read_receipt);
}
uint32_t tox_events_get_friend_read_receipt_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Read_Receipt *tox_events_add_friend_read_receipt(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Read_Receipt *const friend_read_receipt = tox_event_friend_read_receipt_new(mem);
if (friend_read_receipt == nullptr) {
return nullptr;
}
return events->friend_read_receipt_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_READ_RECEIPT;
event.data.friend_read_receipt = friend_read_receipt;
tox_events_add(events, &event);
return friend_read_receipt;
}
const Tox_Event_Friend_Read_Receipt *tox_events_get_friend_read_receipt(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_read_receipt_size);
assert(events->friend_read_receipt != nullptr);
return &events->friend_read_receipt[index];
}
bool tox_events_pack_friend_read_receipt(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_read_receipt_size(events);
uint32_t friend_read_receipt_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_read_receipt_pack(tox_events_get_friend_read_receipt(events, i), bp)) {
return false;
if (friend_read_receipt_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_READ_RECEIPT) {
const Tox_Event_Friend_Read_Receipt *friend_read_receipt = events->events[i].data.friend_read_receipt;
if (friend_read_receipt_index == index) {
return friend_read_receipt;
}
++friend_read_receipt_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_read_receipt(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_read_receipt_size(const Tox_Events *events)
{
Tox_Event_Friend_Read_Receipt *event = tox_events_add_friend_read_receipt(events);
uint32_t friend_read_receipt_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_READ_RECEIPT) {
++friend_read_receipt_size;
}
}
return friend_read_receipt_size;
}
bool tox_event_friend_read_receipt_unpack(
Tox_Event_Friend_Read_Receipt **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_read_receipt_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_read_receipt_unpack(event, bu);
return tox_event_friend_read_receipt_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Read_Receipt *tox_event_friend_read_receipt_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Read_Receipt *friend_read_receipt = tox_events_add_friend_read_receipt(state->events, state->mem);
if (friend_read_receipt == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_read_receipt;
}
@ -189,19 +218,12 @@ bool tox_events_unpack_friend_read_receipt(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
void tox_events_handle_friend_read_receipt(Tox *tox, uint32_t friend_number, uint32_t message_id, void *user_data)
void tox_events_handle_friend_read_receipt(Tox *tox, uint32_t friend_number, uint32_t message_id,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Read_Receipt *friend_read_receipt = tox_events_add_friend_read_receipt(state->events);
Tox_Event_Friend_Read_Receipt *friend_read_receipt = tox_event_friend_read_receipt_alloc(user_data);
if (friend_read_receipt == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

196
external/toxcore/c-toxcore/toxcore/events/friend_request.c vendored
View File

@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_private.h"
/*****************************************************
@ -28,19 +29,6 @@ struct Tox_Event_Friend_Request {
uint32_t message_length;
};
non_null()
static void tox_event_friend_request_construct(Tox_Event_Friend_Request *friend_request)
{
*friend_request = (Tox_Event_Friend_Request) {
0
};
}
non_null()
static void tox_event_friend_request_destruct(Tox_Event_Friend_Request *friend_request)
{
free(friend_request->message);
}
non_null()
static bool tox_event_friend_request_set_public_key(Tox_Event_Friend_Request *friend_request, const uint8_t *public_key)
{
@ -56,24 +44,24 @@ const uint8_t *tox_event_friend_request_get_public_key(const Tox_Event_Friend_Re
}
non_null()
static bool tox_event_friend_request_set_message(Tox_Event_Friend_Request *friend_request, const uint8_t *message,
uint32_t message_length)
static bool tox_event_friend_request_set_message(Tox_Event_Friend_Request *friend_request,
const uint8_t *message, uint32_t message_length, const Memory *mem)
{
assert(friend_request != nullptr);
if (friend_request->message != nullptr) {
free(friend_request->message);
mem_delete(mem, friend_request->message);
friend_request->message = nullptr;
friend_request->message_length = 0;
}
friend_request->message = (uint8_t *)malloc(message_length);
friend_request->message = (uint8_t *)mem_balloc(mem, message_length * sizeof(uint8_t));
if (friend_request->message == nullptr) {
return false;
}
memcpy(friend_request->message, message, message_length);
memcpy(friend_request->message, message, message_length * sizeof(uint8_t));
friend_request->message_length = message_length;
return true;
}
@ -89,7 +77,19 @@ const uint8_t *tox_event_friend_request_get_message(const Tox_Event_Friend_Reque
}
non_null()
static bool tox_event_friend_request_pack(
static void tox_event_friend_request_construct(Tox_Event_Friend_Request *friend_request)
{
*friend_request = (Tox_Event_Friend_Request) {
0
};
}
non_null()
static void tox_event_friend_request_destruct(Tox_Event_Friend_Request *friend_request, const Memory *mem)
{
mem_delete(mem, friend_request->message);
}
bool tox_event_friend_request_pack(
const Tox_Event_Friend_Request *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -101,7 +101,7 @@ static bool tox_event_friend_request_pack(
}
non_null()
static bool tox_event_friend_request_unpack(
static bool tox_event_friend_request_unpack_into(
Tox_Event_Friend_Request *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -113,93 +113,119 @@ static bool tox_event_friend_request_unpack(
&& bin_unpack_bin(bu, &event->message, &event->message_length);
}
/*****************************************************
*
* :: add/clear/get
*
*****************************************************/
non_null()
static Tox_Event_Friend_Request *tox_events_add_friend_request(Tox_Events *events)
const Tox_Event_Friend_Request *tox_event_get_friend_request(
const Tox_Event *event)
{
if (events->friend_request_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_REQUEST ? event->data.friend_request : nullptr;
}
Tox_Event_Friend_Request *tox_event_friend_request_new(const Memory *mem)
{
Tox_Event_Friend_Request *const friend_request =
(Tox_Event_Friend_Request *)mem_alloc(mem, sizeof(Tox_Event_Friend_Request));
if (friend_request == nullptr) {
return nullptr;
}
if (events->friend_request_size == events->friend_request_capacity) {
const uint32_t new_friend_request_capacity = events->friend_request_capacity * 2 + 1;
Tox_Event_Friend_Request *new_friend_request = (Tox_Event_Friend_Request *)realloc(
events->friend_request, new_friend_request_capacity * sizeof(Tox_Event_Friend_Request));
if (new_friend_request == nullptr) {
return nullptr;
}
events->friend_request = new_friend_request;
events->friend_request_capacity = new_friend_request_capacity;
}
Tox_Event_Friend_Request *const friend_request = &events->friend_request[events->friend_request_size];
tox_event_friend_request_construct(friend_request);
++events->friend_request_size;
return friend_request;
}
void tox_events_clear_friend_request(Tox_Events *events)
void tox_event_friend_request_free(Tox_Event_Friend_Request *friend_request, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_request != nullptr) {
tox_event_friend_request_destruct(friend_request, mem);
}
for (uint32_t i = 0; i < events->friend_request_size; ++i) {
tox_event_friend_request_destruct(&events->friend_request[i]);
}
free(events->friend_request);
events->friend_request = nullptr;
events->friend_request_size = 0;
events->friend_request_capacity = 0;
mem_delete(mem, friend_request);
}
uint32_t tox_events_get_friend_request_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Request *tox_events_add_friend_request(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Request *const friend_request = tox_event_friend_request_new(mem);
if (friend_request == nullptr) {
return nullptr;
}
return events->friend_request_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_REQUEST;
event.data.friend_request = friend_request;
tox_events_add(events, &event);
return friend_request;
}
const Tox_Event_Friend_Request *tox_events_get_friend_request(const Tox_Events *events, uint32_t index)
const Tox_Event_Friend_Request *tox_events_get_friend_request(
const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_request_size);
assert(events->friend_request != nullptr);
return &events->friend_request[index];
}
bool tox_events_pack_friend_request(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_request_size(events);
uint32_t friend_request_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_request_pack(tox_events_get_friend_request(events, i), bp)) {
return false;
if (friend_request_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_REQUEST) {
const Tox_Event_Friend_Request *friend_request = events->events[i].data.friend_request;
if (friend_request_index == index) {
return friend_request;
}
++friend_request_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_request(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_request_size(
const Tox_Events *events)
{
Tox_Event_Friend_Request *event = tox_events_add_friend_request(events);
uint32_t friend_request_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_REQUEST) {
++friend_request_size;
}
}
return friend_request_size;
}
bool tox_event_friend_request_unpack(
Tox_Event_Friend_Request **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_request_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_request_unpack(event, bu);
return tox_event_friend_request_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Request *tox_event_friend_request_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Request *friend_request = tox_events_add_friend_request(state->events, state->mem);
if (friend_request == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_request;
}
@ -213,20 +239,14 @@ bool tox_events_unpack_friend_request(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_friend_request(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);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Request *friend_request = tox_events_add_friend_request(state->events);
Tox_Event_Friend_Request *friend_request = tox_event_friend_request_alloc(user_data);
if (friend_request == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
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);
tox_event_friend_request_set_message(friend_request, message, length, sys->mem);
}

177
external/toxcore/c-toxcore/toxcore/events/friend_status.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -28,19 +28,6 @@ struct Tox_Event_Friend_Status {
Tox_User_Status status;
};
non_null()
static void tox_event_friend_status_construct(Tox_Event_Friend_Status *friend_status)
{
*friend_status = (Tox_Event_Friend_Status) {
0
};
}
non_null()
static void tox_event_friend_status_destruct(Tox_Event_Friend_Status *friend_status)
{
return;
}
non_null()
static void tox_event_friend_status_set_friend_number(Tox_Event_Friend_Status *friend_status,
uint32_t friend_number)
@ -68,7 +55,19 @@ Tox_User_Status tox_event_friend_status_get_status(const Tox_Event_Friend_Status
}
non_null()
static bool tox_event_friend_status_pack(
static void tox_event_friend_status_construct(Tox_Event_Friend_Status *friend_status)
{
*friend_status = (Tox_Event_Friend_Status) {
0
};
}
non_null()
static void tox_event_friend_status_destruct(Tox_Event_Friend_Status *friend_status, const Memory *mem)
{
return;
}
bool tox_event_friend_status_pack(
const Tox_Event_Friend_Status *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -80,7 +79,7 @@ static bool tox_event_friend_status_pack(
}
non_null()
static bool tox_event_friend_status_unpack(
static bool tox_event_friend_status_unpack_into(
Tox_Event_Friend_Status *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -89,96 +88,126 @@ static bool tox_event_friend_status_unpack(
}
return bin_unpack_u32(bu, &event->friend_number)
&& tox_unpack_user_status(bu, &event->status);
&& tox_user_status_unpack(bu, &event->status);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Status *tox_events_add_friend_status(Tox_Events *events)
const Tox_Event_Friend_Status *tox_event_get_friend_status(const Tox_Event *event)
{
if (events->friend_status_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_STATUS ? event->data.friend_status : nullptr;
}
Tox_Event_Friend_Status *tox_event_friend_status_new(const Memory *mem)
{
Tox_Event_Friend_Status *const friend_status =
(Tox_Event_Friend_Status *)mem_alloc(mem, sizeof(Tox_Event_Friend_Status));
if (friend_status == nullptr) {
return nullptr;
}
if (events->friend_status_size == events->friend_status_capacity) {
const uint32_t new_friend_status_capacity = events->friend_status_capacity * 2 + 1;
Tox_Event_Friend_Status *new_friend_status = (Tox_Event_Friend_Status *)realloc(
events->friend_status, new_friend_status_capacity * sizeof(Tox_Event_Friend_Status));
if (new_friend_status == nullptr) {
return nullptr;
}
events->friend_status = new_friend_status;
events->friend_status_capacity = new_friend_status_capacity;
}
Tox_Event_Friend_Status *const friend_status = &events->friend_status[events->friend_status_size];
tox_event_friend_status_construct(friend_status);
++events->friend_status_size;
return friend_status;
}
void tox_events_clear_friend_status(Tox_Events *events)
void tox_event_friend_status_free(Tox_Event_Friend_Status *friend_status, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_status != nullptr) {
tox_event_friend_status_destruct(friend_status, mem);
}
for (uint32_t i = 0; i < events->friend_status_size; ++i) {
tox_event_friend_status_destruct(&events->friend_status[i]);
}
free(events->friend_status);
events->friend_status = nullptr;
events->friend_status_size = 0;
events->friend_status_capacity = 0;
mem_delete(mem, friend_status);
}
uint32_t tox_events_get_friend_status_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Status *tox_events_add_friend_status(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Status *const friend_status = tox_event_friend_status_new(mem);
if (friend_status == nullptr) {
return nullptr;
}
return events->friend_status_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_STATUS;
event.data.friend_status = friend_status;
tox_events_add(events, &event);
return friend_status;
}
const Tox_Event_Friend_Status *tox_events_get_friend_status(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_status_size);
assert(events->friend_status != nullptr);
return &events->friend_status[index];
}
bool tox_events_pack_friend_status(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_status_size(events);
uint32_t friend_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_status_pack(tox_events_get_friend_status(events, i), bp)) {
return false;
if (friend_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS) {
const Tox_Event_Friend_Status *friend_status = events->events[i].data.friend_status;
if (friend_status_index == index) {
return friend_status;
}
++friend_status_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_status(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_status_size(const Tox_Events *events)
{
Tox_Event_Friend_Status *event = tox_events_add_friend_status(events);
uint32_t friend_status_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS) {
++friend_status_size;
}
}
return friend_status_size;
}
bool tox_event_friend_status_unpack(
Tox_Event_Friend_Status **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_status_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_status_unpack(event, bu);
return tox_event_friend_status_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Status *tox_event_friend_status_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Status *friend_status = tox_events_add_friend_status(state->events, state->mem);
if (friend_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_status;
}
@ -190,19 +219,11 @@ bool tox_events_unpack_friend_status(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_friend_status(Tox *tox, uint32_t friend_number, Tox_User_Status status,
void *user_data)
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Status *friend_status = tox_events_add_friend_status(state->events);
Tox_Event_Friend_Status *friend_status = tox_event_friend_status_alloc(user_data);
if (friend_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

185
external/toxcore/c-toxcore/toxcore/events/friend_status_message.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -28,19 +29,6 @@ struct Tox_Event_Friend_Status_Message {
uint32_t message_length;
};
non_null()
static void tox_event_friend_status_message_construct(Tox_Event_Friend_Status_Message *friend_status_message)
{
*friend_status_message = (Tox_Event_Friend_Status_Message) {
0
};
}
non_null()
static void tox_event_friend_status_message_destruct(Tox_Event_Friend_Status_Message *friend_status_message)
{
free(friend_status_message->message);
}
non_null()
static void tox_event_friend_status_message_set_friend_number(Tox_Event_Friend_Status_Message *friend_status_message,
uint32_t friend_number)
@ -76,21 +64,31 @@ static bool tox_event_friend_status_message_set_message(Tox_Event_Friend_Status_
friend_status_message->message_length = message_length;
return true;
}
uint32_t tox_event_friend_status_message_get_message_length(const Tox_Event_Friend_Status_Message
*friend_status_message)
uint32_t tox_event_friend_status_message_get_message_length(const Tox_Event_Friend_Status_Message *friend_status_message)
{
assert(friend_status_message != nullptr);
return friend_status_message->message_length;
}
const uint8_t *tox_event_friend_status_message_get_message(const Tox_Event_Friend_Status_Message
*friend_status_message)
const uint8_t *tox_event_friend_status_message_get_message(const Tox_Event_Friend_Status_Message *friend_status_message)
{
assert(friend_status_message != nullptr);
return friend_status_message->message;
}
non_null()
static bool tox_event_friend_status_message_pack(
static void tox_event_friend_status_message_construct(Tox_Event_Friend_Status_Message *friend_status_message)
{
*friend_status_message = (Tox_Event_Friend_Status_Message) {
0
};
}
non_null()
static void tox_event_friend_status_message_destruct(Tox_Event_Friend_Status_Message *friend_status_message, const Memory *mem)
{
free(friend_status_message->message);
}
bool tox_event_friend_status_message_pack(
const Tox_Event_Friend_Status_Message *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -102,7 +100,7 @@ static bool tox_event_friend_status_message_pack(
}
non_null()
static bool tox_event_friend_status_message_unpack(
static bool tox_event_friend_status_message_unpack_into(
Tox_Event_Friend_Status_Message *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -117,91 +115,120 @@ static bool tox_event_friend_status_message_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Status_Message *tox_events_add_friend_status_message(Tox_Events *events)
const Tox_Event_Friend_Status_Message *tox_event_get_friend_status_message(const Tox_Event *event)
{
if (events->friend_status_message_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_STATUS_MESSAGE ? event->data.friend_status_message : nullptr;
}
Tox_Event_Friend_Status_Message *tox_event_friend_status_message_new(const Memory *mem)
{
Tox_Event_Friend_Status_Message *const friend_status_message =
(Tox_Event_Friend_Status_Message *)mem_alloc(mem, sizeof(Tox_Event_Friend_Status_Message));
if (friend_status_message == nullptr) {
return nullptr;
}
if (events->friend_status_message_size == events->friend_status_message_capacity) {
const uint32_t new_friend_status_message_capacity = events->friend_status_message_capacity * 2 + 1;
Tox_Event_Friend_Status_Message *new_friend_status_message = (Tox_Event_Friend_Status_Message *)realloc(
events->friend_status_message, new_friend_status_message_capacity * sizeof(Tox_Event_Friend_Status_Message));
if (new_friend_status_message == nullptr) {
return nullptr;
}
events->friend_status_message = new_friend_status_message;
events->friend_status_message_capacity = new_friend_status_message_capacity;
}
Tox_Event_Friend_Status_Message *const friend_status_message =
&events->friend_status_message[events->friend_status_message_size];
tox_event_friend_status_message_construct(friend_status_message);
++events->friend_status_message_size;
return friend_status_message;
}
void tox_events_clear_friend_status_message(Tox_Events *events)
void tox_event_friend_status_message_free(Tox_Event_Friend_Status_Message *friend_status_message, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_status_message != nullptr) {
tox_event_friend_status_message_destruct(friend_status_message, mem);
}
for (uint32_t i = 0; i < events->friend_status_message_size; ++i) {
tox_event_friend_status_message_destruct(&events->friend_status_message[i]);
}
free(events->friend_status_message);
events->friend_status_message = nullptr;
events->friend_status_message_size = 0;
events->friend_status_message_capacity = 0;
mem_delete(mem, friend_status_message);
}
uint32_t tox_events_get_friend_status_message_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Status_Message *tox_events_add_friend_status_message(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Status_Message *const friend_status_message = tox_event_friend_status_message_new(mem);
if (friend_status_message == nullptr) {
return nullptr;
}
return events->friend_status_message_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_STATUS_MESSAGE;
event.data.friend_status_message = friend_status_message;
tox_events_add(events, &event);
return friend_status_message;
}
const Tox_Event_Friend_Status_Message *tox_events_get_friend_status_message(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_status_message_size);
assert(events->friend_status_message != nullptr);
return &events->friend_status_message[index];
}
bool tox_events_pack_friend_status_message(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_status_message_size(events);
uint32_t friend_status_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_status_message_pack(tox_events_get_friend_status_message(events, i), bp)) {
return false;
if (friend_status_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS_MESSAGE) {
const Tox_Event_Friend_Status_Message *friend_status_message = events->events[i].data.friend_status_message;
if (friend_status_message_index == index) {
return friend_status_message;
}
++friend_status_message_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_status_message(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_status_message_size(const Tox_Events *events)
{
Tox_Event_Friend_Status_Message *event = tox_events_add_friend_status_message(events);
uint32_t friend_status_message_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_STATUS_MESSAGE) {
++friend_status_message_size;
}
}
return friend_status_message_size;
}
bool tox_event_friend_status_message_unpack(
Tox_Event_Friend_Status_Message **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_status_message_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_status_message_unpack(event, bu);
return tox_event_friend_status_message_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Status_Message *tox_event_friend_status_message_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Status_Message *friend_status_message = tox_events_add_friend_status_message(state->events, state->mem);
if (friend_status_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_status_message;
}
@ -212,20 +239,12 @@ bool tox_events_unpack_friend_status_message(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
void tox_events_handle_friend_status_message(Tox *tox, uint32_t friend_number, const uint8_t *message,
size_t length, void *user_data)
void tox_events_handle_friend_status_message(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);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Status_Message *friend_status_message = tox_events_add_friend_status_message(state->events);
Tox_Event_Friend_Status_Message *friend_status_message = tox_event_friend_status_message_alloc(user_data);
if (friend_status_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

180
external/toxcore/c-toxcore/toxcore/events/friend_typing.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -13,6 +13,7 @@
#include "../ccompat.h"
#include "../tox.h"
#include "../tox_events.h"
#include "../tox_unpack.h"
/*****************************************************
@ -27,19 +28,6 @@ struct Tox_Event_Friend_Typing {
bool typing;
};
non_null()
static void tox_event_friend_typing_construct(Tox_Event_Friend_Typing *friend_typing)
{
*friend_typing = (Tox_Event_Friend_Typing) {
0
};
}
non_null()
static void tox_event_friend_typing_destruct(Tox_Event_Friend_Typing *friend_typing)
{
return;
}
non_null()
static void tox_event_friend_typing_set_friend_number(Tox_Event_Friend_Typing *friend_typing,
uint32_t friend_number)
@ -54,7 +42,8 @@ uint32_t tox_event_friend_typing_get_friend_number(const Tox_Event_Friend_Typing
}
non_null()
static void tox_event_friend_typing_set_typing(Tox_Event_Friend_Typing *friend_typing, bool typing)
static void tox_event_friend_typing_set_typing(Tox_Event_Friend_Typing *friend_typing,
bool typing)
{
assert(friend_typing != nullptr);
friend_typing->typing = typing;
@ -66,7 +55,19 @@ bool tox_event_friend_typing_get_typing(const Tox_Event_Friend_Typing *friend_ty
}
non_null()
static bool tox_event_friend_typing_pack(
static void tox_event_friend_typing_construct(Tox_Event_Friend_Typing *friend_typing)
{
*friend_typing = (Tox_Event_Friend_Typing) {
0
};
}
non_null()
static void tox_event_friend_typing_destruct(Tox_Event_Friend_Typing *friend_typing, const Memory *mem)
{
return;
}
bool tox_event_friend_typing_pack(
const Tox_Event_Friend_Typing *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -78,7 +79,7 @@ static bool tox_event_friend_typing_pack(
}
non_null()
static bool tox_event_friend_typing_unpack(
static bool tox_event_friend_typing_unpack_into(
Tox_Event_Friend_Typing *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -93,90 +94,120 @@ static bool tox_event_friend_typing_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Friend_Typing *tox_events_add_friend_typing(Tox_Events *events)
const Tox_Event_Friend_Typing *tox_event_get_friend_typing(const Tox_Event *event)
{
if (events->friend_typing_size == UINT32_MAX) {
return event->type == TOX_EVENT_FRIEND_TYPING ? event->data.friend_typing : nullptr;
}
Tox_Event_Friend_Typing *tox_event_friend_typing_new(const Memory *mem)
{
Tox_Event_Friend_Typing *const friend_typing =
(Tox_Event_Friend_Typing *)mem_alloc(mem, sizeof(Tox_Event_Friend_Typing));
if (friend_typing == nullptr) {
return nullptr;
}
if (events->friend_typing_size == events->friend_typing_capacity) {
const uint32_t new_friend_typing_capacity = events->friend_typing_capacity * 2 + 1;
Tox_Event_Friend_Typing *new_friend_typing = (Tox_Event_Friend_Typing *)realloc(
events->friend_typing, new_friend_typing_capacity * sizeof(Tox_Event_Friend_Typing));
if (new_friend_typing == nullptr) {
return nullptr;
}
events->friend_typing = new_friend_typing;
events->friend_typing_capacity = new_friend_typing_capacity;
}
Tox_Event_Friend_Typing *const friend_typing = &events->friend_typing[events->friend_typing_size];
tox_event_friend_typing_construct(friend_typing);
++events->friend_typing_size;
return friend_typing;
}
void tox_events_clear_friend_typing(Tox_Events *events)
void tox_event_friend_typing_free(Tox_Event_Friend_Typing *friend_typing, const Memory *mem)
{
if (events == nullptr) {
return;
if (friend_typing != nullptr) {
tox_event_friend_typing_destruct(friend_typing, mem);
}
for (uint32_t i = 0; i < events->friend_typing_size; ++i) {
tox_event_friend_typing_destruct(&events->friend_typing[i]);
}
free(events->friend_typing);
events->friend_typing = nullptr;
events->friend_typing_size = 0;
events->friend_typing_capacity = 0;
mem_delete(mem, friend_typing);
}
uint32_t tox_events_get_friend_typing_size(const Tox_Events *events)
non_null()
static Tox_Event_Friend_Typing *tox_events_add_friend_typing(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Friend_Typing *const friend_typing = tox_event_friend_typing_new(mem);
if (friend_typing == nullptr) {
return nullptr;
}
return events->friend_typing_size;
Tox_Event event;
event.type = TOX_EVENT_FRIEND_TYPING;
event.data.friend_typing = friend_typing;
tox_events_add(events, &event);
return friend_typing;
}
const Tox_Event_Friend_Typing *tox_events_get_friend_typing(const Tox_Events *events, uint32_t index)
{
assert(index < events->friend_typing_size);
assert(events->friend_typing != nullptr);
return &events->friend_typing[index];
}
bool tox_events_pack_friend_typing(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_friend_typing_size(events);
uint32_t friend_typing_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_friend_typing_pack(tox_events_get_friend_typing(events, i), bp)) {
return false;
if (friend_typing_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_FRIEND_TYPING) {
const Tox_Event_Friend_Typing *friend_typing = events->events[i].data.friend_typing;
if (friend_typing_index == index) {
return friend_typing;
}
++friend_typing_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_friend_typing(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_friend_typing_size(const Tox_Events *events)
{
Tox_Event_Friend_Typing *event = tox_events_add_friend_typing(events);
uint32_t friend_typing_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_FRIEND_TYPING) {
++friend_typing_size;
}
}
return friend_typing_size;
}
bool tox_event_friend_typing_unpack(
Tox_Event_Friend_Typing **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_friend_typing_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_friend_typing_unpack(event, bu);
return tox_event_friend_typing_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Friend_Typing *tox_event_friend_typing_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Friend_Typing *friend_typing = tox_events_add_friend_typing(state->events, state->mem);
if (friend_typing == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return friend_typing;
}
@ -187,19 +218,12 @@ bool tox_events_unpack_friend_typing(Tox_Events *events, Bin_Unpack *bu)
*****************************************************/
void tox_events_handle_friend_typing(Tox *tox, uint32_t friend_number, bool typing, void *user_data)
void tox_events_handle_friend_typing(Tox *tox, uint32_t friend_number, bool typing,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Friend_Typing *friend_typing = tox_events_add_friend_typing(state->events);
Tox_Event_Friend_Typing *friend_typing = tox_event_friend_typing_alloc(user_data);
if (friend_typing == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_custom_packet.c vendored
View File

@ -30,19 +30,6 @@ struct Tox_Event_Group_Custom_Packet {
uint32_t data_length;
};
non_null()
static void tox_event_group_custom_packet_construct(Tox_Event_Group_Custom_Packet *group_custom_packet)
{
*group_custom_packet = (Tox_Event_Group_Custom_Packet) {
0
};
}
non_null()
static void tox_event_group_custom_packet_destruct(Tox_Event_Group_Custom_Packet *group_custom_packet)
{
free(group_custom_packet->data);
}
non_null()
static void tox_event_group_custom_packet_set_group_number(Tox_Event_Group_Custom_Packet *group_custom_packet,
uint32_t group_number)
@ -91,7 +78,7 @@ static bool tox_event_group_custom_packet_set_data(Tox_Event_Group_Custom_Packet
group_custom_packet->data_length = data_length;
return true;
}
size_t tox_event_group_custom_packet_get_data_length(const Tox_Event_Group_Custom_Packet *group_custom_packet)
uint32_t tox_event_group_custom_packet_get_data_length(const Tox_Event_Group_Custom_Packet *group_custom_packet)
{
assert(group_custom_packet != nullptr);
return group_custom_packet->data_length;
@ -103,7 +90,19 @@ const uint8_t *tox_event_group_custom_packet_get_data(const Tox_Event_Group_Cust
}
non_null()
static bool tox_event_group_custom_packet_pack(
static void tox_event_group_custom_packet_construct(Tox_Event_Group_Custom_Packet *group_custom_packet)
{
*group_custom_packet = (Tox_Event_Group_Custom_Packet) {
0
};
}
non_null()
static void tox_event_group_custom_packet_destruct(Tox_Event_Group_Custom_Packet *group_custom_packet, const Memory *mem)
{
free(group_custom_packet->data);
}
bool tox_event_group_custom_packet_pack(
const Tox_Event_Group_Custom_Packet *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -116,7 +115,7 @@ static bool tox_event_group_custom_packet_pack(
}
non_null()
static bool tox_event_group_custom_packet_unpack(
static bool tox_event_group_custom_packet_unpack_into(
Tox_Event_Group_Custom_Packet *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -132,93 +131,120 @@ static bool tox_event_group_custom_packet_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Custom_Packet *tox_events_add_group_custom_packet(Tox_Events *events)
const Tox_Event_Group_Custom_Packet *tox_event_get_group_custom_packet(const Tox_Event *event)
{
if (events->group_custom_packet_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_CUSTOM_PACKET ? event->data.group_custom_packet : nullptr;
}
Tox_Event_Group_Custom_Packet *tox_event_group_custom_packet_new(const Memory *mem)
{
Tox_Event_Group_Custom_Packet *const group_custom_packet =
(Tox_Event_Group_Custom_Packet *)mem_alloc(mem, sizeof(Tox_Event_Group_Custom_Packet));
if (group_custom_packet == nullptr) {
return nullptr;
}
if (events->group_custom_packet_size == events->group_custom_packet_capacity) {
const uint32_t new_group_custom_packet_capacity = events->group_custom_packet_capacity * 2 + 1;
Tox_Event_Group_Custom_Packet *new_group_custom_packet = (Tox_Event_Group_Custom_Packet *)
realloc(
events->group_custom_packet,
new_group_custom_packet_capacity * sizeof(Tox_Event_Group_Custom_Packet));
if (new_group_custom_packet == nullptr) {
return nullptr;
}
events->group_custom_packet = new_group_custom_packet;
events->group_custom_packet_capacity = new_group_custom_packet_capacity;
}
Tox_Event_Group_Custom_Packet *const group_custom_packet =
&events->group_custom_packet[events->group_custom_packet_size];
tox_event_group_custom_packet_construct(group_custom_packet);
++events->group_custom_packet_size;
return group_custom_packet;
}
void tox_events_clear_group_custom_packet(Tox_Events *events)
void tox_event_group_custom_packet_free(Tox_Event_Group_Custom_Packet *group_custom_packet, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_custom_packet != nullptr) {
tox_event_group_custom_packet_destruct(group_custom_packet, mem);
}
for (uint32_t i = 0; i < events->group_custom_packet_size; ++i) {
tox_event_group_custom_packet_destruct(&events->group_custom_packet[i]);
}
free(events->group_custom_packet);
events->group_custom_packet = nullptr;
events->group_custom_packet_size = 0;
events->group_custom_packet_capacity = 0;
mem_delete(mem, group_custom_packet);
}
uint32_t tox_events_get_group_custom_packet_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Custom_Packet *tox_events_add_group_custom_packet(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Custom_Packet *const group_custom_packet = tox_event_group_custom_packet_new(mem);
if (group_custom_packet == nullptr) {
return nullptr;
}
return events->group_custom_packet_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_CUSTOM_PACKET;
event.data.group_custom_packet = group_custom_packet;
tox_events_add(events, &event);
return group_custom_packet;
}
const Tox_Event_Group_Custom_Packet *tox_events_get_group_custom_packet(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_custom_packet_size);
assert(events->group_custom_packet != nullptr);
return &events->group_custom_packet[index];
}
bool tox_events_pack_group_custom_packet(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_custom_packet_size(events);
uint32_t group_custom_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_custom_packet_pack(tox_events_get_group_custom_packet(events, i), bp)) {
return false;
if (group_custom_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PACKET) {
const Tox_Event_Group_Custom_Packet *group_custom_packet = events->events[i].data.group_custom_packet;
if (group_custom_packet_index == index) {
return group_custom_packet;
}
++group_custom_packet_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_custom_packet(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_custom_packet_size(const Tox_Events *events)
{
Tox_Event_Group_Custom_Packet *event = tox_events_add_group_custom_packet(events);
uint32_t group_custom_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PACKET) {
++group_custom_packet_size;
}
}
return group_custom_packet_size;
}
bool tox_event_group_custom_packet_unpack(
Tox_Event_Group_Custom_Packet **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_custom_packet_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_custom_packet_unpack(event, bu);
return tox_event_group_custom_packet_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Custom_Packet *tox_event_group_custom_packet_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Custom_Packet *group_custom_packet = tox_events_add_group_custom_packet(state->events, state->mem);
if (group_custom_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_custom_packet;
}
@ -232,17 +258,9 @@ bool tox_events_unpack_group_custom_packet(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_custom_packet(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *data, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Custom_Packet *group_custom_packet = tox_events_add_group_custom_packet(state->events);
Tox_Event_Group_Custom_Packet *group_custom_packet = tox_event_group_custom_packet_alloc(user_data);
if (group_custom_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_custom_private_packet.c vendored
View File

@ -30,19 +30,6 @@ struct Tox_Event_Group_Custom_Private_Packet {
uint32_t data_length;
};
non_null()
static void tox_event_group_custom_private_packet_construct(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet)
{
*group_custom_private_packet = (Tox_Event_Group_Custom_Private_Packet) {
0
};
}
non_null()
static void tox_event_group_custom_private_packet_destruct(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet)
{
free(group_custom_private_packet->data);
}
non_null()
static void tox_event_group_custom_private_packet_set_group_number(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet,
uint32_t group_number)
@ -91,7 +78,7 @@ static bool tox_event_group_custom_private_packet_set_data(Tox_Event_Group_Custo
group_custom_private_packet->data_length = data_length;
return true;
}
size_t tox_event_group_custom_private_packet_get_data_length(const Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet)
uint32_t tox_event_group_custom_private_packet_get_data_length(const Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet)
{
assert(group_custom_private_packet != nullptr);
return group_custom_private_packet->data_length;
@ -103,7 +90,19 @@ const uint8_t *tox_event_group_custom_private_packet_get_data(const Tox_Event_Gr
}
non_null()
static bool tox_event_group_custom_private_packet_pack(
static void tox_event_group_custom_private_packet_construct(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet)
{
*group_custom_private_packet = (Tox_Event_Group_Custom_Private_Packet) {
0
};
}
non_null()
static void tox_event_group_custom_private_packet_destruct(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet, const Memory *mem)
{
free(group_custom_private_packet->data);
}
bool tox_event_group_custom_private_packet_pack(
const Tox_Event_Group_Custom_Private_Packet *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -116,7 +115,7 @@ static bool tox_event_group_custom_private_packet_pack(
}
non_null()
static bool tox_event_group_custom_private_packet_unpack(
static bool tox_event_group_custom_private_packet_unpack_into(
Tox_Event_Group_Custom_Private_Packet *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -132,93 +131,120 @@ static bool tox_event_group_custom_private_packet_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Custom_Private_Packet *tox_events_add_group_custom_private_packet(Tox_Events *events)
const Tox_Event_Group_Custom_Private_Packet *tox_event_get_group_custom_private_packet(const Tox_Event *event)
{
if (events->group_custom_private_packet_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET ? event->data.group_custom_private_packet : nullptr;
}
Tox_Event_Group_Custom_Private_Packet *tox_event_group_custom_private_packet_new(const Memory *mem)
{
Tox_Event_Group_Custom_Private_Packet *const group_custom_private_packet =
(Tox_Event_Group_Custom_Private_Packet *)mem_alloc(mem, sizeof(Tox_Event_Group_Custom_Private_Packet));
if (group_custom_private_packet == nullptr) {
return nullptr;
}
if (events->group_custom_private_packet_size == events->group_custom_private_packet_capacity) {
const uint32_t new_group_custom_private_packet_capacity = events->group_custom_private_packet_capacity * 2 + 1;
Tox_Event_Group_Custom_Private_Packet *new_group_custom_private_packet = (Tox_Event_Group_Custom_Private_Packet *)
realloc(
events->group_custom_private_packet,
new_group_custom_private_packet_capacity * sizeof(Tox_Event_Group_Custom_Private_Packet));
if (new_group_custom_private_packet == nullptr) {
return nullptr;
}
events->group_custom_private_packet = new_group_custom_private_packet;
events->group_custom_private_packet_capacity = new_group_custom_private_packet_capacity;
}
Tox_Event_Group_Custom_Private_Packet *const group_custom_private_packet =
&events->group_custom_private_packet[events->group_custom_private_packet_size];
tox_event_group_custom_private_packet_construct(group_custom_private_packet);
++events->group_custom_private_packet_size;
return group_custom_private_packet;
}
void tox_events_clear_group_custom_private_packet(Tox_Events *events)
void tox_event_group_custom_private_packet_free(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_custom_private_packet != nullptr) {
tox_event_group_custom_private_packet_destruct(group_custom_private_packet, mem);
}
for (uint32_t i = 0; i < events->group_custom_private_packet_size; ++i) {
tox_event_group_custom_private_packet_destruct(&events->group_custom_private_packet[i]);
}
free(events->group_custom_private_packet);
events->group_custom_private_packet = nullptr;
events->group_custom_private_packet_size = 0;
events->group_custom_private_packet_capacity = 0;
mem_delete(mem, group_custom_private_packet);
}
uint32_t tox_events_get_group_custom_private_packet_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Custom_Private_Packet *tox_events_add_group_custom_private_packet(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Custom_Private_Packet *const group_custom_private_packet = tox_event_group_custom_private_packet_new(mem);
if (group_custom_private_packet == nullptr) {
return nullptr;
}
return events->group_custom_private_packet_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET;
event.data.group_custom_private_packet = group_custom_private_packet;
tox_events_add(events, &event);
return group_custom_private_packet;
}
const Tox_Event_Group_Custom_Private_Packet *tox_events_get_group_custom_private_packet(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_custom_private_packet_size);
assert(events->group_custom_private_packet != nullptr);
return &events->group_custom_private_packet[index];
}
bool tox_events_pack_group_custom_private_packet(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_custom_private_packet_size(events);
uint32_t group_custom_private_packet_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_custom_private_packet_pack(tox_events_get_group_custom_private_packet(events, i), bp)) {
return false;
if (group_custom_private_packet_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET) {
const Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet = events->events[i].data.group_custom_private_packet;
if (group_custom_private_packet_index == index) {
return group_custom_private_packet;
}
++group_custom_private_packet_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_custom_private_packet(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_custom_private_packet_size(const Tox_Events *events)
{
Tox_Event_Group_Custom_Private_Packet *event = tox_events_add_group_custom_private_packet(events);
uint32_t group_custom_private_packet_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET) {
++group_custom_private_packet_size;
}
}
return group_custom_private_packet_size;
}
bool tox_event_group_custom_private_packet_unpack(
Tox_Event_Group_Custom_Private_Packet **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_custom_private_packet_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_custom_private_packet_unpack(event, bu);
return tox_event_group_custom_private_packet_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Custom_Private_Packet *tox_event_group_custom_private_packet_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet = tox_events_add_group_custom_private_packet(state->events, state->mem);
if (group_custom_private_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_custom_private_packet;
}
@ -232,17 +258,9 @@ bool tox_events_unpack_group_custom_private_packet(Tox_Events *events, Bin_Unpac
void tox_events_handle_group_custom_private_packet(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *data, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet = tox_events_add_group_custom_private_packet(state->events);
Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet = tox_event_group_custom_private_packet_alloc(user_data);
if (group_custom_private_packet == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

180
external/toxcore/c-toxcore/toxcore/events/group_invite.c vendored
View File

@ -31,20 +31,6 @@ struct Tox_Event_Group_Invite {
uint32_t group_name_length;
};
non_null()
static void tox_event_group_invite_construct(Tox_Event_Group_Invite *group_invite)
{
*group_invite = (Tox_Event_Group_Invite) {
0
};
}
non_null()
static void tox_event_group_invite_destruct(Tox_Event_Group_Invite *group_invite)
{
free(group_invite->invite_data);
free(group_invite->group_name);
}
non_null()
static void tox_event_group_invite_set_friend_number(Tox_Event_Group_Invite *group_invite,
uint32_t friend_number)
@ -80,7 +66,7 @@ static bool tox_event_group_invite_set_invite_data(Tox_Event_Group_Invite *group
group_invite->invite_data_length = invite_data_length;
return true;
}
size_t tox_event_group_invite_get_invite_data_length(const Tox_Event_Group_Invite *group_invite)
uint32_t tox_event_group_invite_get_invite_data_length(const Tox_Event_Group_Invite *group_invite)
{
assert(group_invite != nullptr);
return group_invite->invite_data_length;
@ -113,7 +99,7 @@ static bool tox_event_group_invite_set_group_name(Tox_Event_Group_Invite *group_
group_invite->group_name_length = group_name_length;
return true;
}
size_t tox_event_group_invite_get_group_name_length(const Tox_Event_Group_Invite *group_invite)
uint32_t tox_event_group_invite_get_group_name_length(const Tox_Event_Group_Invite *group_invite)
{
assert(group_invite != nullptr);
return group_invite->group_name_length;
@ -125,7 +111,20 @@ const uint8_t *tox_event_group_invite_get_group_name(const Tox_Event_Group_Invit
}
non_null()
static bool tox_event_group_invite_pack(
static void tox_event_group_invite_construct(Tox_Event_Group_Invite *group_invite)
{
*group_invite = (Tox_Event_Group_Invite) {
0
};
}
non_null()
static void tox_event_group_invite_destruct(Tox_Event_Group_Invite *group_invite, const Memory *mem)
{
free(group_invite->invite_data);
free(group_invite->group_name);
}
bool tox_event_group_invite_pack(
const Tox_Event_Group_Invite *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -138,7 +137,7 @@ static bool tox_event_group_invite_pack(
}
non_null()
static bool tox_event_group_invite_unpack(
static bool tox_event_group_invite_unpack_into(
Tox_Event_Group_Invite *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -154,93 +153,120 @@ static bool tox_event_group_invite_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Invite *tox_events_add_group_invite(Tox_Events *events)
const Tox_Event_Group_Invite *tox_event_get_group_invite(const Tox_Event *event)
{
if (events->group_invite_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_INVITE ? event->data.group_invite : nullptr;
}
Tox_Event_Group_Invite *tox_event_group_invite_new(const Memory *mem)
{
Tox_Event_Group_Invite *const group_invite =
(Tox_Event_Group_Invite *)mem_alloc(mem, sizeof(Tox_Event_Group_Invite));
if (group_invite == nullptr) {
return nullptr;
}
if (events->group_invite_size == events->group_invite_capacity) {
const uint32_t new_group_invite_capacity = events->group_invite_capacity * 2 + 1;
Tox_Event_Group_Invite *new_group_invite = (Tox_Event_Group_Invite *)
realloc(
events->group_invite,
new_group_invite_capacity * sizeof(Tox_Event_Group_Invite));
if (new_group_invite == nullptr) {
return nullptr;
}
events->group_invite = new_group_invite;
events->group_invite_capacity = new_group_invite_capacity;
}
Tox_Event_Group_Invite *const group_invite =
&events->group_invite[events->group_invite_size];
tox_event_group_invite_construct(group_invite);
++events->group_invite_size;
return group_invite;
}
void tox_events_clear_group_invite(Tox_Events *events)
void tox_event_group_invite_free(Tox_Event_Group_Invite *group_invite, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_invite != nullptr) {
tox_event_group_invite_destruct(group_invite, mem);
}
for (uint32_t i = 0; i < events->group_invite_size; ++i) {
tox_event_group_invite_destruct(&events->group_invite[i]);
}
free(events->group_invite);
events->group_invite = nullptr;
events->group_invite_size = 0;
events->group_invite_capacity = 0;
mem_delete(mem, group_invite);
}
uint32_t tox_events_get_group_invite_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Invite *tox_events_add_group_invite(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Invite *const group_invite = tox_event_group_invite_new(mem);
if (group_invite == nullptr) {
return nullptr;
}
return events->group_invite_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_INVITE;
event.data.group_invite = group_invite;
tox_events_add(events, &event);
return group_invite;
}
const Tox_Event_Group_Invite *tox_events_get_group_invite(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_invite_size);
assert(events->group_invite != nullptr);
return &events->group_invite[index];
}
bool tox_events_pack_group_invite(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_invite_size(events);
uint32_t group_invite_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_invite_pack(tox_events_get_group_invite(events, i), bp)) {
return false;
if (group_invite_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_INVITE) {
const Tox_Event_Group_Invite *group_invite = events->events[i].data.group_invite;
if (group_invite_index == index) {
return group_invite;
}
++group_invite_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_invite(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_invite_size(const Tox_Events *events)
{
Tox_Event_Group_Invite *event = tox_events_add_group_invite(events);
uint32_t group_invite_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_INVITE) {
++group_invite_size;
}
}
return group_invite_size;
}
bool tox_event_group_invite_unpack(
Tox_Event_Group_Invite **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_invite_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_invite_unpack(event, bu);
return tox_event_group_invite_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Invite *tox_event_group_invite_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Invite *group_invite = tox_events_add_group_invite(state->events, state->mem);
if (group_invite == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_invite;
}
@ -254,17 +280,9 @@ bool tox_events_unpack_group_invite(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_invite(Tox *tox, uint32_t friend_number, const uint8_t *invite_data, size_t length, const uint8_t *group_name, size_t group_name_length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Invite *group_invite = tox_events_add_group_invite(state->events);
Tox_Event_Group_Invite *group_invite = tox_event_group_invite_alloc(user_data);
if (group_invite == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_join_fail.c vendored
View File

@ -28,19 +28,6 @@ struct Tox_Event_Group_Join_Fail {
Tox_Group_Join_Fail fail_type;
};
non_null()
static void tox_event_group_join_fail_construct(Tox_Event_Group_Join_Fail *group_join_fail)
{
*group_join_fail = (Tox_Event_Group_Join_Fail) {
0
};
}
non_null()
static void tox_event_group_join_fail_destruct(Tox_Event_Group_Join_Fail *group_join_fail)
{
return;
}
non_null()
static void tox_event_group_join_fail_set_group_number(Tox_Event_Group_Join_Fail *group_join_fail,
uint32_t group_number)
@ -68,7 +55,19 @@ Tox_Group_Join_Fail tox_event_group_join_fail_get_fail_type(const Tox_Event_Grou
}
non_null()
static bool tox_event_group_join_fail_pack(
static void tox_event_group_join_fail_construct(Tox_Event_Group_Join_Fail *group_join_fail)
{
*group_join_fail = (Tox_Event_Group_Join_Fail) {
0
};
}
non_null()
static void tox_event_group_join_fail_destruct(Tox_Event_Group_Join_Fail *group_join_fail, const Memory *mem)
{
return;
}
bool tox_event_group_join_fail_pack(
const Tox_Event_Group_Join_Fail *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -80,7 +79,7 @@ static bool tox_event_group_join_fail_pack(
}
non_null()
static bool tox_event_group_join_fail_unpack(
static bool tox_event_group_join_fail_unpack_into(
Tox_Event_Group_Join_Fail *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -89,99 +88,126 @@ static bool tox_event_group_join_fail_unpack(
}
return bin_unpack_u32(bu, &event->group_number)
&& tox_unpack_group_join_fail(bu, &event->fail_type);
&& tox_group_join_fail_unpack(bu, &event->fail_type);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Join_Fail *tox_events_add_group_join_fail(Tox_Events *events)
const Tox_Event_Group_Join_Fail *tox_event_get_group_join_fail(const Tox_Event *event)
{
if (events->group_join_fail_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_JOIN_FAIL ? event->data.group_join_fail : nullptr;
}
Tox_Event_Group_Join_Fail *tox_event_group_join_fail_new(const Memory *mem)
{
Tox_Event_Group_Join_Fail *const group_join_fail =
(Tox_Event_Group_Join_Fail *)mem_alloc(mem, sizeof(Tox_Event_Group_Join_Fail));
if (group_join_fail == nullptr) {
return nullptr;
}
if (events->group_join_fail_size == events->group_join_fail_capacity) {
const uint32_t new_group_join_fail_capacity = events->group_join_fail_capacity * 2 + 1;
Tox_Event_Group_Join_Fail *new_group_join_fail = (Tox_Event_Group_Join_Fail *)
realloc(
events->group_join_fail,
new_group_join_fail_capacity * sizeof(Tox_Event_Group_Join_Fail));
if (new_group_join_fail == nullptr) {
return nullptr;
}
events->group_join_fail = new_group_join_fail;
events->group_join_fail_capacity = new_group_join_fail_capacity;
}
Tox_Event_Group_Join_Fail *const group_join_fail =
&events->group_join_fail[events->group_join_fail_size];
tox_event_group_join_fail_construct(group_join_fail);
++events->group_join_fail_size;
return group_join_fail;
}
void tox_events_clear_group_join_fail(Tox_Events *events)
void tox_event_group_join_fail_free(Tox_Event_Group_Join_Fail *group_join_fail, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_join_fail != nullptr) {
tox_event_group_join_fail_destruct(group_join_fail, mem);
}
for (uint32_t i = 0; i < events->group_join_fail_size; ++i) {
tox_event_group_join_fail_destruct(&events->group_join_fail[i]);
}
free(events->group_join_fail);
events->group_join_fail = nullptr;
events->group_join_fail_size = 0;
events->group_join_fail_capacity = 0;
mem_delete(mem, group_join_fail);
}
uint32_t tox_events_get_group_join_fail_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Join_Fail *tox_events_add_group_join_fail(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Join_Fail *const group_join_fail = tox_event_group_join_fail_new(mem);
if (group_join_fail == nullptr) {
return nullptr;
}
return events->group_join_fail_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_JOIN_FAIL;
event.data.group_join_fail = group_join_fail;
tox_events_add(events, &event);
return group_join_fail;
}
const Tox_Event_Group_Join_Fail *tox_events_get_group_join_fail(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_join_fail_size);
assert(events->group_join_fail != nullptr);
return &events->group_join_fail[index];
}
bool tox_events_pack_group_join_fail(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_join_fail_size(events);
uint32_t group_join_fail_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_join_fail_pack(tox_events_get_group_join_fail(events, i), bp)) {
return false;
if (group_join_fail_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_JOIN_FAIL) {
const Tox_Event_Group_Join_Fail *group_join_fail = events->events[i].data.group_join_fail;
if (group_join_fail_index == index) {
return group_join_fail;
}
++group_join_fail_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_join_fail(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_join_fail_size(const Tox_Events *events)
{
Tox_Event_Group_Join_Fail *event = tox_events_add_group_join_fail(events);
uint32_t group_join_fail_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_JOIN_FAIL) {
++group_join_fail_size;
}
}
return group_join_fail_size;
}
bool tox_event_group_join_fail_unpack(
Tox_Event_Group_Join_Fail **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_join_fail_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_join_fail_unpack(event, bu);
return tox_event_group_join_fail_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Join_Fail *tox_event_group_join_fail_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Join_Fail *group_join_fail = tox_events_add_group_join_fail(state->events, state->mem);
if (group_join_fail == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_join_fail;
}
@ -195,17 +221,9 @@ bool tox_events_unpack_group_join_fail(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_join_fail(Tox *tox, uint32_t group_number, Tox_Group_Join_Fail fail_type,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Join_Fail *group_join_fail = tox_events_add_group_join_fail(state->events);
Tox_Event_Group_Join_Fail *group_join_fail = tox_event_group_join_fail_alloc(user_data);
if (group_join_fail == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

178
external/toxcore/c-toxcore/toxcore/events/group_message.c vendored
View File

@ -32,19 +32,6 @@ struct Tox_Event_Group_Message {
uint32_t message_id;
};
non_null()
static void tox_event_group_message_construct(Tox_Event_Group_Message *group_message)
{
*group_message = (Tox_Event_Group_Message) {
0
};
}
non_null()
static void tox_event_group_message_destruct(Tox_Event_Group_Message *group_message)
{
free(group_message->message);
}
non_null()
static void tox_event_group_message_set_group_number(Tox_Event_Group_Message *group_message,
uint32_t group_number)
@ -106,7 +93,7 @@ static bool tox_event_group_message_set_message(Tox_Event_Group_Message *group_m
group_message->message_length = message_length;
return true;
}
size_t tox_event_group_message_get_message_length(const Tox_Event_Group_Message *group_message)
uint32_t tox_event_group_message_get_message_length(const Tox_Event_Group_Message *group_message)
{
assert(group_message != nullptr);
return group_message->message_length;
@ -131,7 +118,19 @@ uint32_t tox_event_group_message_get_message_id(const Tox_Event_Group_Message *g
}
non_null()
static bool tox_event_group_message_pack(
static void tox_event_group_message_construct(Tox_Event_Group_Message *group_message)
{
*group_message = (Tox_Event_Group_Message) {
0
};
}
non_null()
static void tox_event_group_message_destruct(Tox_Event_Group_Message *group_message, const Memory *mem)
{
free(group_message->message);
}
bool tox_event_group_message_pack(
const Tox_Event_Group_Message *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -146,7 +145,7 @@ static bool tox_event_group_message_pack(
}
non_null()
static bool tox_event_group_message_unpack(
static bool tox_event_group_message_unpack_into(
Tox_Event_Group_Message *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -156,7 +155,7 @@ static bool tox_event_group_message_unpack(
return bin_unpack_u32(bu, &event->group_number)
&& bin_unpack_u32(bu, &event->peer_id)
&& tox_unpack_message_type(bu, &event->type)
&& tox_message_type_unpack(bu, &event->type)
&& bin_unpack_bin(bu, &event->message, &event->message_length)
&& bin_unpack_u32(bu, &event->message_id);
}
@ -164,93 +163,120 @@ static bool tox_event_group_message_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Message *tox_events_add_group_message(Tox_Events *events)
const Tox_Event_Group_Message *tox_event_get_group_message(const Tox_Event *event)
{
if (events->group_message_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_MESSAGE ? event->data.group_message : nullptr;
}
Tox_Event_Group_Message *tox_event_group_message_new(const Memory *mem)
{
Tox_Event_Group_Message *const group_message =
(Tox_Event_Group_Message *)mem_alloc(mem, sizeof(Tox_Event_Group_Message));
if (group_message == nullptr) {
return nullptr;
}
if (events->group_message_size == events->group_message_capacity) {
const uint32_t new_group_message_capacity = events->group_message_capacity * 2 + 1;
Tox_Event_Group_Message *new_group_message = (Tox_Event_Group_Message *)
realloc(
events->group_message,
new_group_message_capacity * sizeof(Tox_Event_Group_Message));
if (new_group_message == nullptr) {
return nullptr;
}
events->group_message = new_group_message;
events->group_message_capacity = new_group_message_capacity;
}
Tox_Event_Group_Message *const group_message =
&events->group_message[events->group_message_size];
tox_event_group_message_construct(group_message);
++events->group_message_size;
return group_message;
}
void tox_events_clear_group_message(Tox_Events *events)
void tox_event_group_message_free(Tox_Event_Group_Message *group_message, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_message != nullptr) {
tox_event_group_message_destruct(group_message, mem);
}
for (uint32_t i = 0; i < events->group_message_size; ++i) {
tox_event_group_message_destruct(&events->group_message[i]);
}
free(events->group_message);
events->group_message = nullptr;
events->group_message_size = 0;
events->group_message_capacity = 0;
mem_delete(mem, group_message);
}
uint32_t tox_events_get_group_message_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Message *tox_events_add_group_message(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Message *const group_message = tox_event_group_message_new(mem);
if (group_message == nullptr) {
return nullptr;
}
return events->group_message_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_MESSAGE;
event.data.group_message = group_message;
tox_events_add(events, &event);
return group_message;
}
const Tox_Event_Group_Message *tox_events_get_group_message(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_message_size);
assert(events->group_message != nullptr);
return &events->group_message[index];
}
bool tox_events_pack_group_message(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_message_size(events);
uint32_t group_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_message_pack(tox_events_get_group_message(events, i), bp)) {
return false;
if (group_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_MESSAGE) {
const Tox_Event_Group_Message *group_message = events->events[i].data.group_message;
if (group_message_index == index) {
return group_message;
}
++group_message_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_message(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_message_size(const Tox_Events *events)
{
Tox_Event_Group_Message *event = tox_events_add_group_message(events);
uint32_t group_message_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_MESSAGE) {
++group_message_size;
}
}
return group_message_size;
}
bool tox_event_group_message_unpack(
Tox_Event_Group_Message **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_message_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_message_unpack(event, bu);
return tox_event_group_message_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Message *tox_event_group_message_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Message *group_message = tox_events_add_group_message(state->events, state->mem);
if (group_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_message;
}
@ -264,17 +290,9 @@ bool tox_events_unpack_group_message(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_message(Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, const uint8_t *message, size_t length, uint32_t message_id,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Message *group_message = tox_events_add_group_message(state->events);
Tox_Event_Group_Message *group_message = tox_event_group_message_alloc(user_data);
if (group_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_moderation.c vendored
View File

@ -30,19 +30,6 @@ struct Tox_Event_Group_Moderation {
Tox_Group_Mod_Event mod_type;
};
non_null()
static void tox_event_group_moderation_construct(Tox_Event_Group_Moderation *group_moderation)
{
*group_moderation = (Tox_Event_Group_Moderation) {
0
};
}
non_null()
static void tox_event_group_moderation_destruct(Tox_Event_Group_Moderation *group_moderation)
{
return;
}
non_null()
static void tox_event_group_moderation_set_group_number(Tox_Event_Group_Moderation *group_moderation,
uint32_t group_number)
@ -96,7 +83,19 @@ Tox_Group_Mod_Event tox_event_group_moderation_get_mod_type(const Tox_Event_Grou
}
non_null()
static bool tox_event_group_moderation_pack(
static void tox_event_group_moderation_construct(Tox_Event_Group_Moderation *group_moderation)
{
*group_moderation = (Tox_Event_Group_Moderation) {
0
};
}
non_null()
static void tox_event_group_moderation_destruct(Tox_Event_Group_Moderation *group_moderation, const Memory *mem)
{
return;
}
bool tox_event_group_moderation_pack(
const Tox_Event_Group_Moderation *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -110,7 +109,7 @@ static bool tox_event_group_moderation_pack(
}
non_null()
static bool tox_event_group_moderation_unpack(
static bool tox_event_group_moderation_unpack_into(
Tox_Event_Group_Moderation *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -121,99 +120,126 @@ static bool tox_event_group_moderation_unpack(
return bin_unpack_u32(bu, &event->group_number)
&& bin_unpack_u32(bu, &event->source_peer_id)
&& bin_unpack_u32(bu, &event->target_peer_id)
&& tox_unpack_group_mod_event(bu, &event->mod_type);
&& tox_group_mod_event_unpack(bu, &event->mod_type);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Moderation *tox_events_add_group_moderation(Tox_Events *events)
const Tox_Event_Group_Moderation *tox_event_get_group_moderation(const Tox_Event *event)
{
if (events->group_moderation_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_MODERATION ? event->data.group_moderation : nullptr;
}
Tox_Event_Group_Moderation *tox_event_group_moderation_new(const Memory *mem)
{
Tox_Event_Group_Moderation *const group_moderation =
(Tox_Event_Group_Moderation *)mem_alloc(mem, sizeof(Tox_Event_Group_Moderation));
if (group_moderation == nullptr) {
return nullptr;
}
if (events->group_moderation_size == events->group_moderation_capacity) {
const uint32_t new_group_moderation_capacity = events->group_moderation_capacity * 2 + 1;
Tox_Event_Group_Moderation *new_group_moderation = (Tox_Event_Group_Moderation *)
realloc(
events->group_moderation,
new_group_moderation_capacity * sizeof(Tox_Event_Group_Moderation));
if (new_group_moderation == nullptr) {
return nullptr;
}
events->group_moderation = new_group_moderation;
events->group_moderation_capacity = new_group_moderation_capacity;
}
Tox_Event_Group_Moderation *const group_moderation =
&events->group_moderation[events->group_moderation_size];
tox_event_group_moderation_construct(group_moderation);
++events->group_moderation_size;
return group_moderation;
}
void tox_events_clear_group_moderation(Tox_Events *events)
void tox_event_group_moderation_free(Tox_Event_Group_Moderation *group_moderation, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_moderation != nullptr) {
tox_event_group_moderation_destruct(group_moderation, mem);
}
for (uint32_t i = 0; i < events->group_moderation_size; ++i) {
tox_event_group_moderation_destruct(&events->group_moderation[i]);
}
free(events->group_moderation);
events->group_moderation = nullptr;
events->group_moderation_size = 0;
events->group_moderation_capacity = 0;
mem_delete(mem, group_moderation);
}
uint32_t tox_events_get_group_moderation_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Moderation *tox_events_add_group_moderation(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Moderation *const group_moderation = tox_event_group_moderation_new(mem);
if (group_moderation == nullptr) {
return nullptr;
}
return events->group_moderation_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_MODERATION;
event.data.group_moderation = group_moderation;
tox_events_add(events, &event);
return group_moderation;
}
const Tox_Event_Group_Moderation *tox_events_get_group_moderation(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_moderation_size);
assert(events->group_moderation != nullptr);
return &events->group_moderation[index];
}
bool tox_events_pack_group_moderation(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_moderation_size(events);
uint32_t group_moderation_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_moderation_pack(tox_events_get_group_moderation(events, i), bp)) {
return false;
if (group_moderation_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_MODERATION) {
const Tox_Event_Group_Moderation *group_moderation = events->events[i].data.group_moderation;
if (group_moderation_index == index) {
return group_moderation;
}
++group_moderation_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_moderation(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_moderation_size(const Tox_Events *events)
{
Tox_Event_Group_Moderation *event = tox_events_add_group_moderation(events);
uint32_t group_moderation_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_MODERATION) {
++group_moderation_size;
}
}
return group_moderation_size;
}
bool tox_event_group_moderation_unpack(
Tox_Event_Group_Moderation **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_moderation_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_moderation_unpack(event, bu);
return tox_event_group_moderation_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Moderation *tox_event_group_moderation_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Moderation *group_moderation = tox_events_add_group_moderation(state->events, state->mem);
if (group_moderation == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_moderation;
}
@ -227,17 +253,9 @@ bool tox_events_unpack_group_moderation(Tox_Events *events, Bin_Unpack *bu)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Moderation *group_moderation = tox_events_add_group_moderation(state->events);
Tox_Event_Group_Moderation *group_moderation = tox_event_group_moderation_alloc(user_data);
if (group_moderation == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_password.c vendored
View File

@ -29,19 +29,6 @@ struct Tox_Event_Group_Password {
uint32_t password_length;
};
non_null()
static void tox_event_group_password_construct(Tox_Event_Group_Password *group_password)
{
*group_password = (Tox_Event_Group_Password) {
0
};
}
non_null()
static void tox_event_group_password_destruct(Tox_Event_Group_Password *group_password)
{
free(group_password->password);
}
non_null()
static void tox_event_group_password_set_group_number(Tox_Event_Group_Password *group_password,
uint32_t group_number)
@ -77,7 +64,7 @@ static bool tox_event_group_password_set_password(Tox_Event_Group_Password *grou
group_password->password_length = password_length;
return true;
}
size_t tox_event_group_password_get_password_length(const Tox_Event_Group_Password *group_password)
uint32_t tox_event_group_password_get_password_length(const Tox_Event_Group_Password *group_password)
{
assert(group_password != nullptr);
return group_password->password_length;
@ -89,7 +76,19 @@ const uint8_t *tox_event_group_password_get_password(const Tox_Event_Group_Passw
}
non_null()
static bool tox_event_group_password_pack(
static void tox_event_group_password_construct(Tox_Event_Group_Password *group_password)
{
*group_password = (Tox_Event_Group_Password) {
0
};
}
non_null()
static void tox_event_group_password_destruct(Tox_Event_Group_Password *group_password, const Memory *mem)
{
free(group_password->password);
}
bool tox_event_group_password_pack(
const Tox_Event_Group_Password *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -101,7 +100,7 @@ static bool tox_event_group_password_pack(
}
non_null()
static bool tox_event_group_password_unpack(
static bool tox_event_group_password_unpack_into(
Tox_Event_Group_Password *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -116,93 +115,120 @@ static bool tox_event_group_password_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Password *tox_events_add_group_password(Tox_Events *events)
const Tox_Event_Group_Password *tox_event_get_group_password(const Tox_Event *event)
{
if (events->group_password_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PASSWORD ? event->data.group_password : nullptr;
}
Tox_Event_Group_Password *tox_event_group_password_new(const Memory *mem)
{
Tox_Event_Group_Password *const group_password =
(Tox_Event_Group_Password *)mem_alloc(mem, sizeof(Tox_Event_Group_Password));
if (group_password == nullptr) {
return nullptr;
}
if (events->group_password_size == events->group_password_capacity) {
const uint32_t new_group_password_capacity = events->group_password_capacity * 2 + 1;
Tox_Event_Group_Password *new_group_password = (Tox_Event_Group_Password *)
realloc(
events->group_password,
new_group_password_capacity * sizeof(Tox_Event_Group_Password));
if (new_group_password == nullptr) {
return nullptr;
}
events->group_password = new_group_password;
events->group_password_capacity = new_group_password_capacity;
}
Tox_Event_Group_Password *const group_password =
&events->group_password[events->group_password_size];
tox_event_group_password_construct(group_password);
++events->group_password_size;
return group_password;
}
void tox_events_clear_group_password(Tox_Events *events)
void tox_event_group_password_free(Tox_Event_Group_Password *group_password, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_password != nullptr) {
tox_event_group_password_destruct(group_password, mem);
}
for (uint32_t i = 0; i < events->group_password_size; ++i) {
tox_event_group_password_destruct(&events->group_password[i]);
}
free(events->group_password);
events->group_password = nullptr;
events->group_password_size = 0;
events->group_password_capacity = 0;
mem_delete(mem, group_password);
}
uint32_t tox_events_get_group_password_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Password *tox_events_add_group_password(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Password *const group_password = tox_event_group_password_new(mem);
if (group_password == nullptr) {
return nullptr;
}
return events->group_password_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PASSWORD;
event.data.group_password = group_password;
tox_events_add(events, &event);
return group_password;
}
const Tox_Event_Group_Password *tox_events_get_group_password(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_password_size);
assert(events->group_password != nullptr);
return &events->group_password[index];
}
bool tox_events_pack_group_password(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_password_size(events);
uint32_t group_password_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_password_pack(tox_events_get_group_password(events, i), bp)) {
return false;
if (group_password_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PASSWORD) {
const Tox_Event_Group_Password *group_password = events->events[i].data.group_password;
if (group_password_index == index) {
return group_password;
}
++group_password_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_password(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_password_size(const Tox_Events *events)
{
Tox_Event_Group_Password *event = tox_events_add_group_password(events);
uint32_t group_password_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PASSWORD) {
++group_password_size;
}
}
return group_password_size;
}
bool tox_event_group_password_unpack(
Tox_Event_Group_Password **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_password_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_password_unpack(event, bu);
return tox_event_group_password_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Password *tox_event_group_password_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Password *group_password = tox_events_add_group_password(state->events, state->mem);
if (group_password == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_password;
}
@ -216,17 +242,9 @@ bool tox_events_unpack_group_password(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_password(Tox *tox, uint32_t group_number, const uint8_t *password, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Password *group_password = tox_events_add_group_password(state->events);
Tox_Event_Group_Password *group_password = tox_event_group_password_alloc(user_data);
if (group_password == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

182
external/toxcore/c-toxcore/toxcore/events/group_peer_exit.c vendored
View File

@ -33,20 +33,6 @@ struct Tox_Event_Group_Peer_Exit {
uint32_t part_message_length;
};
non_null()
static void tox_event_group_peer_exit_construct(Tox_Event_Group_Peer_Exit *group_peer_exit)
{
*group_peer_exit = (Tox_Event_Group_Peer_Exit) {
0
};
}
non_null()
static void tox_event_group_peer_exit_destruct(Tox_Event_Group_Peer_Exit *group_peer_exit)
{
free(group_peer_exit->name);
free(group_peer_exit->part_message);
}
non_null()
static void tox_event_group_peer_exit_set_group_number(Tox_Event_Group_Peer_Exit *group_peer_exit,
uint32_t group_number)
@ -108,7 +94,7 @@ static bool tox_event_group_peer_exit_set_name(Tox_Event_Group_Peer_Exit *group_
group_peer_exit->name_length = name_length;
return true;
}
size_t tox_event_group_peer_exit_get_name_length(const Tox_Event_Group_Peer_Exit *group_peer_exit)
uint32_t tox_event_group_peer_exit_get_name_length(const Tox_Event_Group_Peer_Exit *group_peer_exit)
{
assert(group_peer_exit != nullptr);
return group_peer_exit->name_length;
@ -141,7 +127,7 @@ static bool tox_event_group_peer_exit_set_part_message(Tox_Event_Group_Peer_Exit
group_peer_exit->part_message_length = part_message_length;
return true;
}
size_t tox_event_group_peer_exit_get_part_message_length(const Tox_Event_Group_Peer_Exit *group_peer_exit)
uint32_t tox_event_group_peer_exit_get_part_message_length(const Tox_Event_Group_Peer_Exit *group_peer_exit)
{
assert(group_peer_exit != nullptr);
return group_peer_exit->part_message_length;
@ -153,7 +139,20 @@ const uint8_t *tox_event_group_peer_exit_get_part_message(const Tox_Event_Group_
}
non_null()
static bool tox_event_group_peer_exit_pack(
static void tox_event_group_peer_exit_construct(Tox_Event_Group_Peer_Exit *group_peer_exit)
{
*group_peer_exit = (Tox_Event_Group_Peer_Exit) {
0
};
}
non_null()
static void tox_event_group_peer_exit_destruct(Tox_Event_Group_Peer_Exit *group_peer_exit, const Memory *mem)
{
free(group_peer_exit->name);
free(group_peer_exit->part_message);
}
bool tox_event_group_peer_exit_pack(
const Tox_Event_Group_Peer_Exit *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -168,7 +167,7 @@ static bool tox_event_group_peer_exit_pack(
}
non_null()
static bool tox_event_group_peer_exit_unpack(
static bool tox_event_group_peer_exit_unpack_into(
Tox_Event_Group_Peer_Exit *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -178,7 +177,7 @@ static bool tox_event_group_peer_exit_unpack(
return bin_unpack_u32(bu, &event->group_number)
&& bin_unpack_u32(bu, &event->peer_id)
&& tox_unpack_group_exit_type(bu, &event->exit_type)
&& tox_group_exit_type_unpack(bu, &event->exit_type)
&& bin_unpack_bin(bu, &event->name, &event->name_length)
&& bin_unpack_bin(bu, &event->part_message, &event->part_message_length);
}
@ -186,93 +185,120 @@ static bool tox_event_group_peer_exit_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Peer_Exit *tox_events_add_group_peer_exit(Tox_Events *events)
const Tox_Event_Group_Peer_Exit *tox_event_get_group_peer_exit(const Tox_Event *event)
{
if (events->group_peer_exit_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PEER_EXIT ? event->data.group_peer_exit : nullptr;
}
Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_new(const Memory *mem)
{
Tox_Event_Group_Peer_Exit *const group_peer_exit =
(Tox_Event_Group_Peer_Exit *)mem_alloc(mem, sizeof(Tox_Event_Group_Peer_Exit));
if (group_peer_exit == nullptr) {
return nullptr;
}
if (events->group_peer_exit_size == events->group_peer_exit_capacity) {
const uint32_t new_group_peer_exit_capacity = events->group_peer_exit_capacity * 2 + 1;
Tox_Event_Group_Peer_Exit *new_group_peer_exit = (Tox_Event_Group_Peer_Exit *)
realloc(
events->group_peer_exit,
new_group_peer_exit_capacity * sizeof(Tox_Event_Group_Peer_Exit));
if (new_group_peer_exit == nullptr) {
return nullptr;
}
events->group_peer_exit = new_group_peer_exit;
events->group_peer_exit_capacity = new_group_peer_exit_capacity;
}
Tox_Event_Group_Peer_Exit *const group_peer_exit =
&events->group_peer_exit[events->group_peer_exit_size];
tox_event_group_peer_exit_construct(group_peer_exit);
++events->group_peer_exit_size;
return group_peer_exit;
}
void tox_events_clear_group_peer_exit(Tox_Events *events)
void tox_event_group_peer_exit_free(Tox_Event_Group_Peer_Exit *group_peer_exit, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_peer_exit != nullptr) {
tox_event_group_peer_exit_destruct(group_peer_exit, mem);
}
for (uint32_t i = 0; i < events->group_peer_exit_size; ++i) {
tox_event_group_peer_exit_destruct(&events->group_peer_exit[i]);
}
free(events->group_peer_exit);
events->group_peer_exit = nullptr;
events->group_peer_exit_size = 0;
events->group_peer_exit_capacity = 0;
mem_delete(mem, group_peer_exit);
}
uint32_t tox_events_get_group_peer_exit_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Peer_Exit *tox_events_add_group_peer_exit(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Peer_Exit *const group_peer_exit = tox_event_group_peer_exit_new(mem);
if (group_peer_exit == nullptr) {
return nullptr;
}
return events->group_peer_exit_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PEER_EXIT;
event.data.group_peer_exit = group_peer_exit;
tox_events_add(events, &event);
return group_peer_exit;
}
const Tox_Event_Group_Peer_Exit *tox_events_get_group_peer_exit(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_peer_exit_size);
assert(events->group_peer_exit != nullptr);
return &events->group_peer_exit[index];
}
bool tox_events_pack_group_peer_exit(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_peer_exit_size(events);
uint32_t group_peer_exit_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_peer_exit_pack(tox_events_get_group_peer_exit(events, i), bp)) {
return false;
if (group_peer_exit_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_EXIT) {
const Tox_Event_Group_Peer_Exit *group_peer_exit = events->events[i].data.group_peer_exit;
if (group_peer_exit_index == index) {
return group_peer_exit;
}
++group_peer_exit_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_peer_exit(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_peer_exit_size(const Tox_Events *events)
{
Tox_Event_Group_Peer_Exit *event = tox_events_add_group_peer_exit(events);
uint32_t group_peer_exit_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_EXIT) {
++group_peer_exit_size;
}
}
return group_peer_exit_size;
}
bool tox_event_group_peer_exit_unpack(
Tox_Event_Group_Peer_Exit **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_peer_exit_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_peer_exit_unpack(event, bu);
return tox_event_group_peer_exit_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Peer_Exit *group_peer_exit = tox_events_add_group_peer_exit(state->events, state->mem);
if (group_peer_exit == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_peer_exit;
}
@ -286,17 +312,9 @@ bool tox_events_unpack_group_peer_exit(Tox_Events *events, Bin_Unpack *bu)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Peer_Exit *group_peer_exit = tox_events_add_group_peer_exit(state->events);
Tox_Event_Group_Peer_Exit *group_peer_exit = tox_event_group_peer_exit_alloc(user_data);
if (group_peer_exit == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

174
external/toxcore/c-toxcore/toxcore/events/group_peer_join.c vendored
View File

@ -28,19 +28,6 @@ struct Tox_Event_Group_Peer_Join {
uint32_t peer_id;
};
non_null()
static void tox_event_group_peer_join_construct(Tox_Event_Group_Peer_Join *group_peer_join)
{
*group_peer_join = (Tox_Event_Group_Peer_Join) {
0
};
}
non_null()
static void tox_event_group_peer_join_destruct(Tox_Event_Group_Peer_Join *group_peer_join)
{
return;
}
non_null()
static void tox_event_group_peer_join_set_group_number(Tox_Event_Group_Peer_Join *group_peer_join,
uint32_t group_number)
@ -68,7 +55,19 @@ uint32_t tox_event_group_peer_join_get_peer_id(const Tox_Event_Group_Peer_Join *
}
non_null()
static bool tox_event_group_peer_join_pack(
static void tox_event_group_peer_join_construct(Tox_Event_Group_Peer_Join *group_peer_join)
{
*group_peer_join = (Tox_Event_Group_Peer_Join) {
0
};
}
non_null()
static void tox_event_group_peer_join_destruct(Tox_Event_Group_Peer_Join *group_peer_join, const Memory *mem)
{
return;
}
bool tox_event_group_peer_join_pack(
const Tox_Event_Group_Peer_Join *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -80,7 +79,7 @@ static bool tox_event_group_peer_join_pack(
}
non_null()
static bool tox_event_group_peer_join_unpack(
static bool tox_event_group_peer_join_unpack_into(
Tox_Event_Group_Peer_Join *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -95,93 +94,120 @@ static bool tox_event_group_peer_join_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Peer_Join *tox_events_add_group_peer_join(Tox_Events *events)
const Tox_Event_Group_Peer_Join *tox_event_get_group_peer_join(const Tox_Event *event)
{
if (events->group_peer_join_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PEER_JOIN ? event->data.group_peer_join : nullptr;
}
Tox_Event_Group_Peer_Join *tox_event_group_peer_join_new(const Memory *mem)
{
Tox_Event_Group_Peer_Join *const group_peer_join =
(Tox_Event_Group_Peer_Join *)mem_alloc(mem, sizeof(Tox_Event_Group_Peer_Join));
if (group_peer_join == nullptr) {
return nullptr;
}
if (events->group_peer_join_size == events->group_peer_join_capacity) {
const uint32_t new_group_peer_join_capacity = events->group_peer_join_capacity * 2 + 1;
Tox_Event_Group_Peer_Join *new_group_peer_join = (Tox_Event_Group_Peer_Join *)
realloc(
events->group_peer_join,
new_group_peer_join_capacity * sizeof(Tox_Event_Group_Peer_Join));
if (new_group_peer_join == nullptr) {
return nullptr;
}
events->group_peer_join = new_group_peer_join;
events->group_peer_join_capacity = new_group_peer_join_capacity;
}
Tox_Event_Group_Peer_Join *const group_peer_join =
&events->group_peer_join[events->group_peer_join_size];
tox_event_group_peer_join_construct(group_peer_join);
++events->group_peer_join_size;
return group_peer_join;
}
void tox_events_clear_group_peer_join(Tox_Events *events)
void tox_event_group_peer_join_free(Tox_Event_Group_Peer_Join *group_peer_join, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_peer_join != nullptr) {
tox_event_group_peer_join_destruct(group_peer_join, mem);
}
for (uint32_t i = 0; i < events->group_peer_join_size; ++i) {
tox_event_group_peer_join_destruct(&events->group_peer_join[i]);
}
free(events->group_peer_join);
events->group_peer_join = nullptr;
events->group_peer_join_size = 0;
events->group_peer_join_capacity = 0;
mem_delete(mem, group_peer_join);
}
uint32_t tox_events_get_group_peer_join_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Peer_Join *tox_events_add_group_peer_join(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Peer_Join *const group_peer_join = tox_event_group_peer_join_new(mem);
if (group_peer_join == nullptr) {
return nullptr;
}
return events->group_peer_join_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PEER_JOIN;
event.data.group_peer_join = group_peer_join;
tox_events_add(events, &event);
return group_peer_join;
}
const Tox_Event_Group_Peer_Join *tox_events_get_group_peer_join(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_peer_join_size);
assert(events->group_peer_join != nullptr);
return &events->group_peer_join[index];
}
bool tox_events_pack_group_peer_join(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_peer_join_size(events);
uint32_t group_peer_join_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_peer_join_pack(tox_events_get_group_peer_join(events, i), bp)) {
return false;
if (group_peer_join_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_JOIN) {
const Tox_Event_Group_Peer_Join *group_peer_join = events->events[i].data.group_peer_join;
if (group_peer_join_index == index) {
return group_peer_join;
}
++group_peer_join_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_peer_join(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_peer_join_size(const Tox_Events *events)
{
Tox_Event_Group_Peer_Join *event = tox_events_add_group_peer_join(events);
uint32_t group_peer_join_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_JOIN) {
++group_peer_join_size;
}
}
return group_peer_join_size;
}
bool tox_event_group_peer_join_unpack(
Tox_Event_Group_Peer_Join **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_peer_join_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_peer_join_unpack(event, bu);
return tox_event_group_peer_join_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Peer_Join *tox_event_group_peer_join_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Peer_Join *group_peer_join = tox_events_add_group_peer_join(state->events, state->mem);
if (group_peer_join == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_peer_join;
}
@ -195,17 +221,9 @@ bool tox_events_unpack_group_peer_join(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_peer_join(Tox *tox, uint32_t group_number, uint32_t peer_id,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Peer_Join *group_peer_join = tox_events_add_group_peer_join(state->events);
Tox_Event_Group_Peer_Join *group_peer_join = tox_event_group_peer_join_alloc(user_data);
if (group_peer_join == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

174
external/toxcore/c-toxcore/toxcore/events/group_peer_limit.c vendored
View File

@ -28,19 +28,6 @@ struct Tox_Event_Group_Peer_Limit {
uint32_t peer_limit;
};
non_null()
static void tox_event_group_peer_limit_construct(Tox_Event_Group_Peer_Limit *group_peer_limit)
{
*group_peer_limit = (Tox_Event_Group_Peer_Limit) {
0
};
}
non_null()
static void tox_event_group_peer_limit_destruct(Tox_Event_Group_Peer_Limit *group_peer_limit)
{
return;
}
non_null()
static void tox_event_group_peer_limit_set_group_number(Tox_Event_Group_Peer_Limit *group_peer_limit,
uint32_t group_number)
@ -68,7 +55,19 @@ uint32_t tox_event_group_peer_limit_get_peer_limit(const Tox_Event_Group_Peer_Li
}
non_null()
static bool tox_event_group_peer_limit_pack(
static void tox_event_group_peer_limit_construct(Tox_Event_Group_Peer_Limit *group_peer_limit)
{
*group_peer_limit = (Tox_Event_Group_Peer_Limit) {
0
};
}
non_null()
static void tox_event_group_peer_limit_destruct(Tox_Event_Group_Peer_Limit *group_peer_limit, const Memory *mem)
{
return;
}
bool tox_event_group_peer_limit_pack(
const Tox_Event_Group_Peer_Limit *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -80,7 +79,7 @@ static bool tox_event_group_peer_limit_pack(
}
non_null()
static bool tox_event_group_peer_limit_unpack(
static bool tox_event_group_peer_limit_unpack_into(
Tox_Event_Group_Peer_Limit *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -95,93 +94,120 @@ static bool tox_event_group_peer_limit_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Peer_Limit *tox_events_add_group_peer_limit(Tox_Events *events)
const Tox_Event_Group_Peer_Limit *tox_event_get_group_peer_limit(const Tox_Event *event)
{
if (events->group_peer_limit_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PEER_LIMIT ? event->data.group_peer_limit : nullptr;
}
Tox_Event_Group_Peer_Limit *tox_event_group_peer_limit_new(const Memory *mem)
{
Tox_Event_Group_Peer_Limit *const group_peer_limit =
(Tox_Event_Group_Peer_Limit *)mem_alloc(mem, sizeof(Tox_Event_Group_Peer_Limit));
if (group_peer_limit == nullptr) {
return nullptr;
}
if (events->group_peer_limit_size == events->group_peer_limit_capacity) {
const uint32_t new_group_peer_limit_capacity = events->group_peer_limit_capacity * 2 + 1;
Tox_Event_Group_Peer_Limit *new_group_peer_limit = (Tox_Event_Group_Peer_Limit *)
realloc(
events->group_peer_limit,
new_group_peer_limit_capacity * sizeof(Tox_Event_Group_Peer_Limit));
if (new_group_peer_limit == nullptr) {
return nullptr;
}
events->group_peer_limit = new_group_peer_limit;
events->group_peer_limit_capacity = new_group_peer_limit_capacity;
}
Tox_Event_Group_Peer_Limit *const group_peer_limit =
&events->group_peer_limit[events->group_peer_limit_size];
tox_event_group_peer_limit_construct(group_peer_limit);
++events->group_peer_limit_size;
return group_peer_limit;
}
void tox_events_clear_group_peer_limit(Tox_Events *events)
void tox_event_group_peer_limit_free(Tox_Event_Group_Peer_Limit *group_peer_limit, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_peer_limit != nullptr) {
tox_event_group_peer_limit_destruct(group_peer_limit, mem);
}
for (uint32_t i = 0; i < events->group_peer_limit_size; ++i) {
tox_event_group_peer_limit_destruct(&events->group_peer_limit[i]);
}
free(events->group_peer_limit);
events->group_peer_limit = nullptr;
events->group_peer_limit_size = 0;
events->group_peer_limit_capacity = 0;
mem_delete(mem, group_peer_limit);
}
uint32_t tox_events_get_group_peer_limit_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Peer_Limit *tox_events_add_group_peer_limit(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Peer_Limit *const group_peer_limit = tox_event_group_peer_limit_new(mem);
if (group_peer_limit == nullptr) {
return nullptr;
}
return events->group_peer_limit_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PEER_LIMIT;
event.data.group_peer_limit = group_peer_limit;
tox_events_add(events, &event);
return group_peer_limit;
}
const Tox_Event_Group_Peer_Limit *tox_events_get_group_peer_limit(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_peer_limit_size);
assert(events->group_peer_limit != nullptr);
return &events->group_peer_limit[index];
}
bool tox_events_pack_group_peer_limit(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_peer_limit_size(events);
uint32_t group_peer_limit_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_peer_limit_pack(tox_events_get_group_peer_limit(events, i), bp)) {
return false;
if (group_peer_limit_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_LIMIT) {
const Tox_Event_Group_Peer_Limit *group_peer_limit = events->events[i].data.group_peer_limit;
if (group_peer_limit_index == index) {
return group_peer_limit;
}
++group_peer_limit_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_peer_limit(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_peer_limit_size(const Tox_Events *events)
{
Tox_Event_Group_Peer_Limit *event = tox_events_add_group_peer_limit(events);
uint32_t group_peer_limit_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_LIMIT) {
++group_peer_limit_size;
}
}
return group_peer_limit_size;
}
bool tox_event_group_peer_limit_unpack(
Tox_Event_Group_Peer_Limit **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_peer_limit_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_peer_limit_unpack(event, bu);
return tox_event_group_peer_limit_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Peer_Limit *tox_event_group_peer_limit_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Peer_Limit *group_peer_limit = tox_events_add_group_peer_limit(state->events, state->mem);
if (group_peer_limit == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_peer_limit;
}
@ -195,17 +221,9 @@ bool tox_events_unpack_group_peer_limit(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_peer_limit(Tox *tox, uint32_t group_number, uint32_t peer_limit,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Peer_Limit *group_peer_limit = tox_events_add_group_peer_limit(state->events);
Tox_Event_Group_Peer_Limit *group_peer_limit = tox_event_group_peer_limit_alloc(user_data);
if (group_peer_limit == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_peer_name.c vendored
View File

@ -30,19 +30,6 @@ struct Tox_Event_Group_Peer_Name {
uint32_t name_length;
};
non_null()
static void tox_event_group_peer_name_construct(Tox_Event_Group_Peer_Name *group_peer_name)
{
*group_peer_name = (Tox_Event_Group_Peer_Name) {
0
};
}
non_null()
static void tox_event_group_peer_name_destruct(Tox_Event_Group_Peer_Name *group_peer_name)
{
free(group_peer_name->name);
}
non_null()
static void tox_event_group_peer_name_set_group_number(Tox_Event_Group_Peer_Name *group_peer_name,
uint32_t group_number)
@ -91,7 +78,7 @@ static bool tox_event_group_peer_name_set_name(Tox_Event_Group_Peer_Name *group_
group_peer_name->name_length = name_length;
return true;
}
size_t tox_event_group_peer_name_get_name_length(const Tox_Event_Group_Peer_Name *group_peer_name)
uint32_t tox_event_group_peer_name_get_name_length(const Tox_Event_Group_Peer_Name *group_peer_name)
{
assert(group_peer_name != nullptr);
return group_peer_name->name_length;
@ -103,7 +90,19 @@ const uint8_t *tox_event_group_peer_name_get_name(const Tox_Event_Group_Peer_Nam
}
non_null()
static bool tox_event_group_peer_name_pack(
static void tox_event_group_peer_name_construct(Tox_Event_Group_Peer_Name *group_peer_name)
{
*group_peer_name = (Tox_Event_Group_Peer_Name) {
0
};
}
non_null()
static void tox_event_group_peer_name_destruct(Tox_Event_Group_Peer_Name *group_peer_name, const Memory *mem)
{
free(group_peer_name->name);
}
bool tox_event_group_peer_name_pack(
const Tox_Event_Group_Peer_Name *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -116,7 +115,7 @@ static bool tox_event_group_peer_name_pack(
}
non_null()
static bool tox_event_group_peer_name_unpack(
static bool tox_event_group_peer_name_unpack_into(
Tox_Event_Group_Peer_Name *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -132,93 +131,120 @@ static bool tox_event_group_peer_name_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Peer_Name *tox_events_add_group_peer_name(Tox_Events *events)
const Tox_Event_Group_Peer_Name *tox_event_get_group_peer_name(const Tox_Event *event)
{
if (events->group_peer_name_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PEER_NAME ? event->data.group_peer_name : nullptr;
}
Tox_Event_Group_Peer_Name *tox_event_group_peer_name_new(const Memory *mem)
{
Tox_Event_Group_Peer_Name *const group_peer_name =
(Tox_Event_Group_Peer_Name *)mem_alloc(mem, sizeof(Tox_Event_Group_Peer_Name));
if (group_peer_name == nullptr) {
return nullptr;
}
if (events->group_peer_name_size == events->group_peer_name_capacity) {
const uint32_t new_group_peer_name_capacity = events->group_peer_name_capacity * 2 + 1;
Tox_Event_Group_Peer_Name *new_group_peer_name = (Tox_Event_Group_Peer_Name *)
realloc(
events->group_peer_name,
new_group_peer_name_capacity * sizeof(Tox_Event_Group_Peer_Name));
if (new_group_peer_name == nullptr) {
return nullptr;
}
events->group_peer_name = new_group_peer_name;
events->group_peer_name_capacity = new_group_peer_name_capacity;
}
Tox_Event_Group_Peer_Name *const group_peer_name =
&events->group_peer_name[events->group_peer_name_size];
tox_event_group_peer_name_construct(group_peer_name);
++events->group_peer_name_size;
return group_peer_name;
}
void tox_events_clear_group_peer_name(Tox_Events *events)
void tox_event_group_peer_name_free(Tox_Event_Group_Peer_Name *group_peer_name, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_peer_name != nullptr) {
tox_event_group_peer_name_destruct(group_peer_name, mem);
}
for (uint32_t i = 0; i < events->group_peer_name_size; ++i) {
tox_event_group_peer_name_destruct(&events->group_peer_name[i]);
}
free(events->group_peer_name);
events->group_peer_name = nullptr;
events->group_peer_name_size = 0;
events->group_peer_name_capacity = 0;
mem_delete(mem, group_peer_name);
}
uint32_t tox_events_get_group_peer_name_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Peer_Name *tox_events_add_group_peer_name(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Peer_Name *const group_peer_name = tox_event_group_peer_name_new(mem);
if (group_peer_name == nullptr) {
return nullptr;
}
return events->group_peer_name_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PEER_NAME;
event.data.group_peer_name = group_peer_name;
tox_events_add(events, &event);
return group_peer_name;
}
const Tox_Event_Group_Peer_Name *tox_events_get_group_peer_name(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_peer_name_size);
assert(events->group_peer_name != nullptr);
return &events->group_peer_name[index];
}
bool tox_events_pack_group_peer_name(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_peer_name_size(events);
uint32_t group_peer_name_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_peer_name_pack(tox_events_get_group_peer_name(events, i), bp)) {
return false;
if (group_peer_name_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_NAME) {
const Tox_Event_Group_Peer_Name *group_peer_name = events->events[i].data.group_peer_name;
if (group_peer_name_index == index) {
return group_peer_name;
}
++group_peer_name_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_peer_name(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_peer_name_size(const Tox_Events *events)
{
Tox_Event_Group_Peer_Name *event = tox_events_add_group_peer_name(events);
uint32_t group_peer_name_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_NAME) {
++group_peer_name_size;
}
}
return group_peer_name_size;
}
bool tox_event_group_peer_name_unpack(
Tox_Event_Group_Peer_Name **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_peer_name_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_peer_name_unpack(event, bu);
return tox_event_group_peer_name_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Peer_Name *tox_event_group_peer_name_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Peer_Name *group_peer_name = tox_events_add_group_peer_name(state->events, state->mem);
if (group_peer_name == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_peer_name;
}
@ -232,17 +258,9 @@ bool tox_events_unpack_group_peer_name(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_peer_name(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *name, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Peer_Name *group_peer_name = tox_events_add_group_peer_name(state->events);
Tox_Event_Group_Peer_Name *group_peer_name = tox_event_group_peer_name_alloc(user_data);
if (group_peer_name == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_peer_status.c vendored
View File

@ -29,19 +29,6 @@ struct Tox_Event_Group_Peer_Status {
Tox_User_Status status;
};
non_null()
static void tox_event_group_peer_status_construct(Tox_Event_Group_Peer_Status *group_peer_status)
{
*group_peer_status = (Tox_Event_Group_Peer_Status) {
0
};
}
non_null()
static void tox_event_group_peer_status_destruct(Tox_Event_Group_Peer_Status *group_peer_status)
{
return;
}
non_null()
static void tox_event_group_peer_status_set_group_number(Tox_Event_Group_Peer_Status *group_peer_status,
uint32_t group_number)
@ -82,7 +69,19 @@ Tox_User_Status tox_event_group_peer_status_get_status(const Tox_Event_Group_Pee
}
non_null()
static bool tox_event_group_peer_status_pack(
static void tox_event_group_peer_status_construct(Tox_Event_Group_Peer_Status *group_peer_status)
{
*group_peer_status = (Tox_Event_Group_Peer_Status) {
0
};
}
non_null()
static void tox_event_group_peer_status_destruct(Tox_Event_Group_Peer_Status *group_peer_status, const Memory *mem)
{
return;
}
bool tox_event_group_peer_status_pack(
const Tox_Event_Group_Peer_Status *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -95,7 +94,7 @@ static bool tox_event_group_peer_status_pack(
}
non_null()
static bool tox_event_group_peer_status_unpack(
static bool tox_event_group_peer_status_unpack_into(
Tox_Event_Group_Peer_Status *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -105,99 +104,126 @@ static bool tox_event_group_peer_status_unpack(
return bin_unpack_u32(bu, &event->group_number)
&& bin_unpack_u32(bu, &event->peer_id)
&& tox_unpack_user_status(bu, &event->status);
&& tox_user_status_unpack(bu, &event->status);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Peer_Status *tox_events_add_group_peer_status(Tox_Events *events)
const Tox_Event_Group_Peer_Status *tox_event_get_group_peer_status(const Tox_Event *event)
{
if (events->group_peer_status_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PEER_STATUS ? event->data.group_peer_status : nullptr;
}
Tox_Event_Group_Peer_Status *tox_event_group_peer_status_new(const Memory *mem)
{
Tox_Event_Group_Peer_Status *const group_peer_status =
(Tox_Event_Group_Peer_Status *)mem_alloc(mem, sizeof(Tox_Event_Group_Peer_Status));
if (group_peer_status == nullptr) {
return nullptr;
}
if (events->group_peer_status_size == events->group_peer_status_capacity) {
const uint32_t new_group_peer_status_capacity = events->group_peer_status_capacity * 2 + 1;
Tox_Event_Group_Peer_Status *new_group_peer_status = (Tox_Event_Group_Peer_Status *)
realloc(
events->group_peer_status,
new_group_peer_status_capacity * sizeof(Tox_Event_Group_Peer_Status));
if (new_group_peer_status == nullptr) {
return nullptr;
}
events->group_peer_status = new_group_peer_status;
events->group_peer_status_capacity = new_group_peer_status_capacity;
}
Tox_Event_Group_Peer_Status *const group_peer_status =
&events->group_peer_status[events->group_peer_status_size];
tox_event_group_peer_status_construct(group_peer_status);
++events->group_peer_status_size;
return group_peer_status;
}
void tox_events_clear_group_peer_status(Tox_Events *events)
void tox_event_group_peer_status_free(Tox_Event_Group_Peer_Status *group_peer_status, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_peer_status != nullptr) {
tox_event_group_peer_status_destruct(group_peer_status, mem);
}
for (uint32_t i = 0; i < events->group_peer_status_size; ++i) {
tox_event_group_peer_status_destruct(&events->group_peer_status[i]);
}
free(events->group_peer_status);
events->group_peer_status = nullptr;
events->group_peer_status_size = 0;
events->group_peer_status_capacity = 0;
mem_delete(mem, group_peer_status);
}
uint32_t tox_events_get_group_peer_status_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Peer_Status *tox_events_add_group_peer_status(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Peer_Status *const group_peer_status = tox_event_group_peer_status_new(mem);
if (group_peer_status == nullptr) {
return nullptr;
}
return events->group_peer_status_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PEER_STATUS;
event.data.group_peer_status = group_peer_status;
tox_events_add(events, &event);
return group_peer_status;
}
const Tox_Event_Group_Peer_Status *tox_events_get_group_peer_status(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_peer_status_size);
assert(events->group_peer_status != nullptr);
return &events->group_peer_status[index];
}
bool tox_events_pack_group_peer_status(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_peer_status_size(events);
uint32_t group_peer_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_peer_status_pack(tox_events_get_group_peer_status(events, i), bp)) {
return false;
if (group_peer_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PEER_STATUS) {
const Tox_Event_Group_Peer_Status *group_peer_status = events->events[i].data.group_peer_status;
if (group_peer_status_index == index) {
return group_peer_status;
}
++group_peer_status_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_peer_status(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_peer_status_size(const Tox_Events *events)
{
Tox_Event_Group_Peer_Status *event = tox_events_add_group_peer_status(events);
uint32_t group_peer_status_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PEER_STATUS) {
++group_peer_status_size;
}
}
return group_peer_status_size;
}
bool tox_event_group_peer_status_unpack(
Tox_Event_Group_Peer_Status **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_peer_status_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_peer_status_unpack(event, bu);
return tox_event_group_peer_status_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Peer_Status *tox_event_group_peer_status_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Peer_Status *group_peer_status = tox_events_add_group_peer_status(state->events, state->mem);
if (group_peer_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_peer_status;
}
@ -211,17 +237,9 @@ bool tox_events_unpack_group_peer_status(Tox_Events *events, Bin_Unpack *bu)
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_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Peer_Status *group_peer_status = tox_events_add_group_peer_status(state->events);
Tox_Event_Group_Peer_Status *group_peer_status = tox_event_group_peer_status_alloc(user_data);
if (group_peer_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_privacy_state.c vendored
View File

@ -28,19 +28,6 @@ struct Tox_Event_Group_Privacy_State {
Tox_Group_Privacy_State privacy_state;
};
non_null()
static void tox_event_group_privacy_state_construct(Tox_Event_Group_Privacy_State *group_privacy_state)
{
*group_privacy_state = (Tox_Event_Group_Privacy_State) {
0
};
}
non_null()
static void tox_event_group_privacy_state_destruct(Tox_Event_Group_Privacy_State *group_privacy_state)
{
return;
}
non_null()
static void tox_event_group_privacy_state_set_group_number(Tox_Event_Group_Privacy_State *group_privacy_state,
uint32_t group_number)
@ -68,7 +55,19 @@ Tox_Group_Privacy_State tox_event_group_privacy_state_get_privacy_state(const To
}
non_null()
static bool tox_event_group_privacy_state_pack(
static void tox_event_group_privacy_state_construct(Tox_Event_Group_Privacy_State *group_privacy_state)
{
*group_privacy_state = (Tox_Event_Group_Privacy_State) {
0
};
}
non_null()
static void tox_event_group_privacy_state_destruct(Tox_Event_Group_Privacy_State *group_privacy_state, const Memory *mem)
{
return;
}
bool tox_event_group_privacy_state_pack(
const Tox_Event_Group_Privacy_State *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -80,7 +79,7 @@ static bool tox_event_group_privacy_state_pack(
}
non_null()
static bool tox_event_group_privacy_state_unpack(
static bool tox_event_group_privacy_state_unpack_into(
Tox_Event_Group_Privacy_State *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -89,99 +88,126 @@ static bool tox_event_group_privacy_state_unpack(
}
return bin_unpack_u32(bu, &event->group_number)
&& tox_unpack_group_privacy_state(bu, &event->privacy_state);
&& tox_group_privacy_state_unpack(bu, &event->privacy_state);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Privacy_State *tox_events_add_group_privacy_state(Tox_Events *events)
const Tox_Event_Group_Privacy_State *tox_event_get_group_privacy_state(const Tox_Event *event)
{
if (events->group_privacy_state_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PRIVACY_STATE ? event->data.group_privacy_state : nullptr;
}
Tox_Event_Group_Privacy_State *tox_event_group_privacy_state_new(const Memory *mem)
{
Tox_Event_Group_Privacy_State *const group_privacy_state =
(Tox_Event_Group_Privacy_State *)mem_alloc(mem, sizeof(Tox_Event_Group_Privacy_State));
if (group_privacy_state == nullptr) {
return nullptr;
}
if (events->group_privacy_state_size == events->group_privacy_state_capacity) {
const uint32_t new_group_privacy_state_capacity = events->group_privacy_state_capacity * 2 + 1;
Tox_Event_Group_Privacy_State *new_group_privacy_state = (Tox_Event_Group_Privacy_State *)
realloc(
events->group_privacy_state,
new_group_privacy_state_capacity * sizeof(Tox_Event_Group_Privacy_State));
if (new_group_privacy_state == nullptr) {
return nullptr;
}
events->group_privacy_state = new_group_privacy_state;
events->group_privacy_state_capacity = new_group_privacy_state_capacity;
}
Tox_Event_Group_Privacy_State *const group_privacy_state =
&events->group_privacy_state[events->group_privacy_state_size];
tox_event_group_privacy_state_construct(group_privacy_state);
++events->group_privacy_state_size;
return group_privacy_state;
}
void tox_events_clear_group_privacy_state(Tox_Events *events)
void tox_event_group_privacy_state_free(Tox_Event_Group_Privacy_State *group_privacy_state, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_privacy_state != nullptr) {
tox_event_group_privacy_state_destruct(group_privacy_state, mem);
}
for (uint32_t i = 0; i < events->group_privacy_state_size; ++i) {
tox_event_group_privacy_state_destruct(&events->group_privacy_state[i]);
}
free(events->group_privacy_state);
events->group_privacy_state = nullptr;
events->group_privacy_state_size = 0;
events->group_privacy_state_capacity = 0;
mem_delete(mem, group_privacy_state);
}
uint32_t tox_events_get_group_privacy_state_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Privacy_State *tox_events_add_group_privacy_state(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Privacy_State *const group_privacy_state = tox_event_group_privacy_state_new(mem);
if (group_privacy_state == nullptr) {
return nullptr;
}
return events->group_privacy_state_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PRIVACY_STATE;
event.data.group_privacy_state = group_privacy_state;
tox_events_add(events, &event);
return group_privacy_state;
}
const Tox_Event_Group_Privacy_State *tox_events_get_group_privacy_state(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_privacy_state_size);
assert(events->group_privacy_state != nullptr);
return &events->group_privacy_state[index];
}
bool tox_events_pack_group_privacy_state(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_privacy_state_size(events);
uint32_t group_privacy_state_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_privacy_state_pack(tox_events_get_group_privacy_state(events, i), bp)) {
return false;
if (group_privacy_state_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PRIVACY_STATE) {
const Tox_Event_Group_Privacy_State *group_privacy_state = events->events[i].data.group_privacy_state;
if (group_privacy_state_index == index) {
return group_privacy_state;
}
++group_privacy_state_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_privacy_state(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_privacy_state_size(const Tox_Events *events)
{
Tox_Event_Group_Privacy_State *event = tox_events_add_group_privacy_state(events);
uint32_t group_privacy_state_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PRIVACY_STATE) {
++group_privacy_state_size;
}
}
return group_privacy_state_size;
}
bool tox_event_group_privacy_state_unpack(
Tox_Event_Group_Privacy_State **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_privacy_state_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_privacy_state_unpack(event, bu);
return tox_event_group_privacy_state_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Privacy_State *tox_event_group_privacy_state_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Privacy_State *group_privacy_state = tox_events_add_group_privacy_state(state->events, state->mem);
if (group_privacy_state == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_privacy_state;
}
@ -195,17 +221,9 @@ bool tox_events_unpack_group_privacy_state(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_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);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Privacy_State *group_privacy_state = tox_events_add_group_privacy_state(state->events);
Tox_Event_Group_Privacy_State *group_privacy_state = tox_event_group_privacy_state_alloc(user_data);
if (group_privacy_state == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

178
external/toxcore/c-toxcore/toxcore/events/group_private_message.c vendored
View File

@ -31,19 +31,6 @@ struct Tox_Event_Group_Private_Message {
uint32_t message_length;
};
non_null()
static void tox_event_group_private_message_construct(Tox_Event_Group_Private_Message *group_private_message)
{
*group_private_message = (Tox_Event_Group_Private_Message) {
0
};
}
non_null()
static void tox_event_group_private_message_destruct(Tox_Event_Group_Private_Message *group_private_message)
{
free(group_private_message->message);
}
non_null()
static void tox_event_group_private_message_set_group_number(Tox_Event_Group_Private_Message *group_private_message,
uint32_t group_number)
@ -105,7 +92,7 @@ static bool tox_event_group_private_message_set_message(Tox_Event_Group_Private_
group_private_message->message_length = message_length;
return true;
}
size_t tox_event_group_private_message_get_message_length(const Tox_Event_Group_Private_Message *group_private_message)
uint32_t tox_event_group_private_message_get_message_length(const Tox_Event_Group_Private_Message *group_private_message)
{
assert(group_private_message != nullptr);
return group_private_message->message_length;
@ -117,7 +104,19 @@ const uint8_t *tox_event_group_private_message_get_message(const Tox_Event_Group
}
non_null()
static bool tox_event_group_private_message_pack(
static void tox_event_group_private_message_construct(Tox_Event_Group_Private_Message *group_private_message)
{
*group_private_message = (Tox_Event_Group_Private_Message) {
0
};
}
non_null()
static void tox_event_group_private_message_destruct(Tox_Event_Group_Private_Message *group_private_message, const Memory *mem)
{
free(group_private_message->message);
}
bool tox_event_group_private_message_pack(
const Tox_Event_Group_Private_Message *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -131,7 +130,7 @@ static bool tox_event_group_private_message_pack(
}
non_null()
static bool tox_event_group_private_message_unpack(
static bool tox_event_group_private_message_unpack_into(
Tox_Event_Group_Private_Message *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -141,100 +140,127 @@ static bool tox_event_group_private_message_unpack(
return bin_unpack_u32(bu, &event->group_number)
&& bin_unpack_u32(bu, &event->peer_id)
&& tox_unpack_message_type(bu, &event->type)
&& tox_message_type_unpack(bu, &event->type)
&& bin_unpack_bin(bu, &event->message, &event->message_length);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Private_Message *tox_events_add_group_private_message(Tox_Events *events)
const Tox_Event_Group_Private_Message *tox_event_get_group_private_message(const Tox_Event *event)
{
if (events->group_private_message_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_PRIVATE_MESSAGE ? event->data.group_private_message : nullptr;
}
Tox_Event_Group_Private_Message *tox_event_group_private_message_new(const Memory *mem)
{
Tox_Event_Group_Private_Message *const group_private_message =
(Tox_Event_Group_Private_Message *)mem_alloc(mem, sizeof(Tox_Event_Group_Private_Message));
if (group_private_message == nullptr) {
return nullptr;
}
if (events->group_private_message_size == events->group_private_message_capacity) {
const uint32_t new_group_private_message_capacity = events->group_private_message_capacity * 2 + 1;
Tox_Event_Group_Private_Message *new_group_private_message = (Tox_Event_Group_Private_Message *)
realloc(
events->group_private_message,
new_group_private_message_capacity * sizeof(Tox_Event_Group_Private_Message));
if (new_group_private_message == nullptr) {
return nullptr;
}
events->group_private_message = new_group_private_message;
events->group_private_message_capacity = new_group_private_message_capacity;
}
Tox_Event_Group_Private_Message *const group_private_message =
&events->group_private_message[events->group_private_message_size];
tox_event_group_private_message_construct(group_private_message);
++events->group_private_message_size;
return group_private_message;
}
void tox_events_clear_group_private_message(Tox_Events *events)
void tox_event_group_private_message_free(Tox_Event_Group_Private_Message *group_private_message, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_private_message != nullptr) {
tox_event_group_private_message_destruct(group_private_message, mem);
}
for (uint32_t i = 0; i < events->group_private_message_size; ++i) {
tox_event_group_private_message_destruct(&events->group_private_message[i]);
}
free(events->group_private_message);
events->group_private_message = nullptr;
events->group_private_message_size = 0;
events->group_private_message_capacity = 0;
mem_delete(mem, group_private_message);
}
uint32_t tox_events_get_group_private_message_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Private_Message *tox_events_add_group_private_message(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Private_Message *const group_private_message = tox_event_group_private_message_new(mem);
if (group_private_message == nullptr) {
return nullptr;
}
return events->group_private_message_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_PRIVATE_MESSAGE;
event.data.group_private_message = group_private_message;
tox_events_add(events, &event);
return group_private_message;
}
const Tox_Event_Group_Private_Message *tox_events_get_group_private_message(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_private_message_size);
assert(events->group_private_message != nullptr);
return &events->group_private_message[index];
}
bool tox_events_pack_group_private_message(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_private_message_size(events);
uint32_t group_private_message_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_private_message_pack(tox_events_get_group_private_message(events, i), bp)) {
return false;
if (group_private_message_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_PRIVATE_MESSAGE) {
const Tox_Event_Group_Private_Message *group_private_message = events->events[i].data.group_private_message;
if (group_private_message_index == index) {
return group_private_message;
}
++group_private_message_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_private_message(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_private_message_size(const Tox_Events *events)
{
Tox_Event_Group_Private_Message *event = tox_events_add_group_private_message(events);
uint32_t group_private_message_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_PRIVATE_MESSAGE) {
++group_private_message_size;
}
}
return group_private_message_size;
}
bool tox_event_group_private_message_unpack(
Tox_Event_Group_Private_Message **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_private_message_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_private_message_unpack(event, bu);
return tox_event_group_private_message_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Private_Message *tox_event_group_private_message_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Private_Message *group_private_message = tox_events_add_group_private_message(state->events, state->mem);
if (group_private_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_private_message;
}
@ -248,17 +274,9 @@ bool tox_events_unpack_group_private_message(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_private_message(Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, const uint8_t *message, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Private_Message *group_private_message = tox_events_add_group_private_message(state->events);
Tox_Event_Group_Private_Message *group_private_message = tox_event_group_private_message_alloc(user_data);
if (group_private_message == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

175
external/toxcore/c-toxcore/toxcore/events/group_self_join.c vendored
View File

@ -27,19 +27,6 @@ struct Tox_Event_Group_Self_Join {
uint32_t group_number;
};
non_null()
static void tox_event_group_self_join_construct(Tox_Event_Group_Self_Join *group_self_join)
{
*group_self_join = (Tox_Event_Group_Self_Join) {
0
};
}
non_null()
static void tox_event_group_self_join_destruct(Tox_Event_Group_Self_Join *group_self_join)
{
return;
}
non_null()
static void tox_event_group_self_join_set_group_number(Tox_Event_Group_Self_Join *group_self_join,
uint32_t group_number)
@ -54,18 +41,29 @@ uint32_t tox_event_group_self_join_get_group_number(const Tox_Event_Group_Self_J
}
non_null()
static bool tox_event_group_self_join_pack(
static void tox_event_group_self_join_construct(Tox_Event_Group_Self_Join *group_self_join)
{
*group_self_join = (Tox_Event_Group_Self_Join) {
0
};
}
non_null()
static void tox_event_group_self_join_destruct(Tox_Event_Group_Self_Join *group_self_join, const Memory *mem)
{
return;
}
bool tox_event_group_self_join_pack(
const Tox_Event_Group_Self_Join *event, Bin_Pack *bp)
{
assert(event != nullptr);
return bin_pack_array(bp, 2)
&& bin_pack_u32(bp, TOX_EVENT_GROUP_SELF_JOIN)
&& bin_pack_u32(bp, event->group_number);
}
non_null()
static bool tox_event_group_self_join_unpack(
static bool tox_event_group_self_join_unpack_into(
Tox_Event_Group_Self_Join *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -75,93 +73,120 @@ static bool tox_event_group_self_join_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Self_Join *tox_events_add_group_self_join(Tox_Events *events)
const Tox_Event_Group_Self_Join *tox_event_get_group_self_join(const Tox_Event *event)
{
if (events->group_self_join_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_SELF_JOIN ? event->data.group_self_join : nullptr;
}
Tox_Event_Group_Self_Join *tox_event_group_self_join_new(const Memory *mem)
{
Tox_Event_Group_Self_Join *const group_self_join =
(Tox_Event_Group_Self_Join *)mem_alloc(mem, sizeof(Tox_Event_Group_Self_Join));
if (group_self_join == nullptr) {
return nullptr;
}
if (events->group_self_join_size == events->group_self_join_capacity) {
const uint32_t new_group_self_join_capacity = events->group_self_join_capacity * 2 + 1;
Tox_Event_Group_Self_Join *new_group_self_join = (Tox_Event_Group_Self_Join *)
realloc(
events->group_self_join,
new_group_self_join_capacity * sizeof(Tox_Event_Group_Self_Join));
if (new_group_self_join == nullptr) {
return nullptr;
}
events->group_self_join = new_group_self_join;
events->group_self_join_capacity = new_group_self_join_capacity;
}
Tox_Event_Group_Self_Join *const group_self_join =
&events->group_self_join[events->group_self_join_size];
tox_event_group_self_join_construct(group_self_join);
++events->group_self_join_size;
return group_self_join;
}
void tox_events_clear_group_self_join(Tox_Events *events)
void tox_event_group_self_join_free(Tox_Event_Group_Self_Join *group_self_join, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_self_join != nullptr) {
tox_event_group_self_join_destruct(group_self_join, mem);
}
for (uint32_t i = 0; i < events->group_self_join_size; ++i) {
tox_event_group_self_join_destruct(&events->group_self_join[i]);
}
free(events->group_self_join);
events->group_self_join = nullptr;
events->group_self_join_size = 0;
events->group_self_join_capacity = 0;
mem_delete(mem, group_self_join);
}
uint32_t tox_events_get_group_self_join_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Self_Join *tox_events_add_group_self_join(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Self_Join *const group_self_join = tox_event_group_self_join_new(mem);
if (group_self_join == nullptr) {
return nullptr;
}
return events->group_self_join_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_SELF_JOIN;
event.data.group_self_join = group_self_join;
tox_events_add(events, &event);
return group_self_join;
}
const Tox_Event_Group_Self_Join *tox_events_get_group_self_join(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_self_join_size);
assert(events->group_self_join != nullptr);
return &events->group_self_join[index];
}
bool tox_events_pack_group_self_join(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_self_join_size(events);
uint32_t group_self_join_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_self_join_pack(tox_events_get_group_self_join(events, i), bp)) {
return false;
if (group_self_join_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_SELF_JOIN) {
const Tox_Event_Group_Self_Join *group_self_join = events->events[i].data.group_self_join;
if (group_self_join_index == index) {
return group_self_join;
}
++group_self_join_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_self_join(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_self_join_size(const Tox_Events *events)
{
Tox_Event_Group_Self_Join *event = tox_events_add_group_self_join(events);
uint32_t group_self_join_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_SELF_JOIN) {
++group_self_join_size;
}
}
return group_self_join_size;
}
bool tox_event_group_self_join_unpack(
Tox_Event_Group_Self_Join **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_self_join_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_self_join_unpack(event, bu);
return tox_event_group_self_join_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Self_Join *tox_event_group_self_join_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Self_Join *group_self_join = tox_events_add_group_self_join(state->events, state->mem);
if (group_self_join == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_self_join;
}
@ -175,17 +200,9 @@ bool tox_events_unpack_group_self_join(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_self_join(Tox *tox, uint32_t group_number,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Self_Join *group_self_join = tox_events_add_group_self_join(state->events);
Tox_Event_Group_Self_Join *group_self_join = tox_event_group_self_join_alloc(user_data);
if (group_self_join == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_topic.c vendored
View File

@ -30,19 +30,6 @@ struct Tox_Event_Group_Topic {
uint32_t topic_length;
};
non_null()
static void tox_event_group_topic_construct(Tox_Event_Group_Topic *group_topic)
{
*group_topic = (Tox_Event_Group_Topic) {
0
};
}
non_null()
static void tox_event_group_topic_destruct(Tox_Event_Group_Topic *group_topic)
{
free(group_topic->topic);
}
non_null()
static void tox_event_group_topic_set_group_number(Tox_Event_Group_Topic *group_topic,
uint32_t group_number)
@ -91,7 +78,7 @@ static bool tox_event_group_topic_set_topic(Tox_Event_Group_Topic *group_topic,
group_topic->topic_length = topic_length;
return true;
}
size_t tox_event_group_topic_get_topic_length(const Tox_Event_Group_Topic *group_topic)
uint32_t tox_event_group_topic_get_topic_length(const Tox_Event_Group_Topic *group_topic)
{
assert(group_topic != nullptr);
return group_topic->topic_length;
@ -103,7 +90,19 @@ const uint8_t *tox_event_group_topic_get_topic(const Tox_Event_Group_Topic *grou
}
non_null()
static bool tox_event_group_topic_pack(
static void tox_event_group_topic_construct(Tox_Event_Group_Topic *group_topic)
{
*group_topic = (Tox_Event_Group_Topic) {
0
};
}
non_null()
static void tox_event_group_topic_destruct(Tox_Event_Group_Topic *group_topic, const Memory *mem)
{
free(group_topic->topic);
}
bool tox_event_group_topic_pack(
const Tox_Event_Group_Topic *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -116,7 +115,7 @@ static bool tox_event_group_topic_pack(
}
non_null()
static bool tox_event_group_topic_unpack(
static bool tox_event_group_topic_unpack_into(
Tox_Event_Group_Topic *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -132,93 +131,120 @@ static bool tox_event_group_topic_unpack(
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Topic *tox_events_add_group_topic(Tox_Events *events)
const Tox_Event_Group_Topic *tox_event_get_group_topic(const Tox_Event *event)
{
if (events->group_topic_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_TOPIC ? event->data.group_topic : nullptr;
}
Tox_Event_Group_Topic *tox_event_group_topic_new(const Memory *mem)
{
Tox_Event_Group_Topic *const group_topic =
(Tox_Event_Group_Topic *)mem_alloc(mem, sizeof(Tox_Event_Group_Topic));
if (group_topic == nullptr) {
return nullptr;
}
if (events->group_topic_size == events->group_topic_capacity) {
const uint32_t new_group_topic_capacity = events->group_topic_capacity * 2 + 1;
Tox_Event_Group_Topic *new_group_topic = (Tox_Event_Group_Topic *)
realloc(
events->group_topic,
new_group_topic_capacity * sizeof(Tox_Event_Group_Topic));
if (new_group_topic == nullptr) {
return nullptr;
}
events->group_topic = new_group_topic;
events->group_topic_capacity = new_group_topic_capacity;
}
Tox_Event_Group_Topic *const group_topic =
&events->group_topic[events->group_topic_size];
tox_event_group_topic_construct(group_topic);
++events->group_topic_size;
return group_topic;
}
void tox_events_clear_group_topic(Tox_Events *events)
void tox_event_group_topic_free(Tox_Event_Group_Topic *group_topic, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_topic != nullptr) {
tox_event_group_topic_destruct(group_topic, mem);
}
for (uint32_t i = 0; i < events->group_topic_size; ++i) {
tox_event_group_topic_destruct(&events->group_topic[i]);
}
free(events->group_topic);
events->group_topic = nullptr;
events->group_topic_size = 0;
events->group_topic_capacity = 0;
mem_delete(mem, group_topic);
}
uint32_t tox_events_get_group_topic_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Topic *tox_events_add_group_topic(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Topic *const group_topic = tox_event_group_topic_new(mem);
if (group_topic == nullptr) {
return nullptr;
}
return events->group_topic_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_TOPIC;
event.data.group_topic = group_topic;
tox_events_add(events, &event);
return group_topic;
}
const Tox_Event_Group_Topic *tox_events_get_group_topic(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_topic_size);
assert(events->group_topic != nullptr);
return &events->group_topic[index];
}
bool tox_events_pack_group_topic(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_topic_size(events);
uint32_t group_topic_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_topic_pack(tox_events_get_group_topic(events, i), bp)) {
return false;
if (group_topic_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC) {
const Tox_Event_Group_Topic *group_topic = events->events[i].data.group_topic;
if (group_topic_index == index) {
return group_topic;
}
++group_topic_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_topic(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_topic_size(const Tox_Events *events)
{
Tox_Event_Group_Topic *event = tox_events_add_group_topic(events);
uint32_t group_topic_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC) {
++group_topic_size;
}
}
return group_topic_size;
}
bool tox_event_group_topic_unpack(
Tox_Event_Group_Topic **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_topic_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_topic_unpack(event, bu);
return tox_event_group_topic_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Topic *tox_event_group_topic_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Topic *group_topic = tox_events_add_group_topic(state->events, state->mem);
if (group_topic == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_topic;
}
@ -232,17 +258,9 @@ bool tox_events_unpack_group_topic(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_topic(Tox *tox, uint32_t group_number, uint32_t peer_id, const uint8_t *topic, size_t length,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Topic *group_topic = tox_events_add_group_topic(state->events);
Tox_Event_Group_Topic *group_topic = tox_event_group_topic_alloc(user_data);
if (group_topic == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_topic_lock.c vendored
View File

@ -28,19 +28,6 @@ struct Tox_Event_Group_Topic_Lock {
Tox_Group_Topic_Lock topic_lock;
};
non_null()
static void tox_event_group_topic_lock_construct(Tox_Event_Group_Topic_Lock *group_topic_lock)
{
*group_topic_lock = (Tox_Event_Group_Topic_Lock) {
0
};
}
non_null()
static void tox_event_group_topic_lock_destruct(Tox_Event_Group_Topic_Lock *group_topic_lock)
{
return;
}
non_null()
static void tox_event_group_topic_lock_set_group_number(Tox_Event_Group_Topic_Lock *group_topic_lock,
uint32_t group_number)
@ -68,7 +55,19 @@ Tox_Group_Topic_Lock tox_event_group_topic_lock_get_topic_lock(const Tox_Event_G
}
non_null()
static bool tox_event_group_topic_lock_pack(
static void tox_event_group_topic_lock_construct(Tox_Event_Group_Topic_Lock *group_topic_lock)
{
*group_topic_lock = (Tox_Event_Group_Topic_Lock) {
0
};
}
non_null()
static void tox_event_group_topic_lock_destruct(Tox_Event_Group_Topic_Lock *group_topic_lock, const Memory *mem)
{
return;
}
bool tox_event_group_topic_lock_pack(
const Tox_Event_Group_Topic_Lock *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -80,7 +79,7 @@ static bool tox_event_group_topic_lock_pack(
}
non_null()
static bool tox_event_group_topic_lock_unpack(
static bool tox_event_group_topic_lock_unpack_into(
Tox_Event_Group_Topic_Lock *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -89,99 +88,126 @@ static bool tox_event_group_topic_lock_unpack(
}
return bin_unpack_u32(bu, &event->group_number)
&& tox_unpack_group_topic_lock(bu, &event->topic_lock);
&& tox_group_topic_lock_unpack(bu, &event->topic_lock);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Topic_Lock *tox_events_add_group_topic_lock(Tox_Events *events)
const Tox_Event_Group_Topic_Lock *tox_event_get_group_topic_lock(const Tox_Event *event)
{
if (events->group_topic_lock_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_TOPIC_LOCK ? event->data.group_topic_lock : nullptr;
}
Tox_Event_Group_Topic_Lock *tox_event_group_topic_lock_new(const Memory *mem)
{
Tox_Event_Group_Topic_Lock *const group_topic_lock =
(Tox_Event_Group_Topic_Lock *)mem_alloc(mem, sizeof(Tox_Event_Group_Topic_Lock));
if (group_topic_lock == nullptr) {
return nullptr;
}
if (events->group_topic_lock_size == events->group_topic_lock_capacity) {
const uint32_t new_group_topic_lock_capacity = events->group_topic_lock_capacity * 2 + 1;
Tox_Event_Group_Topic_Lock *new_group_topic_lock = (Tox_Event_Group_Topic_Lock *)
realloc(
events->group_topic_lock,
new_group_topic_lock_capacity * sizeof(Tox_Event_Group_Topic_Lock));
if (new_group_topic_lock == nullptr) {
return nullptr;
}
events->group_topic_lock = new_group_topic_lock;
events->group_topic_lock_capacity = new_group_topic_lock_capacity;
}
Tox_Event_Group_Topic_Lock *const group_topic_lock =
&events->group_topic_lock[events->group_topic_lock_size];
tox_event_group_topic_lock_construct(group_topic_lock);
++events->group_topic_lock_size;
return group_topic_lock;
}
void tox_events_clear_group_topic_lock(Tox_Events *events)
void tox_event_group_topic_lock_free(Tox_Event_Group_Topic_Lock *group_topic_lock, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_topic_lock != nullptr) {
tox_event_group_topic_lock_destruct(group_topic_lock, mem);
}
for (uint32_t i = 0; i < events->group_topic_lock_size; ++i) {
tox_event_group_topic_lock_destruct(&events->group_topic_lock[i]);
}
free(events->group_topic_lock);
events->group_topic_lock = nullptr;
events->group_topic_lock_size = 0;
events->group_topic_lock_capacity = 0;
mem_delete(mem, group_topic_lock);
}
uint32_t tox_events_get_group_topic_lock_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Topic_Lock *tox_events_add_group_topic_lock(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Topic_Lock *const group_topic_lock = tox_event_group_topic_lock_new(mem);
if (group_topic_lock == nullptr) {
return nullptr;
}
return events->group_topic_lock_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_TOPIC_LOCK;
event.data.group_topic_lock = group_topic_lock;
tox_events_add(events, &event);
return group_topic_lock;
}
const Tox_Event_Group_Topic_Lock *tox_events_get_group_topic_lock(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_topic_lock_size);
assert(events->group_topic_lock != nullptr);
return &events->group_topic_lock[index];
}
bool tox_events_pack_group_topic_lock(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_topic_lock_size(events);
uint32_t group_topic_lock_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_topic_lock_pack(tox_events_get_group_topic_lock(events, i), bp)) {
return false;
if (group_topic_lock_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC_LOCK) {
const Tox_Event_Group_Topic_Lock *group_topic_lock = events->events[i].data.group_topic_lock;
if (group_topic_lock_index == index) {
return group_topic_lock;
}
++group_topic_lock_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_topic_lock(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_topic_lock_size(const Tox_Events *events)
{
Tox_Event_Group_Topic_Lock *event = tox_events_add_group_topic_lock(events);
uint32_t group_topic_lock_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_TOPIC_LOCK) {
++group_topic_lock_size;
}
}
return group_topic_lock_size;
}
bool tox_event_group_topic_lock_unpack(
Tox_Event_Group_Topic_Lock **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_topic_lock_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_topic_lock_unpack(event, bu);
return tox_event_group_topic_lock_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Topic_Lock *tox_event_group_topic_lock_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Topic_Lock *group_topic_lock = tox_events_add_group_topic_lock(state->events, state->mem);
if (group_topic_lock == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_topic_lock;
}
@ -195,17 +221,9 @@ bool tox_events_unpack_group_topic_lock(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_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);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Topic_Lock *group_topic_lock = tox_events_add_group_topic_lock(state->events);
Tox_Event_Group_Topic_Lock *group_topic_lock = tox_event_group_topic_lock_alloc(user_data);
if (group_topic_lock == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

176
external/toxcore/c-toxcore/toxcore/events/group_voice_state.c vendored
View File

@ -28,19 +28,6 @@ struct Tox_Event_Group_Voice_State {
Tox_Group_Voice_State voice_state;
};
non_null()
static void tox_event_group_voice_state_construct(Tox_Event_Group_Voice_State *group_voice_state)
{
*group_voice_state = (Tox_Event_Group_Voice_State) {
0
};
}
non_null()
static void tox_event_group_voice_state_destruct(Tox_Event_Group_Voice_State *group_voice_state)
{
return;
}
non_null()
static void tox_event_group_voice_state_set_group_number(Tox_Event_Group_Voice_State *group_voice_state,
uint32_t group_number)
@ -68,7 +55,19 @@ Tox_Group_Voice_State tox_event_group_voice_state_get_voice_state(const Tox_Even
}
non_null()
static bool tox_event_group_voice_state_pack(
static void tox_event_group_voice_state_construct(Tox_Event_Group_Voice_State *group_voice_state)
{
*group_voice_state = (Tox_Event_Group_Voice_State) {
0
};
}
non_null()
static void tox_event_group_voice_state_destruct(Tox_Event_Group_Voice_State *group_voice_state, const Memory *mem)
{
return;
}
bool tox_event_group_voice_state_pack(
const Tox_Event_Group_Voice_State *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -80,7 +79,7 @@ static bool tox_event_group_voice_state_pack(
}
non_null()
static bool tox_event_group_voice_state_unpack(
static bool tox_event_group_voice_state_unpack_into(
Tox_Event_Group_Voice_State *event, Bin_Unpack *bu)
{
assert(event != nullptr);
@ -89,99 +88,126 @@ static bool tox_event_group_voice_state_unpack(
}
return bin_unpack_u32(bu, &event->group_number)
&& tox_unpack_group_voice_state(bu, &event->voice_state);
&& tox_group_voice_state_unpack(bu, &event->voice_state);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Group_Voice_State *tox_events_add_group_voice_state(Tox_Events *events)
const Tox_Event_Group_Voice_State *tox_event_get_group_voice_state(const Tox_Event *event)
{
if (events->group_voice_state_size == UINT32_MAX) {
return event->type == TOX_EVENT_GROUP_VOICE_STATE ? event->data.group_voice_state : nullptr;
}
Tox_Event_Group_Voice_State *tox_event_group_voice_state_new(const Memory *mem)
{
Tox_Event_Group_Voice_State *const group_voice_state =
(Tox_Event_Group_Voice_State *)mem_alloc(mem, sizeof(Tox_Event_Group_Voice_State));
if (group_voice_state == nullptr) {
return nullptr;
}
if (events->group_voice_state_size == events->group_voice_state_capacity) {
const uint32_t new_group_voice_state_capacity = events->group_voice_state_capacity * 2 + 1;
Tox_Event_Group_Voice_State *new_group_voice_state = (Tox_Event_Group_Voice_State *)
realloc(
events->group_voice_state,
new_group_voice_state_capacity * sizeof(Tox_Event_Group_Voice_State));
if (new_group_voice_state == nullptr) {
return nullptr;
}
events->group_voice_state = new_group_voice_state;
events->group_voice_state_capacity = new_group_voice_state_capacity;
}
Tox_Event_Group_Voice_State *const group_voice_state =
&events->group_voice_state[events->group_voice_state_size];
tox_event_group_voice_state_construct(group_voice_state);
++events->group_voice_state_size;
return group_voice_state;
}
void tox_events_clear_group_voice_state(Tox_Events *events)
void tox_event_group_voice_state_free(Tox_Event_Group_Voice_State *group_voice_state, const Memory *mem)
{
if (events == nullptr) {
return;
if (group_voice_state != nullptr) {
tox_event_group_voice_state_destruct(group_voice_state, mem);
}
for (uint32_t i = 0; i < events->group_voice_state_size; ++i) {
tox_event_group_voice_state_destruct(&events->group_voice_state[i]);
}
free(events->group_voice_state);
events->group_voice_state = nullptr;
events->group_voice_state_size = 0;
events->group_voice_state_capacity = 0;
mem_delete(mem, group_voice_state);
}
uint32_t tox_events_get_group_voice_state_size(const Tox_Events *events)
non_null()
static Tox_Event_Group_Voice_State *tox_events_add_group_voice_state(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Group_Voice_State *const group_voice_state = tox_event_group_voice_state_new(mem);
if (group_voice_state == nullptr) {
return nullptr;
}
return events->group_voice_state_size;
Tox_Event event;
event.type = TOX_EVENT_GROUP_VOICE_STATE;
event.data.group_voice_state = group_voice_state;
tox_events_add(events, &event);
return group_voice_state;
}
const Tox_Event_Group_Voice_State *tox_events_get_group_voice_state(const Tox_Events *events, uint32_t index)
{
assert(index < events->group_voice_state_size);
assert(events->group_voice_state != nullptr);
return &events->group_voice_state[index];
}
bool tox_events_pack_group_voice_state(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_group_voice_state_size(events);
uint32_t group_voice_state_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_group_voice_state_pack(tox_events_get_group_voice_state(events, i), bp)) {
return false;
if (group_voice_state_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_GROUP_VOICE_STATE) {
const Tox_Event_Group_Voice_State *group_voice_state = events->events[i].data.group_voice_state;
if (group_voice_state_index == index) {
return group_voice_state;
}
++group_voice_state_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_group_voice_state(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_group_voice_state_size(const Tox_Events *events)
{
Tox_Event_Group_Voice_State *event = tox_events_add_group_voice_state(events);
uint32_t group_voice_state_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_GROUP_VOICE_STATE) {
++group_voice_state_size;
}
}
return group_voice_state_size;
}
bool tox_event_group_voice_state_unpack(
Tox_Event_Group_Voice_State **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_group_voice_state_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_group_voice_state_unpack(event, bu);
return tox_event_group_voice_state_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Group_Voice_State *tox_event_group_voice_state_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Group_Voice_State *group_voice_state = tox_events_add_group_voice_state(state->events, state->mem);
if (group_voice_state == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return group_voice_state;
}
@ -195,17 +221,9 @@ bool tox_events_unpack_group_voice_state(Tox_Events *events, Bin_Unpack *bu)
void tox_events_handle_group_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);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Group_Voice_State *group_voice_state = tox_events_add_group_voice_state(state->events);
Tox_Event_Group_Voice_State *group_voice_state = tox_event_group_voice_state_alloc(user_data);
if (group_voice_state == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

184
external/toxcore/c-toxcore/toxcore/events/self_connection_status.c vendored
View File

@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
* Copyright © 2023 The TokTok team.
*/
#include "events_alloc.h"
@ -27,6 +27,19 @@ struct Tox_Event_Self_Connection_Status {
Tox_Connection connection_status;
};
non_null()
static void tox_event_self_connection_status_set_connection_status(Tox_Event_Self_Connection_Status *self_connection_status,
Tox_Connection connection_status)
{
assert(self_connection_status != nullptr);
self_connection_status->connection_status = connection_status;
}
Tox_Connection tox_event_self_connection_status_get_connection_status(const Tox_Event_Self_Connection_Status *self_connection_status)
{
assert(self_connection_status != nullptr);
return self_connection_status->connection_status;
}
non_null()
static void tox_event_self_connection_status_construct(Tox_Event_Self_Connection_Status *self_connection_status)
{
@ -35,27 +48,12 @@ static void tox_event_self_connection_status_construct(Tox_Event_Self_Connection
};
}
non_null()
static void tox_event_self_connection_status_destruct(Tox_Event_Self_Connection_Status *self_connection_status)
static void tox_event_self_connection_status_destruct(Tox_Event_Self_Connection_Status *self_connection_status, const Memory *mem)
{
return;
}
non_null()
static void tox_event_self_connection_status_set_connection_status(Tox_Event_Self_Connection_Status
*self_connection_status, Tox_Connection connection_status)
{
assert(self_connection_status != nullptr);
self_connection_status->connection_status = connection_status;
}
Tox_Connection tox_event_self_connection_status_get_connection_status(const Tox_Event_Self_Connection_Status
*self_connection_status)
{
assert(self_connection_status != nullptr);
return self_connection_status->connection_status;
}
non_null()
static bool tox_event_self_connection_status_pack(
bool tox_event_self_connection_status_pack(
const Tox_Event_Self_Connection_Status *event, Bin_Pack *bp)
{
assert(event != nullptr);
@ -65,101 +63,130 @@ static bool tox_event_self_connection_status_pack(
}
non_null()
static bool tox_event_self_connection_status_unpack(
static bool tox_event_self_connection_status_unpack_into(
Tox_Event_Self_Connection_Status *event, Bin_Unpack *bu)
{
assert(event != nullptr);
return tox_unpack_connection(bu, &event->connection_status);
return tox_connection_unpack(bu, &event->connection_status);
}
/*****************************************************
*
* :: add/clear/get
* :: new/free/add/get/size/unpack
*
*****************************************************/
non_null()
static Tox_Event_Self_Connection_Status *tox_events_add_self_connection_status(Tox_Events *events)
const Tox_Event_Self_Connection_Status *tox_event_get_self_connection_status(const Tox_Event *event)
{
if (events->self_connection_status_size == UINT32_MAX) {
return event->type == TOX_EVENT_SELF_CONNECTION_STATUS ? event->data.self_connection_status : nullptr;
}
Tox_Event_Self_Connection_Status *tox_event_self_connection_status_new(const Memory *mem)
{
Tox_Event_Self_Connection_Status *const self_connection_status =
(Tox_Event_Self_Connection_Status *)mem_alloc(mem, sizeof(Tox_Event_Self_Connection_Status));
if (self_connection_status == nullptr) {
return nullptr;
}
if (events->self_connection_status_size == events->self_connection_status_capacity) {
const uint32_t new_self_connection_status_capacity = events->self_connection_status_capacity * 2 + 1;
Tox_Event_Self_Connection_Status *new_self_connection_status = (Tox_Event_Self_Connection_Status *)realloc(
events->self_connection_status, new_self_connection_status_capacity * sizeof(Tox_Event_Self_Connection_Status));
if (new_self_connection_status == nullptr) {
return nullptr;
}
events->self_connection_status = new_self_connection_status;
events->self_connection_status_capacity = new_self_connection_status_capacity;
}
Tox_Event_Self_Connection_Status *const self_connection_status =
&events->self_connection_status[events->self_connection_status_size];
tox_event_self_connection_status_construct(self_connection_status);
++events->self_connection_status_size;
return self_connection_status;
}
void tox_events_clear_self_connection_status(Tox_Events *events)
void tox_event_self_connection_status_free(Tox_Event_Self_Connection_Status *self_connection_status, const Memory *mem)
{
if (events == nullptr) {
return;
if (self_connection_status != nullptr) {
tox_event_self_connection_status_destruct(self_connection_status, mem);
}
for (uint32_t i = 0; i < events->self_connection_status_size; ++i) {
tox_event_self_connection_status_destruct(&events->self_connection_status[i]);
}
free(events->self_connection_status);
events->self_connection_status = nullptr;
events->self_connection_status_size = 0;
events->self_connection_status_capacity = 0;
mem_delete(mem, self_connection_status);
}
uint32_t tox_events_get_self_connection_status_size(const Tox_Events *events)
non_null()
static Tox_Event_Self_Connection_Status *tox_events_add_self_connection_status(Tox_Events *events, const Memory *mem)
{
if (events == nullptr) {
return 0;
Tox_Event_Self_Connection_Status *const self_connection_status = tox_event_self_connection_status_new(mem);
if (self_connection_status == nullptr) {
return nullptr;
}
return events->self_connection_status_size;
Tox_Event event;
event.type = TOX_EVENT_SELF_CONNECTION_STATUS;
event.data.self_connection_status = self_connection_status;
tox_events_add(events, &event);
return self_connection_status;
}
const Tox_Event_Self_Connection_Status *tox_events_get_self_connection_status(const Tox_Events *events, uint32_t index)
{
assert(index < events->self_connection_status_size);
assert(events->self_connection_status != nullptr);
return &events->self_connection_status[index];
}
bool tox_events_pack_self_connection_status(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t size = tox_events_get_self_connection_status_size(events);
uint32_t self_connection_status_index = 0;
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_self_connection_status_pack(tox_events_get_self_connection_status(events, i), bp)) {
return false;
if (self_connection_status_index > index) {
return nullptr;
}
if (events->events[i].type == TOX_EVENT_SELF_CONNECTION_STATUS) {
const Tox_Event_Self_Connection_Status *self_connection_status = events->events[i].data.self_connection_status;
if (self_connection_status_index == index) {
return self_connection_status;
}
++self_connection_status_index;
}
}
return true;
return nullptr;
}
bool tox_events_unpack_self_connection_status(Tox_Events *events, Bin_Unpack *bu)
uint32_t tox_events_get_self_connection_status_size(const Tox_Events *events)
{
Tox_Event_Self_Connection_Status *event = tox_events_add_self_connection_status(events);
uint32_t self_connection_status_size = 0;
const uint32_t size = tox_events_get_size(events);
if (event == nullptr) {
for (uint32_t i = 0; i < size; ++i) {
if (events->events[i].type == TOX_EVENT_SELF_CONNECTION_STATUS) {
++self_connection_status_size;
}
}
return self_connection_status_size;
}
bool tox_event_self_connection_status_unpack(
Tox_Event_Self_Connection_Status **event, Bin_Unpack *bu, const Memory *mem)
{
assert(event != nullptr);
*event = tox_event_self_connection_status_new(mem);
if (*event == nullptr) {
return false;
}
return tox_event_self_connection_status_unpack(event, bu);
return tox_event_self_connection_status_unpack_into(*event, bu);
}
non_null()
static Tox_Event_Self_Connection_Status *tox_event_self_connection_status_alloc(void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return nullptr;
}
Tox_Event_Self_Connection_Status *self_connection_status = tox_events_add_self_connection_status(state->events, state->mem);
if (self_connection_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return nullptr;
}
return self_connection_status;
}
@ -170,19 +197,12 @@ bool tox_events_unpack_self_connection_status(Tox_Events *events, Bin_Unpack *bu
*****************************************************/
void tox_events_handle_self_connection_status(Tox *tox, Tox_Connection connection_status, void *user_data)
void tox_events_handle_self_connection_status(Tox *tox, Tox_Connection connection_status,
void *user_data)
{
Tox_Events_State *state = tox_events_alloc(user_data);
assert(state != nullptr);
if (state->events == nullptr) {
return;
}
Tox_Event_Self_Connection_Status *self_connection_status = tox_events_add_self_connection_status(state->events);
Tox_Event_Self_Connection_Status *self_connection_status = tox_event_self_connection_status_alloc(user_data);
if (self_connection_status == nullptr) {
state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
return;
}

6
external/toxcore/c-toxcore/toxcore/forwarding.c vendored
View File

@ -31,14 +31,14 @@ struct Forwarding {
void *forwarded_response_callback_object;
};
DHT *forwarding_get_dht(Forwarding *forwarding)
DHT *forwarding_get_dht(const Forwarding *forwarding)
{
return forwarding->dht;
}
#define SENDBACK_TIMEOUT 3600
bool send_forward_request(Networking_Core *net, const IP_Port *forwarder,
bool send_forward_request(const Networking_Core *net, const IP_Port *forwarder,
const uint8_t *chain_keys, uint16_t chain_length,
const uint8_t *data, uint16_t data_length)
{
@ -316,7 +316,7 @@ static int handle_forwarding(void *object, const IP_Port *source, const uint8_t
}
}
bool forward_reply(Networking_Core *net, const IP_Port *forwarder,
bool forward_reply(const Networking_Core *net, const IP_Port *forwarder,
const uint8_t *sendback, uint16_t sendback_length,
const uint8_t *data, uint16_t length)
{

6
external/toxcore/c-toxcore/toxcore/forwarding.h vendored
View File

@ -26,7 +26,7 @@ extern "C" {
typedef struct Forwarding Forwarding;
non_null()
DHT *forwarding_get_dht(Forwarding *forwarding);
DHT *forwarding_get_dht(const Forwarding *forwarding);
/**
* @brief Send data to forwarder for forwarding via chain of dht nodes.
@ -41,7 +41,7 @@ DHT *forwarding_get_dht(Forwarding *forwarding);
* @return true on success, false otherwise.
*/
non_null()
bool send_forward_request(Networking_Core *net, const IP_Port *forwarder,
bool send_forward_request(const Networking_Core *net, const IP_Port *forwarder,
const uint8_t *chain_keys, uint16_t chain_length,
const uint8_t *data, uint16_t data_length);
@ -75,7 +75,7 @@ bool create_forward_chain_packet(const uint8_t *chain_keys, uint16_t chain_lengt
* @return true on success, false otherwise.
*/
non_null()
bool forward_reply(Networking_Core *net, const IP_Port *forwarder,
bool forward_reply(const Networking_Core *net, const IP_Port *forwarder,
const uint8_t *sendback, uint16_t sendback_length,
const uint8_t *data, uint16_t length);

20
external/toxcore/c-toxcore/toxcore/friend_connection.c vendored
View File

@ -911,25 +911,27 @@ Friend_Connections *new_friend_connections(
return nullptr;
}
temp->mono_time = mono_time;
temp->logger = logger;
temp->dht = onion_get_dht(onion_c);
temp->net_crypto = onion_get_net_crypto(onion_c);
temp->onion_c = onion_c;
temp->local_discovery_enabled = local_discovery_enabled;
// Don't include default port in port range
temp->next_lan_port = TOX_PORTRANGE_FROM + 1;
new_connection_handler(temp->net_crypto, &handle_new_connections, temp);
if (temp->local_discovery_enabled) {
temp->broadcast = lan_discovery_init(ns);
if (temp->broadcast == nullptr) {
LOGGER_ERROR(logger, "could not initialise LAN discovery");
temp->local_discovery_enabled = false;
}
}
temp->mono_time = mono_time;
temp->logger = logger;
temp->dht = onion_get_dht(onion_c);
temp->net_crypto = onion_get_net_crypto(onion_c);
temp->onion_c = onion_c;
// Don't include default port in port range
temp->next_lan_port = TOX_PORTRANGE_FROM + 1;
new_connection_handler(temp->net_crypto, &handle_new_connections, temp);
return temp;
}

5
external/toxcore/c-toxcore/toxcore/group.c vendored
View File

@ -212,13 +212,13 @@ static bool group_id_eq(const uint8_t *a, const uint8_t *b)
}
non_null()
static bool g_title_eq(Group_c *g, const uint8_t *title, uint8_t title_len)
static bool g_title_eq(const Group_c *g, const uint8_t *title, uint8_t title_len)
{
return memeq(g->title, g->title_len, title, title_len);
}
non_null()
static bool g_peer_nick_eq(Group_Peer *peer, const uint8_t *nick, uint8_t nick_len)
static bool g_peer_nick_eq(const Group_Peer *peer, const uint8_t *nick, uint8_t nick_len)
{
return memeq(peer->nick, peer->nick_len, nick, nick_len);
}
@ -3767,7 +3767,6 @@ Group_Chats *new_groupchats(const Mono_Time *mono_time, Messenger *m)
temp->mono_time = mono_time;
temp->m = m;
temp->fr_c = m->fr_c;
m->conferences_object = temp;
m_callback_conference_invite(m, &handle_friend_invite_packet);
set_global_status_callback(m->fr_c, &g_handle_any_status, temp);

19
external/toxcore/c-toxcore/toxcore/group_chats.c vendored
View File

@ -11,9 +11,7 @@
#include <assert.h>
#ifndef VANILLA_NACL
#include <sodium.h>
#endif
#include <string.h>
@ -30,8 +28,6 @@
#include "network.h"
#include "util.h"
#ifndef VANILLA_NACL
/* The minimum size of a plaintext group handshake packet */
#define GC_MIN_HS_PACKET_PAYLOAD_SIZE (1 + ENC_PUBLIC_KEY_SIZE + SIG_PUBLIC_KEY_SIZE + 1 + 1)
@ -160,7 +156,7 @@ non_null() static bool self_gc_is_founder(const GC_Chat *chat);
non_null() static bool group_number_valid(const GC_Session *c, int group_number);
non_null() static int peer_update(const GC_Chat *chat, const GC_Peer *peer, uint32_t peer_number);
non_null() static void group_delete(GC_Session *c, GC_Chat *chat);
non_null() static void group_cleanup(GC_Session *c, GC_Chat *chat);
non_null() static void group_cleanup(const GC_Session *c, GC_Chat *chat);
non_null() static bool group_exists(const GC_Session *c, const uint8_t *chat_id);
non_null() static void add_tcp_relays_to_chat(const GC_Session *c, GC_Chat *chat);
non_null(1, 2) nullable(4)
@ -1280,8 +1276,8 @@ static uint16_t unpack_gc_shared_state(GC_SharedState *shared_state, const uint8
memcpy(&voice_state, data + len_processed, sizeof(uint8_t));
len_processed += sizeof(uint8_t);
shared_state->voice_state = group_voice_state_from_int(voice_state);
shared_state->privacy_state = group_privacy_state_from_int(privacy_state);
group_voice_state_from_int(voice_state, &shared_state->voice_state);
group_privacy_state_from_int(privacy_state, &shared_state->privacy_state);
return len_processed;
}
@ -7434,6 +7430,9 @@ static int create_new_group(GC_Session *c, const uint8_t *nick, size_t nick_leng
return -1;
}
init_gc_shared_state(chat, privacy_state);
init_gc_moderation(chat);
if (!init_gc_tcp_connection(c, chat)) {
group_delete(c, chat);
return -1;
@ -7454,9 +7453,6 @@ static int create_new_group(GC_Session *c, const uint8_t *nick, size_t nick_leng
self_gc_set_confirmed(chat, true);
self_gc_set_ext_public_key(chat, chat->self_public_key);
init_gc_shared_state(chat, privacy_state);
init_gc_moderation(chat);
return group_number;
}
@ -8182,7 +8178,7 @@ GC_Session *new_dht_groupchats(Messenger *m)
return c;
}
static void group_cleanup(GC_Session *c, GC_Chat *chat)
static void group_cleanup(const GC_Session *c, GC_Chat *chat)
{
kill_group_friend_connection(c, chat);
@ -8496,4 +8492,3 @@ int gc_add_peers_from_announces(GC_Chat *chat, const GC_Announce *announces, uin
return added_peers;
}
#endif // VANILLA_NACL

6
external/toxcore/c-toxcore/toxcore/group_connection.c vendored
View File

@ -22,8 +22,6 @@
#include "mono_time.h"
#include "util.h"
#ifndef VANILLA_NACL
/** Seconds since last direct UDP packet was received before the connection is considered dead */
#define GCC_UDP_DIRECT_TIMEOUT (GC_PING_TIMEOUT + 4)
@ -211,7 +209,7 @@ bool gcc_send_lossless_packet_fragments(const GC_Chat *chat, GC_Connection *gcon
const uint16_t end_idx = gcc_get_array_index(gconn->send_message_id);
for (uint16_t i = start_idx; i != end_idx; i = (i + 1) % GCC_BUFFER_SIZE) {
GC_Message_Array_Entry *entry = &gconn->send_array[i];
const GC_Message_Array_Entry *entry = &gconn->send_array[i];
if (array_entry_is_empty(entry)) {
LOGGER_FATAL(chat->log, "array entry for packet chunk is empty");
@ -704,5 +702,3 @@ void gcc_cleanup(const GC_Chat *chat)
gcc_peer_cleanup(gconn);
}
}
#endif // VANILLA_NACL

3
external/toxcore/c-toxcore/toxcore/group_onion_announce.c vendored
View File

@ -66,8 +66,6 @@ void gca_onion_init(GC_Announces_List *group_announce, Onion_Announce *onion_a)
group_announce);
}
#ifndef VANILLA_NACL
int create_gca_announce_request(
const Random *rng, uint8_t *packet, uint16_t max_packet_length, const uint8_t *dest_client_id,
const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *ping_id,
@ -112,4 +110,3 @@ int create_gca_announce_request(
return full_length;
}
#endif // VANILLA_NACL

55
external/toxcore/c-toxcore/toxcore/group_pack.c vendored
View File

@ -18,29 +18,48 @@
#include "ccompat.h"
#include "util.h"
Group_Privacy_State group_privacy_state_from_int(uint8_t value)
bool group_privacy_state_from_int(uint8_t value, Group_Privacy_State *out)
{
switch (value) {
case 0:
return GI_PUBLIC;
case 1:
return GI_PRIVATE;
default:
return GI_PUBLIC;
case GI_PUBLIC: {
*out = GI_PUBLIC;
return true;
}
case GI_PRIVATE: {
*out = GI_PRIVATE;
return true;
}
default: {
*out = GI_PUBLIC;
return false;
}
}
}
Group_Voice_State group_voice_state_from_int(uint8_t value)
bool group_voice_state_from_int(uint8_t value, Group_Voice_State *out)
{
switch (value) {
case 0:
return GV_ALL;
case 1:
return GV_MODS;
case 2:
return GV_FOUNDER;
default:
return GV_ALL;
case GV_ALL: {
*out = GV_ALL;
return true;
}
case GV_MODS: {
*out = GV_MODS;
return true;
}
case GV_FOUNDER: {
*out = GV_FOUNDER;
return true;
}
default: {
*out = GV_ALL;
return false;
}
}
}
@ -69,8 +88,8 @@ static bool load_unpack_state_values(GC_Chat *chat, Bin_Unpack *bu)
}
chat->connection_state = manually_disconnected ? CS_DISCONNECTED : CS_CONNECTING;
chat->shared_state.privacy_state = group_privacy_state_from_int(privacy_state);
chat->shared_state.voice_state = group_voice_state_from_int(voice_state);
group_privacy_state_from_int(privacy_state, &chat->shared_state.privacy_state);
group_voice_state_from_int(voice_state, &chat->shared_state.voice_state);
// we always load saved groups as private in case the group became private while we were offline.
// this will have no detrimental effect if the group is public, as the correct privacy

6
external/toxcore/c-toxcore/toxcore/group_pack.h vendored
View File

@ -32,7 +32,9 @@ void gc_save_pack_group(const GC_Chat *chat, Bin_Pack *bp);
non_null()
bool gc_load_unpack_group(GC_Chat *chat, Bin_Unpack *bu);
Group_Privacy_State group_privacy_state_from_int(uint8_t value);
Group_Voice_State group_voice_state_from_int(uint8_t value);
non_null()
bool group_privacy_state_from_int(uint8_t value, Group_Privacy_State *out);
non_null()
bool group_voice_state_from_int(uint8_t value, Group_Voice_State *out);
#endif // GROUP_PACK_H

3
external/toxcore/c-toxcore/toxcore/net_crypto.c vendored
View File

@ -219,10 +219,9 @@ static int create_cookie_request(const Net_Crypto *c, uint8_t *packet, const uin
uint64_t number, uint8_t *shared_key)
{
uint8_t plain[COOKIE_REQUEST_PLAIN_LENGTH];
uint8_t padding[CRYPTO_PUBLIC_KEY_SIZE] = {0};
memcpy(plain, c->self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
memcpy(plain + CRYPTO_PUBLIC_KEY_SIZE, padding, CRYPTO_PUBLIC_KEY_SIZE);
memset(plain + CRYPTO_PUBLIC_KEY_SIZE, 0, CRYPTO_PUBLIC_KEY_SIZE);
memcpy(plain + (CRYPTO_PUBLIC_KEY_SIZE * 2), &number, sizeof(uint64_t));
const uint8_t *tmp_shared_key = dht_get_shared_key_sent(c->dht, dht_public_key);
memcpy(shared_key, tmp_shared_key, CRYPTO_SHARED_KEY_SIZE);

46
external/toxcore/c-toxcore/toxcore/net_crypto.h vendored
View File

@ -43,29 +43,31 @@
/*** Messages. */
#define PACKET_ID_PADDING 0 // Denotes padding
#define PACKET_ID_REQUEST 1 // Used to request unreceived packets
#define PACKET_ID_KILL 2 // Used to kill connection
typedef enum Packet_Id {
PACKET_ID_PADDING = 0, // Denotes padding
PACKET_ID_REQUEST = 1, // Used to request unreceived packets
PACKET_ID_KILL = 2, // Used to kill connection
#define PACKET_ID_ONLINE 24
#define PACKET_ID_OFFLINE 25
#define PACKET_ID_NICKNAME 48
#define PACKET_ID_STATUSMESSAGE 49
#define PACKET_ID_USERSTATUS 50
#define PACKET_ID_TYPING 51
#define PACKET_ID_MESSAGE 64
#define PACKET_ID_ACTION 65 // PACKET_ID_MESSAGE + MESSAGE_ACTION
#define PACKET_ID_MSI 69 // Used by AV to setup calls and etc
#define PACKET_ID_FILE_SENDREQUEST 80
#define PACKET_ID_FILE_CONTROL 81
#define PACKET_ID_FILE_DATA 82
#define PACKET_ID_INVITE_GROUPCHAT 95
#define PACKET_ID_INVITE_CONFERENCE 96
#define PACKET_ID_ONLINE_PACKET 97
#define PACKET_ID_DIRECT_CONFERENCE 98
#define PACKET_ID_MESSAGE_CONFERENCE 99
#define PACKET_ID_REJOIN_CONFERENCE 100
#define PACKET_ID_LOSSY_CONFERENCE 199
PACKET_ID_ONLINE = 24,
PACKET_ID_OFFLINE = 25,
PACKET_ID_NICKNAME = 48,
PACKET_ID_STATUSMESSAGE = 49,
PACKET_ID_USERSTATUS = 50,
PACKET_ID_TYPING = 51,
PACKET_ID_MESSAGE = 64,
PACKET_ID_ACTION = 65, // PACKET_ID_MESSAGE + MESSAGE_ACTION
PACKET_ID_MSI = 69, // Used by AV to setup calls and etc
PACKET_ID_FILE_SENDREQUEST = 80,
PACKET_ID_FILE_CONTROL = 81,
PACKET_ID_FILE_DATA = 82,
PACKET_ID_INVITE_GROUPCHAT = 95,
PACKET_ID_INVITE_CONFERENCE = 96,
PACKET_ID_ONLINE_PACKET = 97,
PACKET_ID_DIRECT_CONFERENCE = 98,
PACKET_ID_MESSAGE_CONFERENCE = 99,
PACKET_ID_REJOIN_CONFERENCE = 100,
PACKET_ID_LOSSY_CONFERENCE = 199,
} Packet_Id;
/** Maximum size of receiving and sending packet buffers. */
#define CRYPTO_PACKET_BUFFER_SIZE 32768 // Must be a power of 2

27
external/toxcore/c-toxcore/toxcore/network.c vendored
View File

@ -21,7 +21,7 @@
#define _XOPEN_SOURCE 700
#endif
#if defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_WINXP
#if defined(_WIN32) && defined(_WIN32_WINNT) && _WIN32_WINNT >= _WIN32_WINNT_WINXP
#undef _WIN32_WINNT
#define _WIN32_WINNT 0x501
#endif
@ -87,11 +87,6 @@
#include <stdlib.h>
#include <string.h>
#ifndef VANILLA_NACL
// Used for sodium_init()
#include <sodium.h>
#endif
#include "ccompat.h"
#include "logger.h"
#include "mono_time.h"
@ -361,13 +356,9 @@ IP4 get_ip4_loopback(void)
IP6 get_ip6_loopback(void)
{
IP6 loopback;
#ifdef ESP_PLATFORM
loopback = empty_ip_port.ip.ip.v6;
/* in6addr_loopback isn't available everywhere, so we do it ourselves. */
IP6 loopback = empty_ip_port.ip.ip.v6;
loopback.uint8[15] = 1;
#else
get_ip6(&loopback, &in6addr_loopback);
#endif
return loopback;
}
@ -565,7 +556,7 @@ non_null()
static int sys_getsockopt(void *obj, int sock, int level, int optname, void *optval, size_t *optlen)
{
socklen_t len = *optlen;
const int ret = getsockopt(sock, level, optname, optval, &len);
const int ret = getsockopt(sock, level, optname, (char *)optval, &len);
*optlen = len;
return ret;
}
@ -573,7 +564,7 @@ static int sys_getsockopt(void *obj, int sock, int level, int optname, void *opt
non_null()
static int sys_setsockopt(void *obj, int sock, int level, int optname, const void *optval, size_t optlen)
{
return setsockopt(sock, level, optname, optval, optlen);
return setsockopt(sock, level, optname, (const char *)optval, optlen);
}
static const Network_Funcs system_network_funcs = {
@ -1340,8 +1331,8 @@ Networking_Core *new_networking_ex(
Ip_Ntoa ip_str;
int neterror = net_error();
char *strerror = net_new_strerror(neterror);
LOGGER_ERROR(log, "failed to bind socket: %d, %s IP: %s port_from: %u port_to: %u", neterror, strerror,
net_ip_ntoa(ip, &ip_str), port_from, port_to);
LOGGER_ERROR(log, "failed to bind socket: %d, %s IP: %s port_from: %u port_to: %u",
neterror, strerror, net_ip_ntoa(ip, &ip_str), port_from, port_to);
net_kill_strerror(strerror);
kill_networking(temp);
@ -1769,6 +1760,8 @@ bool net_connect(const Memory *mem, const Logger *log, Socket sock, const IP_Por
int32_t net_getipport(const Memory *mem, const char *node, IP_Port **res, int tox_type)
{
assert(node != nullptr);
// Try parsing as IP address first.
IP_Port parsed = {{{0}}};
// Initialise to nullptr. In error paths, at least we initialise the out
@ -2031,7 +2024,7 @@ char *net_new_strerror(int error)
return str;
}
#else
#ifdef _GNU_SOURCE
#if defined(_GNU_SOURCE) && defined(__GLIBC__)
non_null()
static const char *net_strerror_r(int error, char *tmp, size_t tmp_size)
{

53
external/toxcore/c-toxcore/toxcore/network.h vendored
View File

@ -97,56 +97,6 @@ Family net_family_tox_tcp_ipv6(void);
#define MAX_UDP_PACKET_SIZE 2048
#ifdef USE_TEST_NETWORK
typedef enum Net_Packet_Type {
NET_PACKET_PING_REQUEST = 0x05, /* Ping request packet ID. */
NET_PACKET_PING_RESPONSE = 0x06, /* Ping response packet ID. */
NET_PACKET_GET_NODES = 0x07, /* Get nodes request packet ID. */
NET_PACKET_SEND_NODES_IPV6 = 0x08, /* Send nodes response packet ID for other addresses. */
NET_PACKET_COOKIE_REQUEST = 0x1c, /* Cookie request packet */
NET_PACKET_COOKIE_RESPONSE = 0x1d, /* Cookie response packet */
NET_PACKET_CRYPTO_HS = 0x1e, /* Crypto handshake packet */
NET_PACKET_CRYPTO_DATA = 0x1f, /* Crypto data packet */
NET_PACKET_CRYPTO = 0x24, /* Encrypted data packet ID. */
NET_PACKET_LAN_DISCOVERY = 0x25, /* LAN discovery packet ID. */
NET_PACKET_GC_HANDSHAKE = 0x62, /* Group chat handshake packet ID */
NET_PACKET_GC_LOSSLESS = 0x63, /* Group chat lossless packet ID */
NET_PACKET_GC_LOSSY = 0x64, /* Group chat lossy packet ID */
/* See: `docs/Prevent_Tracking.txt` and `onion.{c,h}` */
NET_PACKET_ONION_SEND_INITIAL = 0x8f,
NET_PACKET_ONION_SEND_1 = 0x90,
NET_PACKET_ONION_SEND_2 = 0x91,
NET_PACKET_ANNOUNCE_REQUEST = 0x92,
NET_PACKET_ANNOUNCE_RESPONSE = 0x93,
NET_PACKET_ONION_DATA_REQUEST = 0x94,
NET_PACKET_ONION_DATA_RESPONSE = 0x95,
NET_PACKET_ANNOUNCE_REQUEST_OLD = 0x96, /* TODO: DEPRECATE */
NET_PACKET_ANNOUNCE_RESPONSE_OLD = 0x97, /* TODO: DEPRECATE */
NET_PACKET_ONION_RECV_3 = 0x9b,
NET_PACKET_ONION_RECV_2 = 0x9c,
NET_PACKET_ONION_RECV_1 = 0x9d,
NET_PACKET_FORWARD_REQUEST = 0x9e,
NET_PACKET_FORWARDING = 0x9f,
NET_PACKET_FORWARD_REPLY = 0xa0,
NET_PACKET_DATA_SEARCH_REQUEST = 0xa1,
NET_PACKET_DATA_SEARCH_RESPONSE = 0xa2,
NET_PACKET_DATA_RETRIEVE_REQUEST = 0xa3,
NET_PACKET_DATA_RETRIEVE_RESPONSE = 0xa4,
NET_PACKET_STORE_ANNOUNCE_REQUEST = 0xa5,
NET_PACKET_STORE_ANNOUNCE_RESPONSE = 0xa6,
BOOTSTRAP_INFO_PACKET_ID = 0xf1, /* Only used for bootstrap nodes */
NET_PACKET_MAX = 0xff, /* This type must remain within a single uint8. */
} Net_Packet_Type;
#else
typedef enum Net_Packet_Type {
NET_PACKET_PING_REQUEST = 0x00, /* Ping request packet ID. */
NET_PACKET_PING_RESPONSE = 0x01, /* Ping response packet ID. */
@ -195,7 +145,6 @@ typedef enum Net_Packet_Type {
NET_PACKET_MAX = 0xff, /* This type must remain within a single uint8. */
} Net_Packet_Type;
#endif // test network
#define TOX_PORTRANGE_FROM 33445
@ -591,7 +540,7 @@ char *net_new_strerror(int error);
* It's valid to pass NULL as the argument, the function does nothing in this
* case.
*/
non_null()
nullable(1)
void net_kill_strerror(char *strerror);
/** @brief Initialize networking.

1
external/toxcore/c-toxcore/toxcore/onion.c vendored
View File

@ -735,6 +735,7 @@ Onion *new_onion(const Logger *log, const Memory *mem, const Mono_Time *mono_tim
if (onion->shared_keys_1 == nullptr ||
onion->shared_keys_2 == nullptr ||
onion->shared_keys_3 == nullptr) {
// cppcheck-suppress mismatchAllocDealloc
kill_onion(onion);
return nullptr;
}

1
external/toxcore/c-toxcore/toxcore/onion_announce.c vendored
View File

@ -669,6 +669,7 @@ Onion_Announce *new_onion_announce(const Logger *log, const Memory *mem, const R
onion_a->shared_keys_recv = shared_key_cache_new(log, mono_time, mem, dht_get_self_secret_key(dht), KEYS_TIMEOUT, MAX_KEYS_PER_SLOT);
if (onion_a->shared_keys_recv == nullptr) {
// cppcheck-suppress mismatchAllocDealloc
kill_onion_announce(onion_a);
return nullptr;
}

7
external/toxcore/c-toxcore/toxcore/onion_client.c vendored
View File

@ -671,7 +671,6 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, con
onion_friend->temp_secret_key, ping_id, onion_friend->real_public_key,
zero_ping_id, sendback);
} else { // contact is a gc
#ifndef VANILLA_NACL
onion_friend->is_groupchat = true;
len = create_gca_announce_request(
@ -679,9 +678,6 @@ static int client_send_announce_request(Onion_Client *onion_c, uint32_t num, con
onion_friend->temp_secret_key, ping_id, onion_friend->real_public_key,
zero_ping_id, sendback, onion_friend->gc_data,
onion_friend->gc_data_length);
#else
return -1;
#endif // VANILLA_NACL
}
}
@ -1996,6 +1992,9 @@ static void do_announce(Onion_Client *onion_c)
// Don't send announces to the same node twice. If we don't have many nodes,
// the random selection below may have overlaps. This ensures that we deduplicate
// nodes before sending packets to save some bandwidth.
//
// TODO(iphydf): Figure out why on esp32, this is necessary for the onion
// connection to succeed. This is an optimisation and shouldn't be necessary.
const uint8_t *targets[MAX_ONION_CLIENTS_ANNOUNCE / 2];
unsigned int targets_count = 0;

35
external/toxcore/c-toxcore/toxcore/tox.c vendored
View File

@ -362,7 +362,6 @@ static void tox_friend_lossless_packet_handler(Messenger *m, uint32_t friend_num
}
}
#ifndef VANILLA_NACL
non_null(1, 4) nullable(6)
static void tox_group_peer_name_handler(const Messenger *m, uint32_t group_number, uint32_t peer_id,
const uint8_t *name, size_t length, void *user_data)
@ -573,7 +572,6 @@ static void tox_group_moderation_handler(const Messenger *m, uint32_t group_numb
tox_data->user_data);
}
}
#endif
bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch)
{
@ -637,6 +635,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
switch (err) {
case TOX_ERR_OPTIONS_NEW_OK: {
assert(default_options != nullptr);
break;
}
@ -660,6 +659,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
if (sys->rng == nullptr || sys->ns == nullptr || sys->mem == nullptr) {
// TODO(iphydf): Not quite right, but similar.
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
tox_options_free(default_options);
return nullptr;
}
@ -717,6 +717,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
if (tox == nullptr) {
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
tox_options_free(default_options);
return nullptr;
}
@ -743,8 +744,8 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
default: {
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_TYPE);
tox_options_free(default_options);
mem_delete(sys->mem, tox);
tox_options_free(default_options);
return nullptr;
}
}
@ -754,8 +755,8 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
if (m_options.proxy_info.proxy_type != TCP_PROXY_NONE) {
if (tox_options_get_proxy_port(opts) == 0) {
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_PORT);
tox_options_free(default_options);
mem_delete(sys->mem, tox);
tox_options_free(default_options);
return nullptr;
}
@ -771,8 +772,8 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
|| !addr_resolve_or_parse_ip(tox->sys.ns, proxy_host, &m_options.proxy_info.ip_port.ip, nullptr)) {
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_HOST);
// TODO(irungentoo): TOX_ERR_NEW_PROXY_NOT_FOUND if domain.
tox_options_free(default_options);
mem_delete(sys->mem, tox);
tox_options_free(default_options);
return nullptr;
}
@ -783,8 +784,8 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
if (tox->mono_time == nullptr) {
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
tox_options_free(default_options);
mem_delete(sys->mem, tox);
tox_options_free(default_options);
return nullptr;
}
@ -793,8 +794,8 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
if (tox->mutex == nullptr) {
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
tox_options_free(default_options);
mem_delete(sys->mem, tox);
tox_options_free(default_options);
return nullptr;
}
@ -828,7 +829,6 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
}
mono_time_free(tox->sys.mem, tox->mono_time);
tox_options_free(default_options);
tox_unlock(tox);
if (tox->mutex != nullptr) {
@ -837,14 +837,16 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
mem_delete(sys->mem, tox->mutex);
mem_delete(sys->mem, tox);
tox_options_free(default_options);
return nullptr;
}
if (new_groupchats(tox->mono_time, tox->m) == nullptr) {
tox->m->conferences_object = new_groupchats(tox->mono_time, tox->m);
if (tox->m->conferences_object == nullptr) {
kill_messenger(tox->m);
mono_time_free(tox->sys.mem, tox->mono_time);
tox_options_free(default_options);
tox_unlock(tox);
if (tox->mutex != nullptr) {
@ -855,6 +857,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
mem_delete(sys->mem, tox);
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);
tox_options_free(default_options);
return nullptr;
}
@ -864,7 +867,6 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
kill_messenger(tox->m);
mono_time_free(tox->sys.mem, tox->mono_time);
tox_options_free(default_options);
tox_unlock(tox);
if (tox->mutex != nullptr) {
@ -875,6 +877,7 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
mem_delete(sys->mem, tox);
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);
tox_options_free(default_options);
return nullptr;
}
@ -905,7 +908,6 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
custom_lossy_packet_registerhandler(tox->m, tox_friend_lossy_packet_handler);
custom_lossless_packet_registerhandler(tox->m, tox_friend_lossless_packet_handler);
#ifndef VANILLA_NACL
m_callback_group_invite(tox->m, tox_group_invite_handler);
gc_callback_message(tox->m, tox_group_message_handler);
gc_callback_private_message(tox->m, tox_group_private_message_handler);
@ -924,14 +926,12 @@ Tox *tox_new(const struct Tox_Options *options, Tox_Err_New *error)
gc_callback_self_join(tox->m, tox_group_self_join_handler);
gc_callback_rejected(tox->m, tox_group_join_fail_handler);
gc_callback_voice_state(tox->m, tox_group_voice_state_handler);
#endif
tox_options_free(default_options);
tox_unlock(tox);
SET_ERROR_PARAMETER(error, TOX_ERR_NEW_OK);
tox_options_free(default_options);
return tox;
}
@ -2725,6 +2725,7 @@ static void set_custom_packet_error(int ret, Tox_Err_Friend_Custom_Packet *error
}
}
// cppcheck-suppress constParameterPointer
bool tox_friend_send_lossy_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
Tox_Err_Friend_Custom_Packet *error)
{
@ -2764,6 +2765,7 @@ void tox_callback_friend_lossy_packet(Tox *tox, tox_friend_lossy_packet_cb *call
}
}
// cppcheck-suppress constParameterPointer
bool tox_friend_send_lossless_packet(Tox *tox, uint32_t friend_number, const uint8_t *data, size_t length,
Tox_Err_Friend_Custom_Packet *error)
{
@ -2843,7 +2845,6 @@ uint16_t tox_self_get_tcp_port(const Tox *tox, Tox_Err_Get_Port *error)
/* GROUPCHAT FUNCTIONS */
#ifndef VANILLA_NACL
void tox_callback_group_invite(Tox *tox, tox_group_invite_cb *callback)
{
assert(tox != nullptr);
@ -4595,8 +4596,6 @@ bool tox_group_mod_kick_peer(const Tox *tox, uint32_t group_number, uint32_t pee
return false;
}
#endif /* VANILLA_NACL */
const Tox_System *tox_get_system(Tox *tox)
{
assert(tox != nullptr);

674
external/toxcore/c-toxcore/toxcore/tox_dispatch.c vendored
View File

@ -7,6 +7,8 @@
#include <stdlib.h>
#include "ccompat.h"
#include "events/events_alloc.h"
#include "tox_event.h"
struct Tox_Dispatch {
tox_events_conference_connected_cb *conference_connected_callback;
@ -274,591 +276,333 @@ void tox_events_callback_group_moderation(
dispatch->group_moderation_callback = callback;
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_conference_connected(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
non_null(1, 2, 3) nullable(4)
static void tox_dispatch_invoke_event(const Tox_Dispatch *dispatch, const Tox_Event *event, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_conference_connected_size(events);
switch (event->type) {
case TOX_EVENT_CONFERENCE_CONNECTED: {
if (dispatch->conference_connected_callback != nullptr) {
dispatch->conference_connected_callback(tox, event->data.conference_connected, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->conference_connected_callback != nullptr) {
dispatch->conference_connected_callback(
tox, tox_events_get_conference_connected(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_conference_invite(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_conference_invite_size(events);
case TOX_EVENT_CONFERENCE_INVITE: {
if (dispatch->conference_invite_callback != nullptr) {
dispatch->conference_invite_callback(tox, event->data.conference_invite, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->conference_invite_callback != nullptr) {
dispatch->conference_invite_callback(
tox, tox_events_get_conference_invite(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_conference_message(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_conference_message_size(events);
case TOX_EVENT_CONFERENCE_MESSAGE: {
if (dispatch->conference_message_callback != nullptr) {
dispatch->conference_message_callback(tox, event->data.conference_message, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->conference_message_callback != nullptr) {
dispatch->conference_message_callback(
tox, tox_events_get_conference_message(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_conference_peer_list_changed(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_conference_peer_list_changed_size(events);
case TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED: {
if (dispatch->conference_peer_list_changed_callback != nullptr) {
dispatch->conference_peer_list_changed_callback(tox, event->data.conference_peer_list_changed, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->conference_peer_list_changed_callback != nullptr) {
dispatch->conference_peer_list_changed_callback(
tox, tox_events_get_conference_peer_list_changed(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_conference_peer_name(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_conference_peer_name_size(events);
case TOX_EVENT_CONFERENCE_PEER_NAME: {
if (dispatch->conference_peer_name_callback != nullptr) {
dispatch->conference_peer_name_callback(tox, event->data.conference_peer_name, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->conference_peer_name_callback != nullptr) {
dispatch->conference_peer_name_callback(
tox, tox_events_get_conference_peer_name(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_conference_title(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_conference_title_size(events);
case TOX_EVENT_CONFERENCE_TITLE: {
if (dispatch->conference_title_callback != nullptr) {
dispatch->conference_title_callback(tox, event->data.conference_title, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->conference_title_callback != nullptr) {
dispatch->conference_title_callback(
tox, tox_events_get_conference_title(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_file_chunk_request(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_file_chunk_request_size(events);
case TOX_EVENT_FILE_CHUNK_REQUEST: {
if (dispatch->file_chunk_request_callback != nullptr) {
dispatch->file_chunk_request_callback(tox, event->data.file_chunk_request, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->file_chunk_request_callback != nullptr) {
dispatch->file_chunk_request_callback(
tox, tox_events_get_file_chunk_request(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_file_recv(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_file_recv_size(events);
case TOX_EVENT_FILE_RECV_CHUNK: {
if (dispatch->file_recv_chunk_callback != nullptr) {
dispatch->file_recv_chunk_callback(tox, event->data.file_recv_chunk, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->file_recv_callback != nullptr) {
dispatch->file_recv_callback(
tox, tox_events_get_file_recv(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_file_recv_chunk(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_file_recv_chunk_size(events);
case TOX_EVENT_FILE_RECV_CONTROL: {
if (dispatch->file_recv_control_callback != nullptr) {
dispatch->file_recv_control_callback(tox, event->data.file_recv_control, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->file_recv_chunk_callback != nullptr) {
dispatch->file_recv_chunk_callback(
tox, tox_events_get_file_recv_chunk(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_file_recv_control(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_file_recv_control_size(events);
case TOX_EVENT_FILE_RECV: {
if (dispatch->file_recv_callback != nullptr) {
dispatch->file_recv_callback(tox, event->data.file_recv, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->file_recv_control_callback != nullptr) {
dispatch->file_recv_control_callback(
tox, tox_events_get_file_recv_control(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_connection_status(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_connection_status_size(events);
case TOX_EVENT_FRIEND_CONNECTION_STATUS: {
if (dispatch->friend_connection_status_callback != nullptr) {
dispatch->friend_connection_status_callback(tox, event->data.friend_connection_status, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_connection_status_callback != nullptr) {
dispatch->friend_connection_status_callback(
tox, tox_events_get_friend_connection_status(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_lossless_packet(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_lossless_packet_size(events);
case TOX_EVENT_FRIEND_LOSSLESS_PACKET: {
if (dispatch->friend_lossless_packet_callback != nullptr) {
dispatch->friend_lossless_packet_callback(tox, event->data.friend_lossless_packet, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_lossless_packet_callback != nullptr) {
dispatch->friend_lossless_packet_callback(
tox, tox_events_get_friend_lossless_packet(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_lossy_packet(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_lossy_packet_size(events);
case TOX_EVENT_FRIEND_LOSSY_PACKET: {
if (dispatch->friend_lossy_packet_callback != nullptr) {
dispatch->friend_lossy_packet_callback(tox, event->data.friend_lossy_packet, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_lossy_packet_callback != nullptr) {
dispatch->friend_lossy_packet_callback(
tox, tox_events_get_friend_lossy_packet(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_message(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_message_size(events);
case TOX_EVENT_FRIEND_MESSAGE: {
if (dispatch->friend_message_callback != nullptr) {
dispatch->friend_message_callback(tox, event->data.friend_message, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_message_callback != nullptr) {
dispatch->friend_message_callback(
tox, tox_events_get_friend_message(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_name(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_name_size(events);
case TOX_EVENT_FRIEND_NAME: {
if (dispatch->friend_name_callback != nullptr) {
dispatch->friend_name_callback(tox, event->data.friend_name, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_name_callback != nullptr) {
dispatch->friend_name_callback(
tox, tox_events_get_friend_name(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_read_receipt(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_read_receipt_size(events);
case TOX_EVENT_FRIEND_READ_RECEIPT: {
if (dispatch->friend_read_receipt_callback != nullptr) {
dispatch->friend_read_receipt_callback(tox, event->data.friend_read_receipt, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_read_receipt_callback != nullptr) {
dispatch->friend_read_receipt_callback(
tox, tox_events_get_friend_read_receipt(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_request(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_request_size(events);
case TOX_EVENT_FRIEND_REQUEST: {
if (dispatch->friend_request_callback != nullptr) {
dispatch->friend_request_callback(tox, event->data.friend_request, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_request_callback != nullptr) {
dispatch->friend_request_callback(
tox, tox_events_get_friend_request(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_status(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_status_size(events);
case TOX_EVENT_FRIEND_STATUS: {
if (dispatch->friend_status_callback != nullptr) {
dispatch->friend_status_callback(tox, event->data.friend_status, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_status_callback != nullptr) {
dispatch->friend_status_callback(
tox, tox_events_get_friend_status(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_status_message(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_status_message_size(events);
case TOX_EVENT_FRIEND_STATUS_MESSAGE: {
if (dispatch->friend_status_message_callback != nullptr) {
dispatch->friend_status_message_callback(tox, event->data.friend_status_message, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_status_message_callback != nullptr) {
dispatch->friend_status_message_callback(
tox, tox_events_get_friend_status_message(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_friend_typing(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_friend_typing_size(events);
case TOX_EVENT_FRIEND_TYPING: {
if (dispatch->friend_typing_callback != nullptr) {
dispatch->friend_typing_callback(tox, event->data.friend_typing, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->friend_typing_callback != nullptr) {
dispatch->friend_typing_callback(
tox, tox_events_get_friend_typing(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_self_connection_status(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_self_connection_status_size(events);
case TOX_EVENT_SELF_CONNECTION_STATUS: {
if (dispatch->self_connection_status_callback != nullptr) {
dispatch->self_connection_status_callback(tox, event->data.self_connection_status, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->self_connection_status_callback != nullptr) {
dispatch->self_connection_status_callback(
tox, tox_events_get_self_connection_status(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_peer_name(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_peer_name_size(events);
case TOX_EVENT_GROUP_PEER_NAME: {
if (dispatch->group_peer_name_callback != nullptr) {
dispatch->group_peer_name_callback(tox, event->data.group_peer_name, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_peer_name_callback != nullptr) {
dispatch->group_peer_name_callback(
tox, tox_events_get_group_peer_name(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_peer_status(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_peer_status_size(events);
case TOX_EVENT_GROUP_PEER_STATUS: {
if (dispatch->group_peer_status_callback != nullptr) {
dispatch->group_peer_status_callback(tox, event->data.group_peer_status, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_peer_status_callback != nullptr) {
dispatch->group_peer_status_callback(
tox, tox_events_get_group_peer_status(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_topic(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_topic_size(events);
case TOX_EVENT_GROUP_TOPIC: {
if (dispatch->group_topic_callback != nullptr) {
dispatch->group_topic_callback(tox, event->data.group_topic, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_topic_callback != nullptr) {
dispatch->group_topic_callback(
tox, tox_events_get_group_topic(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_privacy_state(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_privacy_state_size(events);
case TOX_EVENT_GROUP_PRIVACY_STATE: {
if (dispatch->group_privacy_state_callback != nullptr) {
dispatch->group_privacy_state_callback(tox, event->data.group_privacy_state, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_privacy_state_callback != nullptr) {
dispatch->group_privacy_state_callback(
tox, tox_events_get_group_privacy_state(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_voice_state(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_voice_state_size(events);
case TOX_EVENT_GROUP_VOICE_STATE: {
if (dispatch->group_voice_state_callback != nullptr) {
dispatch->group_voice_state_callback(tox, event->data.group_voice_state, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_voice_state_callback != nullptr) {
dispatch->group_voice_state_callback(
tox, tox_events_get_group_voice_state(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_topic_lock(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_topic_lock_size(events);
case TOX_EVENT_GROUP_TOPIC_LOCK: {
if (dispatch->group_topic_lock_callback != nullptr) {
dispatch->group_topic_lock_callback(tox, event->data.group_topic_lock, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_topic_lock_callback != nullptr) {
dispatch->group_topic_lock_callback(
tox, tox_events_get_group_topic_lock(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_peer_limit(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_peer_limit_size(events);
case TOX_EVENT_GROUP_PEER_LIMIT: {
if (dispatch->group_peer_limit_callback != nullptr) {
dispatch->group_peer_limit_callback(tox, event->data.group_peer_limit, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_peer_limit_callback != nullptr) {
dispatch->group_peer_limit_callback(
tox, tox_events_get_group_peer_limit(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_password(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_password_size(events);
case TOX_EVENT_GROUP_PASSWORD: {
if (dispatch->group_password_callback != nullptr) {
dispatch->group_password_callback(tox, event->data.group_password, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_password_callback != nullptr) {
dispatch->group_password_callback(
tox, tox_events_get_group_password(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_message(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_message_size(events);
case TOX_EVENT_GROUP_MESSAGE: {
if (dispatch->group_message_callback != nullptr) {
dispatch->group_message_callback(tox, event->data.group_message, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_message_callback != nullptr) {
dispatch->group_message_callback(
tox, tox_events_get_group_message(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_private_message(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_private_message_size(events);
case TOX_EVENT_GROUP_PRIVATE_MESSAGE: {
if (dispatch->group_private_message_callback != nullptr) {
dispatch->group_private_message_callback(tox, event->data.group_private_message, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_private_message_callback != nullptr) {
dispatch->group_private_message_callback(
tox, tox_events_get_group_private_message(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_custom_packet(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_custom_packet_size(events);
case TOX_EVENT_GROUP_CUSTOM_PACKET: {
if (dispatch->group_custom_packet_callback != nullptr) {
dispatch->group_custom_packet_callback(tox, event->data.group_custom_packet, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_custom_packet_callback != nullptr) {
dispatch->group_custom_packet_callback(
tox, tox_events_get_group_custom_packet(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_custom_private_packet(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_custom_private_packet_size(events);
case TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET: {
if (dispatch->group_custom_private_packet_callback != nullptr) {
dispatch->group_custom_private_packet_callback(tox, event->data.group_custom_private_packet, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_custom_private_packet_callback != nullptr) {
dispatch->group_custom_private_packet_callback(
tox, tox_events_get_group_custom_private_packet(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_invite(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_invite_size(events);
case TOX_EVENT_GROUP_INVITE: {
if (dispatch->group_invite_callback != nullptr) {
dispatch->group_invite_callback(tox, event->data.group_invite, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_invite_callback != nullptr) {
dispatch->group_invite_callback(
tox, tox_events_get_group_invite(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_peer_join(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_peer_join_size(events);
case TOX_EVENT_GROUP_PEER_JOIN: {
if (dispatch->group_peer_join_callback != nullptr) {
dispatch->group_peer_join_callback(tox, event->data.group_peer_join, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_peer_join_callback != nullptr) {
dispatch->group_peer_join_callback(
tox, tox_events_get_group_peer_join(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_peer_exit(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_peer_exit_size(events);
case TOX_EVENT_GROUP_PEER_EXIT: {
if (dispatch->group_peer_exit_callback != nullptr) {
dispatch->group_peer_exit_callback(tox, event->data.group_peer_exit, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_peer_exit_callback != nullptr) {
dispatch->group_peer_exit_callback(
tox, tox_events_get_group_peer_exit(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_self_join(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_self_join_size(events);
case TOX_EVENT_GROUP_SELF_JOIN: {
if (dispatch->group_self_join_callback != nullptr) {
dispatch->group_self_join_callback(tox, event->data.group_self_join, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_self_join_callback != nullptr) {
dispatch->group_self_join_callback(
tox, tox_events_get_group_self_join(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_join_fail(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_join_fail_size(events);
case TOX_EVENT_GROUP_JOIN_FAIL: {
if (dispatch->group_join_fail_callback != nullptr) {
dispatch->group_join_fail_callback(tox, event->data.group_join_fail, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_join_fail_callback != nullptr) {
dispatch->group_join_fail_callback(
tox, tox_events_get_group_join_fail(events, i), user_data);
break;
}
}
}
non_null(1, 3) nullable(2, 4)
static void tox_dispatch_invoke_group_moderation(
const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
const uint32_t size = tox_events_get_group_moderation_size(events);
case TOX_EVENT_GROUP_MODERATION: {
if (dispatch->group_moderation_callback != nullptr) {
dispatch->group_moderation_callback(tox, event->data.group_moderation, user_data);
}
for (uint32_t i = 0; i < size; ++i) {
if (dispatch->group_moderation_callback != nullptr) {
dispatch->group_moderation_callback(
tox, tox_events_get_group_moderation(events, i), user_data);
break;
}
case TOX_EVENT_INVALID: {
break;
}
}
}
void tox_dispatch_invoke(const Tox_Dispatch *dispatch, const Tox_Events *events, Tox *tox, void *user_data)
{
tox_dispatch_invoke_conference_connected(dispatch, events, tox, user_data);
tox_dispatch_invoke_conference_invite(dispatch, events, tox, user_data);
tox_dispatch_invoke_conference_message(dispatch, events, tox, user_data);
tox_dispatch_invoke_conference_peer_list_changed(dispatch, events, tox, user_data);
tox_dispatch_invoke_conference_peer_name(dispatch, events, tox, user_data);
tox_dispatch_invoke_conference_title(dispatch, events, tox, user_data);
tox_dispatch_invoke_file_chunk_request(dispatch, events, tox, user_data);
tox_dispatch_invoke_file_recv(dispatch, events, tox, user_data);
tox_dispatch_invoke_file_recv_chunk(dispatch, events, tox, user_data);
tox_dispatch_invoke_file_recv_control(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_connection_status(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_lossless_packet(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_lossy_packet(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_message(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_name(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_read_receipt(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_request(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_status(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_status_message(dispatch, events, tox, user_data);
tox_dispatch_invoke_friend_typing(dispatch, events, tox, user_data);
tox_dispatch_invoke_self_connection_status(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_peer_name(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_peer_status(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_topic(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_privacy_state(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_voice_state(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_topic_lock(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_peer_limit(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_password(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_message(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_private_message(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_custom_packet(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_custom_private_packet(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_invite(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_peer_join(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_peer_exit(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_self_join(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_join_fail(dispatch, events, tox, user_data);
tox_dispatch_invoke_group_moderation(dispatch, events, tox, user_data);
const uint32_t size = tox_events_get_size(events);
for (uint32_t i = 0; i < size; ++i) {
const Tox_Event *event = &events->events[i];
tox_dispatch_invoke_event(dispatch, event, tox, user_data);
}
}

1058
external/toxcore/c-toxcore/toxcore/tox_event.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

254
external/toxcore/c-toxcore/toxcore/tox_event.h vendored Normal file
View File

@ -0,0 +1,254 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2022 The TokTok team.
*/
#ifndef C_TOXCORE_TOXCORE_TOX_EVENT_H
#define C_TOXCORE_TOXCORE_TOX_EVENT_H
#include "attributes.h"
#include "bin_pack.h"
#include "bin_unpack.h"
#include "mem.h"
#include "tox_events.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef union Tox_Event_Data {
/**
* Opaque pointer just to check whether any value is set.
*/
void *value;
Tox_Event_Conference_Connected *conference_connected;
Tox_Event_Conference_Invite *conference_invite;
Tox_Event_Conference_Message *conference_message;
Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed;
Tox_Event_Conference_Peer_Name *conference_peer_name;
Tox_Event_Conference_Title *conference_title;
Tox_Event_File_Chunk_Request *file_chunk_request;
Tox_Event_File_Recv *file_recv;
Tox_Event_File_Recv_Chunk *file_recv_chunk;
Tox_Event_File_Recv_Control *file_recv_control;
Tox_Event_Friend_Connection_Status *friend_connection_status;
Tox_Event_Friend_Lossless_Packet *friend_lossless_packet;
Tox_Event_Friend_Lossy_Packet *friend_lossy_packet;
Tox_Event_Friend_Message *friend_message;
Tox_Event_Friend_Name *friend_name;
Tox_Event_Friend_Read_Receipt *friend_read_receipt;
Tox_Event_Friend_Request *friend_request;
Tox_Event_Friend_Status *friend_status;
Tox_Event_Friend_Status_Message *friend_status_message;
Tox_Event_Friend_Typing *friend_typing;
Tox_Event_Self_Connection_Status *self_connection_status;
Tox_Event_Group_Peer_Name *group_peer_name;
Tox_Event_Group_Peer_Status *group_peer_status;
Tox_Event_Group_Topic *group_topic;
Tox_Event_Group_Privacy_State *group_privacy_state;
Tox_Event_Group_Voice_State *group_voice_state;
Tox_Event_Group_Topic_Lock *group_topic_lock;
Tox_Event_Group_Peer_Limit *group_peer_limit;
Tox_Event_Group_Password *group_password;
Tox_Event_Group_Message *group_message;
Tox_Event_Group_Private_Message *group_private_message;
Tox_Event_Group_Custom_Packet *group_custom_packet;
Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet;
Tox_Event_Group_Invite *group_invite;
Tox_Event_Group_Peer_Join *group_peer_join;
Tox_Event_Group_Peer_Exit *group_peer_exit;
Tox_Event_Group_Self_Join *group_self_join;
Tox_Event_Group_Join_Fail *group_join_fail;
Tox_Event_Group_Moderation *group_moderation;
} Tox_Event_Data;
struct Tox_Event {
Tox_Event_Type type;
Tox_Event_Data data;
};
/**
* Constructor.
*/
non_null() bool tox_event_construct(Tox_Event *event, Tox_Event_Type type, const Memory *mem);
non_null() Tox_Event_Conference_Connected *tox_event_conference_connected_new(const Memory *mem);
non_null() Tox_Event_Conference_Invite *tox_event_conference_invite_new(const Memory *mem);
non_null() Tox_Event_Conference_Message *tox_event_conference_message_new(const Memory *mem);
non_null() Tox_Event_Conference_Peer_List_Changed *tox_event_conference_peer_list_changed_new(const Memory *mem);
non_null() Tox_Event_Conference_Peer_Name *tox_event_conference_peer_name_new(const Memory *mem);
non_null() Tox_Event_Conference_Title *tox_event_conference_title_new(const Memory *mem);
non_null() Tox_Event_File_Chunk_Request *tox_event_file_chunk_request_new(const Memory *mem);
non_null() Tox_Event_File_Recv_Chunk *tox_event_file_recv_chunk_new(const Memory *mem);
non_null() Tox_Event_File_Recv_Control *tox_event_file_recv_control_new(const Memory *mem);
non_null() Tox_Event_File_Recv *tox_event_file_recv_new(const Memory *mem);
non_null() Tox_Event_Friend_Connection_Status *tox_event_friend_connection_status_new(const Memory *mem);
non_null() Tox_Event_Friend_Lossless_Packet *tox_event_friend_lossless_packet_new(const Memory *mem);
non_null() Tox_Event_Friend_Lossy_Packet *tox_event_friend_lossy_packet_new(const Memory *mem);
non_null() Tox_Event_Friend_Message *tox_event_friend_message_new(const Memory *mem);
non_null() Tox_Event_Friend_Name *tox_event_friend_name_new(const Memory *mem);
non_null() Tox_Event_Friend_Read_Receipt *tox_event_friend_read_receipt_new(const Memory *mem);
non_null() Tox_Event_Friend_Request *tox_event_friend_request_new(const Memory *mem);
non_null() Tox_Event_Friend_Status_Message *tox_event_friend_status_message_new(const Memory *mem);
non_null() Tox_Event_Friend_Status *tox_event_friend_status_new(const Memory *mem);
non_null() Tox_Event_Friend_Typing *tox_event_friend_typing_new(const Memory *mem);
non_null() Tox_Event_Self_Connection_Status *tox_event_self_connection_status_new(const Memory *mem);
non_null() Tox_Event_Group_Peer_Name *tox_event_group_peer_name_new(const Memory *mem);
non_null() Tox_Event_Group_Peer_Status *tox_event_group_peer_status_new(const Memory *mem);
non_null() Tox_Event_Group_Topic *tox_event_group_topic_new(const Memory *mem);
non_null() Tox_Event_Group_Privacy_State *tox_event_group_privacy_state_new(const Memory *mem);
non_null() Tox_Event_Group_Voice_State *tox_event_group_voice_state_new(const Memory *mem);
non_null() Tox_Event_Group_Topic_Lock *tox_event_group_topic_lock_new(const Memory *mem);
non_null() Tox_Event_Group_Peer_Limit *tox_event_group_peer_limit_new(const Memory *mem);
non_null() Tox_Event_Group_Password *tox_event_group_password_new(const Memory *mem);
non_null() Tox_Event_Group_Message *tox_event_group_message_new(const Memory *mem);
non_null() Tox_Event_Group_Private_Message *tox_event_group_private_message_new(const Memory *mem);
non_null() Tox_Event_Group_Custom_Packet *tox_event_group_custom_packet_new(const Memory *mem);
non_null() Tox_Event_Group_Custom_Private_Packet *tox_event_group_custom_private_packet_new(const Memory *mem);
non_null() Tox_Event_Group_Invite *tox_event_group_invite_new(const Memory *mem);
non_null() Tox_Event_Group_Peer_Join *tox_event_group_peer_join_new(const Memory *mem);
non_null() Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_new(const Memory *mem);
non_null() Tox_Event_Group_Self_Join *tox_event_group_self_join_new(const Memory *mem);
non_null() Tox_Event_Group_Join_Fail *tox_event_group_join_fail_new(const Memory *mem);
non_null() Tox_Event_Group_Moderation *tox_event_group_moderation_new(const Memory *mem);
/**
* Destructor.
*/
non_null(2) nullable(1) void tox_event_destruct(Tox_Event *event, const Memory *mem);
non_null(2) nullable(1) void tox_event_conference_connected_free(Tox_Event_Conference_Connected *conference_connected, const Memory *mem);
non_null(2) nullable(1) void tox_event_conference_invite_free(Tox_Event_Conference_Invite *conference_invite, const Memory *mem);
non_null(2) nullable(1) void tox_event_conference_message_free(Tox_Event_Conference_Message *conference_message, const Memory *mem);
non_null(2) nullable(1) void tox_event_conference_peer_list_changed_free(Tox_Event_Conference_Peer_List_Changed *conference_peer_list_changed, const Memory *mem);
non_null(2) nullable(1) void tox_event_conference_peer_name_free(Tox_Event_Conference_Peer_Name *conference_peer_name, const Memory *mem);
non_null(2) nullable(1) void tox_event_conference_title_free(Tox_Event_Conference_Title *conference_title, const Memory *mem);
non_null(2) nullable(1) void tox_event_file_chunk_request_free(Tox_Event_File_Chunk_Request *file_chunk_request, const Memory *mem);
non_null(2) nullable(1) void tox_event_file_recv_chunk_free(Tox_Event_File_Recv_Chunk *file_recv_chunk, const Memory *mem);
non_null(2) nullable(1) void tox_event_file_recv_control_free(Tox_Event_File_Recv_Control *file_recv_control, const Memory *mem);
non_null(2) nullable(1) void tox_event_file_recv_free(Tox_Event_File_Recv *file_recv, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_connection_status_free(Tox_Event_Friend_Connection_Status *friend_connection_status, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_lossless_packet_free(Tox_Event_Friend_Lossless_Packet *friend_lossless_packet, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_lossy_packet_free(Tox_Event_Friend_Lossy_Packet *friend_lossy_packet, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_message_free(Tox_Event_Friend_Message *friend_message, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_name_free(Tox_Event_Friend_Name *friend_name, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_read_receipt_free(Tox_Event_Friend_Read_Receipt *friend_read_receipt, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_request_free(Tox_Event_Friend_Request *friend_request, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_status_message_free(Tox_Event_Friend_Status_Message *friend_status_message, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_status_free(Tox_Event_Friend_Status *friend_status, const Memory *mem);
non_null(2) nullable(1) void tox_event_friend_typing_free(Tox_Event_Friend_Typing *friend_typing, const Memory *mem);
non_null(2) nullable(1) void tox_event_self_connection_status_free(Tox_Event_Self_Connection_Status *self_connection_status, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_peer_name_free(Tox_Event_Group_Peer_Name *group_peer_name, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_peer_status_free(Tox_Event_Group_Peer_Status *group_peer_status, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_topic_free(Tox_Event_Group_Topic *group_topic, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_privacy_state_free(Tox_Event_Group_Privacy_State *group_privacy_state, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_voice_state_free(Tox_Event_Group_Voice_State *group_voice_state, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_topic_lock_free(Tox_Event_Group_Topic_Lock *group_topic_lock, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_peer_limit_free(Tox_Event_Group_Peer_Limit *group_peer_limit, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_password_free(Tox_Event_Group_Password *group_password, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_message_free(Tox_Event_Group_Message *group_message, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_private_message_free(Tox_Event_Group_Private_Message *group_private_message, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_custom_packet_free(Tox_Event_Group_Custom_Packet *group_custom_packet, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_custom_private_packet_free(Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_invite_free(Tox_Event_Group_Invite *group_invite, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_peer_join_free(Tox_Event_Group_Peer_Join *group_peer_join, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_peer_exit_free(Tox_Event_Group_Peer_Exit *group_peer_exit, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_self_join_free(Tox_Event_Group_Self_Join *group_self_join, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_join_fail_free(Tox_Event_Group_Join_Fail *group_join_fail, const Memory *mem);
non_null(2) nullable(1) void tox_event_group_moderation_free(Tox_Event_Group_Moderation *group_moderation, const Memory *mem);
/**
* Pack into msgpack.
*/
non_null() bool tox_event_pack(const Tox_Event *event, Bin_Pack *bp);
non_null() bool tox_event_conference_connected_pack(const Tox_Event_Conference_Connected *event, Bin_Pack *bp);
non_null() bool tox_event_conference_invite_pack(const Tox_Event_Conference_Invite *event, Bin_Pack *bp);
non_null() bool tox_event_conference_message_pack(const Tox_Event_Conference_Message *event, Bin_Pack *bp);
non_null() bool tox_event_conference_peer_list_changed_pack(const Tox_Event_Conference_Peer_List_Changed *event, Bin_Pack *bp);
non_null() bool tox_event_conference_peer_name_pack(const Tox_Event_Conference_Peer_Name *event, Bin_Pack *bp);
non_null() bool tox_event_conference_title_pack(const Tox_Event_Conference_Title *event, Bin_Pack *bp);
non_null() bool tox_event_file_chunk_request_pack(const Tox_Event_File_Chunk_Request *event, Bin_Pack *bp);
non_null() bool tox_event_file_recv_chunk_pack(const Tox_Event_File_Recv_Chunk *event, Bin_Pack *bp);
non_null() bool tox_event_file_recv_control_pack(const Tox_Event_File_Recv_Control *event, Bin_Pack *bp);
non_null() bool tox_event_file_recv_pack(const Tox_Event_File_Recv *event, Bin_Pack *bp);
non_null() bool tox_event_friend_connection_status_pack(const Tox_Event_Friend_Connection_Status *event, Bin_Pack *bp);
non_null() bool tox_event_friend_lossless_packet_pack(const Tox_Event_Friend_Lossless_Packet *event, Bin_Pack *bp);
non_null() bool tox_event_friend_lossy_packet_pack(const Tox_Event_Friend_Lossy_Packet *event, Bin_Pack *bp);
non_null() bool tox_event_friend_message_pack(const Tox_Event_Friend_Message *event, Bin_Pack *bp);
non_null() bool tox_event_friend_name_pack(const Tox_Event_Friend_Name *event, Bin_Pack *bp);
non_null() bool tox_event_friend_read_receipt_pack(const Tox_Event_Friend_Read_Receipt *event, Bin_Pack *bp);
non_null() bool tox_event_friend_request_pack(const Tox_Event_Friend_Request *event, Bin_Pack *bp);
non_null() bool tox_event_friend_status_message_pack(const Tox_Event_Friend_Status_Message *event, Bin_Pack *bp);
non_null() bool tox_event_friend_status_pack(const Tox_Event_Friend_Status *event, Bin_Pack *bp);
non_null() bool tox_event_friend_typing_pack(const Tox_Event_Friend_Typing *event, Bin_Pack *bp);
non_null() bool tox_event_self_connection_status_pack(const Tox_Event_Self_Connection_Status *event, Bin_Pack *bp);
non_null() bool tox_event_group_peer_name_pack(const Tox_Event_Group_Peer_Name *event, Bin_Pack *bp);
non_null() bool tox_event_group_peer_status_pack(const Tox_Event_Group_Peer_Status *event, Bin_Pack *bp);
non_null() bool tox_event_group_topic_pack(const Tox_Event_Group_Topic *event, Bin_Pack *bp);
non_null() bool tox_event_group_privacy_state_pack(const Tox_Event_Group_Privacy_State *event, Bin_Pack *bp);
non_null() bool tox_event_group_voice_state_pack(const Tox_Event_Group_Voice_State *event, Bin_Pack *bp);
non_null() bool tox_event_group_topic_lock_pack(const Tox_Event_Group_Topic_Lock *event, Bin_Pack *bp);
non_null() bool tox_event_group_peer_limit_pack(const Tox_Event_Group_Peer_Limit *event, Bin_Pack *bp);
non_null() bool tox_event_group_password_pack(const Tox_Event_Group_Password *event, Bin_Pack *bp);
non_null() bool tox_event_group_message_pack(const Tox_Event_Group_Message *event, Bin_Pack *bp);
non_null() bool tox_event_group_private_message_pack(const Tox_Event_Group_Private_Message *event, Bin_Pack *bp);
non_null() bool tox_event_group_custom_packet_pack(const Tox_Event_Group_Custom_Packet *event, Bin_Pack *bp);
non_null() bool tox_event_group_custom_private_packet_pack(const Tox_Event_Group_Custom_Private_Packet *event, Bin_Pack *bp);
non_null() bool tox_event_group_invite_pack(const Tox_Event_Group_Invite *event, Bin_Pack *bp);
non_null() bool tox_event_group_peer_join_pack(const Tox_Event_Group_Peer_Join *event, Bin_Pack *bp);
non_null() bool tox_event_group_peer_exit_pack(const Tox_Event_Group_Peer_Exit *event, Bin_Pack *bp);
non_null() bool tox_event_group_self_join_pack(const Tox_Event_Group_Self_Join *event, Bin_Pack *bp);
non_null() bool tox_event_group_join_fail_pack(const Tox_Event_Group_Join_Fail *event, Bin_Pack *bp);
non_null() bool tox_event_group_moderation_pack(const Tox_Event_Group_Moderation *event, Bin_Pack *bp);
/**
* Unpack from msgpack.
*/
non_null() bool tox_event_unpack_into(Tox_Event *event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_conference_connected_unpack(Tox_Event_Conference_Connected **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_conference_invite_unpack(Tox_Event_Conference_Invite **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_conference_message_unpack(Tox_Event_Conference_Message **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_conference_peer_list_changed_unpack(Tox_Event_Conference_Peer_List_Changed **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_conference_peer_name_unpack(Tox_Event_Conference_Peer_Name **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_conference_title_unpack(Tox_Event_Conference_Title **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_file_chunk_request_unpack(Tox_Event_File_Chunk_Request **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_file_recv_chunk_unpack(Tox_Event_File_Recv_Chunk **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_file_recv_control_unpack(Tox_Event_File_Recv_Control **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_file_recv_unpack(Tox_Event_File_Recv **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_connection_status_unpack(Tox_Event_Friend_Connection_Status **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_lossless_packet_unpack(Tox_Event_Friend_Lossless_Packet **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_lossy_packet_unpack(Tox_Event_Friend_Lossy_Packet **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_message_unpack(Tox_Event_Friend_Message **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_name_unpack(Tox_Event_Friend_Name **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_read_receipt_unpack(Tox_Event_Friend_Read_Receipt **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_request_unpack(Tox_Event_Friend_Request **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_status_message_unpack(Tox_Event_Friend_Status_Message **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_status_unpack(Tox_Event_Friend_Status **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_friend_typing_unpack(Tox_Event_Friend_Typing **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_self_connection_status_unpack(Tox_Event_Self_Connection_Status **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_peer_name_unpack(Tox_Event_Group_Peer_Name **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_peer_status_unpack(Tox_Event_Group_Peer_Status **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_topic_unpack(Tox_Event_Group_Topic **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_privacy_state_unpack(Tox_Event_Group_Privacy_State **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_voice_state_unpack(Tox_Event_Group_Voice_State **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_topic_lock_unpack(Tox_Event_Group_Topic_Lock **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_peer_limit_unpack(Tox_Event_Group_Peer_Limit **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_password_unpack(Tox_Event_Group_Password **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_message_unpack(Tox_Event_Group_Message **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_private_message_unpack(Tox_Event_Group_Private_Message **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_custom_packet_unpack(Tox_Event_Group_Custom_Packet **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_custom_private_packet_unpack(Tox_Event_Group_Custom_Private_Packet **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_invite_unpack(Tox_Event_Group_Invite **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_peer_join_unpack(Tox_Event_Group_Peer_Join **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_peer_exit_unpack(Tox_Event_Group_Peer_Exit **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_self_join_unpack(Tox_Event_Group_Self_Join **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_join_fail_unpack(Tox_Event_Group_Join_Fail **event, Bin_Unpack *bu, const Memory *mem);
non_null() bool tox_event_group_moderation_unpack(Tox_Event_Group_Moderation **event, Bin_Unpack *bu, const Memory *mem);
#ifdef __cplusplus
}
#endif
#endif // C_TOXCORE_TOXCORE_TOX_EVENT_H

257
external/toxcore/c-toxcore/toxcore/tox_events.c vendored
View File

@ -67,9 +67,24 @@ void tox_events_init(Tox *tox)
tox_callback_group_moderation(tox, tox_events_handle_group_moderation);
}
uint32_t tox_events_get_size(const Tox_Events *events)
{
return events == nullptr ? 0 : events->events_size;
}
const Tox_Event *tox_events_get(const Tox_Events *events, uint32_t index)
{
if (index >= tox_events_get_size(events)) {
return nullptr;
}
return &events->events[index];
}
Tox_Events *tox_events_iterate(Tox *tox, bool fail_hard, Tox_Err_Events_Iterate *error)
{
Tox_Events_State state = {TOX_ERR_EVENTS_ITERATE_OK};
const Tox_System *sys = tox_get_system(tox);
Tox_Events_State state = {TOX_ERR_EVENTS_ITERATE_OK, sys->mem};
tox_iterate(tox, &state);
if (error != nullptr) {
@ -86,231 +101,21 @@ Tox_Events *tox_events_iterate(Tox *tox, bool fail_hard, Tox_Err_Events_Iterate
bool tox_events_pack(const Tox_Events *events, Bin_Pack *bp)
{
const uint32_t count = tox_events_get_conference_connected_size(events)
+ tox_events_get_conference_invite_size(events)
+ tox_events_get_conference_message_size(events)
+ tox_events_get_conference_peer_list_changed_size(events)
+ tox_events_get_conference_peer_name_size(events)
+ tox_events_get_conference_title_size(events)
+ tox_events_get_file_chunk_request_size(events)
+ tox_events_get_file_recv_chunk_size(events)
+ tox_events_get_file_recv_control_size(events)
+ tox_events_get_file_recv_size(events)
+ tox_events_get_friend_connection_status_size(events)
+ tox_events_get_friend_lossless_packet_size(events)
+ tox_events_get_friend_lossy_packet_size(events)
+ tox_events_get_friend_message_size(events)
+ tox_events_get_friend_name_size(events)
+ tox_events_get_friend_read_receipt_size(events)
+ tox_events_get_friend_request_size(events)
+ tox_events_get_friend_status_message_size(events)
+ tox_events_get_friend_status_size(events)
+ tox_events_get_friend_typing_size(events)
+ tox_events_get_self_connection_status_size(events)
+ tox_events_get_group_peer_name_size(events)
+ tox_events_get_group_peer_status_size(events)
+ tox_events_get_group_topic_size(events)
+ tox_events_get_group_privacy_state_size(events)
+ tox_events_get_group_voice_state_size(events)
+ tox_events_get_group_topic_lock_size(events)
+ tox_events_get_group_peer_limit_size(events)
+ tox_events_get_group_password_size(events)
+ tox_events_get_group_message_size(events)
+ tox_events_get_group_private_message_size(events)
+ tox_events_get_group_custom_packet_size(events)
+ tox_events_get_group_custom_private_packet_size(events)
+ tox_events_get_group_invite_size(events)
+ tox_events_get_group_peer_join_size(events)
+ tox_events_get_group_peer_exit_size(events)
+ tox_events_get_group_self_join_size(events)
+ tox_events_get_group_join_fail_size(events)
+ tox_events_get_group_moderation_size(events);
return bin_pack_array(bp, count)
&& tox_events_pack_conference_connected(events, bp)
&& tox_events_pack_conference_invite(events, bp)
&& tox_events_pack_conference_message(events, bp)
&& tox_events_pack_conference_peer_list_changed(events, bp)
&& tox_events_pack_conference_peer_name(events, bp)
&& tox_events_pack_conference_title(events, bp)
&& tox_events_pack_file_chunk_request(events, bp)
&& tox_events_pack_file_recv_chunk(events, bp)
&& tox_events_pack_file_recv_control(events, bp)
&& tox_events_pack_file_recv(events, bp)
&& tox_events_pack_friend_connection_status(events, bp)
&& tox_events_pack_friend_lossless_packet(events, bp)
&& tox_events_pack_friend_lossy_packet(events, bp)
&& tox_events_pack_friend_message(events, bp)
&& tox_events_pack_friend_name(events, bp)
&& tox_events_pack_friend_read_receipt(events, bp)
&& tox_events_pack_friend_request(events, bp)
&& tox_events_pack_friend_status_message(events, bp)
&& tox_events_pack_friend_status(events, bp)
&& tox_events_pack_friend_typing(events, bp)
&& tox_events_pack_self_connection_status(events, bp)
&& tox_events_pack_group_peer_name(events, bp)
&& tox_events_pack_group_peer_status(events, bp)
&& tox_events_pack_group_topic(events, bp)
&& tox_events_pack_group_privacy_state(events, bp)
&& tox_events_pack_group_voice_state(events, bp)
&& tox_events_pack_group_topic_lock(events, bp)
&& tox_events_pack_group_peer_limit(events, bp)
&& tox_events_pack_group_password(events, bp)
&& tox_events_pack_group_message(events, bp)
&& tox_events_pack_group_private_message(events, bp)
&& tox_events_pack_group_custom_packet(events, bp)
&& tox_events_pack_group_custom_private_packet(events, bp)
&& tox_events_pack_group_invite(events, bp)
&& tox_events_pack_group_peer_join(events, bp)
&& tox_events_pack_group_peer_exit(events, bp)
&& tox_events_pack_group_self_join(events, bp)
&& tox_events_pack_group_join_fail(events, bp)
&& tox_events_pack_group_moderation(events, bp);
}
non_null()
static bool tox_event_unpack(Tox_Events *events, Bin_Unpack *bu)
{
uint32_t size;
if (!bin_unpack_array(bu, &size)) {
const uint32_t size = tox_events_get_size(events);
if (!bin_pack_array(bp, size)) {
return false;
}
if (size != 2) {
return false;
}
uint8_t type;
if (!bin_unpack_u08(bu, &type)) {
return false;
}
switch (type) {
case TOX_EVENT_CONFERENCE_CONNECTED:
return tox_events_unpack_conference_connected(events, bu);
case TOX_EVENT_CONFERENCE_INVITE:
return tox_events_unpack_conference_invite(events, bu);
case TOX_EVENT_CONFERENCE_MESSAGE:
return tox_events_unpack_conference_message(events, bu);
case TOX_EVENT_CONFERENCE_PEER_LIST_CHANGED:
return tox_events_unpack_conference_peer_list_changed(events, bu);
case TOX_EVENT_CONFERENCE_PEER_NAME:
return tox_events_unpack_conference_peer_name(events, bu);
case TOX_EVENT_CONFERENCE_TITLE:
return tox_events_unpack_conference_title(events, bu);
case TOX_EVENT_FILE_CHUNK_REQUEST:
return tox_events_unpack_file_chunk_request(events, bu);
case TOX_EVENT_FILE_RECV_CHUNK:
return tox_events_unpack_file_recv_chunk(events, bu);
case TOX_EVENT_FILE_RECV_CONTROL:
return tox_events_unpack_file_recv_control(events, bu);
case TOX_EVENT_FILE_RECV:
return tox_events_unpack_file_recv(events, bu);
case TOX_EVENT_FRIEND_CONNECTION_STATUS:
return tox_events_unpack_friend_connection_status(events, bu);
case TOX_EVENT_FRIEND_LOSSLESS_PACKET:
return tox_events_unpack_friend_lossless_packet(events, bu);
case TOX_EVENT_FRIEND_LOSSY_PACKET:
return tox_events_unpack_friend_lossy_packet(events, bu);
case TOX_EVENT_FRIEND_MESSAGE:
return tox_events_unpack_friend_message(events, bu);
case TOX_EVENT_FRIEND_NAME:
return tox_events_unpack_friend_name(events, bu);
case TOX_EVENT_FRIEND_READ_RECEIPT:
return tox_events_unpack_friend_read_receipt(events, bu);
case TOX_EVENT_FRIEND_REQUEST:
return tox_events_unpack_friend_request(events, bu);
case TOX_EVENT_FRIEND_STATUS_MESSAGE:
return tox_events_unpack_friend_status_message(events, bu);
case TOX_EVENT_FRIEND_STATUS:
return tox_events_unpack_friend_status(events, bu);
case TOX_EVENT_FRIEND_TYPING:
return tox_events_unpack_friend_typing(events, bu);
case TOX_EVENT_SELF_CONNECTION_STATUS:
return tox_events_unpack_self_connection_status(events, bu);
case TOX_EVENT_GROUP_PEER_NAME:
return tox_events_unpack_group_peer_name(events, bu);
case TOX_EVENT_GROUP_PEER_STATUS:
return tox_events_unpack_group_peer_status(events, bu);
case TOX_EVENT_GROUP_TOPIC:
return tox_events_unpack_group_topic(events, bu);
case TOX_EVENT_GROUP_PRIVACY_STATE:
return tox_events_unpack_group_privacy_state(events, bu);
case TOX_EVENT_GROUP_VOICE_STATE:
return tox_events_unpack_group_voice_state(events, bu);
case TOX_EVENT_GROUP_TOPIC_LOCK:
return tox_events_unpack_group_topic_lock(events, bu);
case TOX_EVENT_GROUP_PEER_LIMIT:
return tox_events_unpack_group_peer_limit(events, bu);
case TOX_EVENT_GROUP_PASSWORD:
return tox_events_unpack_group_password(events, bu);
case TOX_EVENT_GROUP_MESSAGE:
return tox_events_unpack_group_message(events, bu);
case TOX_EVENT_GROUP_PRIVATE_MESSAGE:
return tox_events_unpack_group_private_message(events, bu);
case TOX_EVENT_GROUP_CUSTOM_PACKET:
return tox_events_unpack_group_custom_packet(events, bu);
case TOX_EVENT_GROUP_CUSTOM_PRIVATE_PACKET:
return tox_events_unpack_group_custom_private_packet(events, bu);
case TOX_EVENT_GROUP_INVITE:
return tox_events_unpack_group_invite(events, bu);
case TOX_EVENT_GROUP_PEER_JOIN:
return tox_events_unpack_group_peer_join(events, bu);
case TOX_EVENT_GROUP_PEER_EXIT:
return tox_events_unpack_group_peer_exit(events, bu);
case TOX_EVENT_GROUP_SELF_JOIN:
return tox_events_unpack_group_self_join(events, bu);
case TOX_EVENT_GROUP_JOIN_FAIL:
return tox_events_unpack_group_join_fail(events, bu);
case TOX_EVENT_GROUP_MODERATION:
return tox_events_unpack_group_moderation(events, bu);
default:
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_pack(&events->events[i], bp)) {
return false;
}
}
return true;
}
bool tox_events_unpack(Tox_Events *events, Bin_Unpack *bu)
bool tox_events_unpack(Tox_Events *events, Bin_Unpack *bu, const Memory *mem)
{
uint32_t size;
if (!bin_unpack_array(bu, &size)) {
@ -318,11 +123,20 @@ bool tox_events_unpack(Tox_Events *events, Bin_Unpack *bu)
}
for (uint32_t i = 0; i < size; ++i) {
if (!tox_event_unpack(events, bu)) {
Tox_Event event = {TOX_EVENT_INVALID};
if (!tox_event_unpack_into(&event, bu, mem)) {
tox_event_destruct(&event, mem);
return false;
}
if (!tox_events_add(events, &event)) {
tox_event_destruct(&event, mem);
return false;
}
}
// Invariant: if all adds worked, the events size must be the input array size.
assert(tox_events_get_size(events) == size);
return true;
}
@ -337,9 +151,9 @@ uint32_t tox_events_bytes_size(const Tox_Events *events)
return bin_pack_obj_size(tox_events_bin_pack_handler, nullptr, events);
}
void tox_events_get_bytes(const Tox_Events *events, uint8_t *bytes)
bool tox_events_get_bytes(const Tox_Events *events, uint8_t *bytes)
{
bin_pack_obj(tox_events_bin_pack_handler, nullptr, events, bytes, UINT32_MAX);
return bin_pack_obj(tox_events_bin_pack_handler, nullptr, events, bytes, UINT32_MAX);
}
Tox_Events *tox_events_load(const Tox_System *sys, const uint8_t *bytes, uint32_t bytes_size)
@ -360,8 +174,9 @@ Tox_Events *tox_events_load(const Tox_System *sys, const uint8_t *bytes, uint32_
*events = (Tox_Events) {
nullptr
};
events->mem = sys->mem;
if (!tox_events_unpack(events, bu)) {
if (!tox_events_unpack(events, bu, sys->mem)) {
tox_events_free(events);
bin_unpack_free(bu);
return nullptr;

128
external/toxcore/c-toxcore/toxcore/tox_events.h vendored
View File

@ -88,7 +88,7 @@ uint32_t tox_event_file_recv_get_kind(
typedef struct Tox_Event_File_Recv_Chunk Tox_Event_File_Recv_Chunk;
const uint8_t *tox_event_file_recv_chunk_get_data(
const Tox_Event_File_Recv_Chunk *file_recv_chunk);
uint32_t tox_event_file_recv_chunk_get_length(
uint32_t tox_event_file_recv_chunk_get_data_length(
const Tox_Event_File_Recv_Chunk *file_recv_chunk);
uint32_t tox_event_file_recv_chunk_get_file_number(
const Tox_Event_File_Recv_Chunk *file_recv_chunk);
@ -190,7 +190,7 @@ uint32_t tox_event_group_peer_name_get_peer_id(
const Tox_Event_Group_Peer_Name *group_peer_name);
const uint8_t *tox_event_group_peer_name_get_name(
const Tox_Event_Group_Peer_Name *group_peer_name);
size_t tox_event_group_peer_name_get_name_length(
uint32_t tox_event_group_peer_name_get_name_length(
const Tox_Event_Group_Peer_Name *group_peer_name);
typedef struct Tox_Event_Group_Peer_Status Tox_Event_Group_Peer_Status;
@ -208,7 +208,7 @@ uint32_t tox_event_group_topic_get_peer_id(
const Tox_Event_Group_Topic *group_topic);
const uint8_t *tox_event_group_topic_get_topic(
const Tox_Event_Group_Topic *group_topic);
size_t tox_event_group_topic_get_topic_length(
uint32_t tox_event_group_topic_get_topic_length(
const Tox_Event_Group_Topic *group_topic);
typedef struct Tox_Event_Group_Privacy_State Tox_Event_Group_Privacy_State;
@ -240,7 +240,7 @@ uint32_t tox_event_group_password_get_group_number(
const Tox_Event_Group_Password *group_password);
const uint8_t *tox_event_group_password_get_password(
const Tox_Event_Group_Password *group_password);
size_t tox_event_group_password_get_password_length(
uint32_t tox_event_group_password_get_password_length(
const Tox_Event_Group_Password *group_password);
typedef struct Tox_Event_Group_Message Tox_Event_Group_Message;
@ -252,7 +252,7 @@ Tox_Message_Type tox_event_group_message_get_type(
const Tox_Event_Group_Message *group_message);
const uint8_t *tox_event_group_message_get_message(
const Tox_Event_Group_Message *group_message);
size_t tox_event_group_message_get_message_length(
uint32_t tox_event_group_message_get_message_length(
const Tox_Event_Group_Message *group_message);
uint32_t tox_event_group_message_get_message_id(
const Tox_Event_Group_Message *group_message);
@ -266,7 +266,7 @@ Tox_Message_Type tox_event_group_private_message_get_type(
const Tox_Event_Group_Private_Message *group_private_message);
const uint8_t *tox_event_group_private_message_get_message(
const Tox_Event_Group_Private_Message *group_private_message);
size_t tox_event_group_private_message_get_message_length(
uint32_t tox_event_group_private_message_get_message_length(
const Tox_Event_Group_Private_Message *group_private_message);
typedef struct Tox_Event_Group_Custom_Packet Tox_Event_Group_Custom_Packet;
@ -276,7 +276,7 @@ uint32_t tox_event_group_custom_packet_get_peer_id(
const Tox_Event_Group_Custom_Packet *group_custom_packet);
const uint8_t *tox_event_group_custom_packet_get_data(
const Tox_Event_Group_Custom_Packet *group_custom_packet);
size_t tox_event_group_custom_packet_get_data_length(
uint32_t tox_event_group_custom_packet_get_data_length(
const Tox_Event_Group_Custom_Packet *group_custom_packet);
typedef struct Tox_Event_Group_Custom_Private_Packet Tox_Event_Group_Custom_Private_Packet;
@ -286,7 +286,7 @@ uint32_t tox_event_group_custom_private_packet_get_peer_id(
const Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet);
const uint8_t *tox_event_group_custom_private_packet_get_data(
const Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet);
size_t tox_event_group_custom_private_packet_get_data_length(
uint32_t tox_event_group_custom_private_packet_get_data_length(
const Tox_Event_Group_Custom_Private_Packet *group_custom_private_packet);
typedef struct Tox_Event_Group_Invite Tox_Event_Group_Invite;
@ -294,11 +294,11 @@ uint32_t tox_event_group_invite_get_friend_number(
const Tox_Event_Group_Invite *group_invite);
const uint8_t *tox_event_group_invite_get_invite_data(
const Tox_Event_Group_Invite *group_invite);
size_t tox_event_group_invite_get_invite_data_length(
uint32_t tox_event_group_invite_get_invite_data_length(
const Tox_Event_Group_Invite *group_invite);
const uint8_t *tox_event_group_invite_get_group_name(
const Tox_Event_Group_Invite *group_invite);
size_t tox_event_group_invite_get_group_name_length(
uint32_t tox_event_group_invite_get_group_name_length(
const Tox_Event_Group_Invite *group_invite);
typedef struct Tox_Event_Group_Peer_Join Tox_Event_Group_Peer_Join;
@ -316,11 +316,11 @@ Tox_Group_Exit_Type tox_event_group_peer_exit_get_exit_type(
const Tox_Event_Group_Peer_Exit *group_peer_exit);
const uint8_t *tox_event_group_peer_exit_get_name(
const Tox_Event_Group_Peer_Exit *group_peer_exit);
size_t tox_event_group_peer_exit_get_name_length(
uint32_t tox_event_group_peer_exit_get_name_length(
const Tox_Event_Group_Peer_Exit *group_peer_exit);
const uint8_t *tox_event_group_peer_exit_get_part_message(
const Tox_Event_Group_Peer_Exit *group_peer_exit);
size_t tox_event_group_peer_exit_get_part_message_length(
uint32_t tox_event_group_peer_exit_get_part_message_length(
const Tox_Event_Group_Peer_Exit *group_peer_exit);
typedef struct Tox_Event_Group_Self_Join Tox_Event_Group_Self_Join;
@ -343,7 +343,7 @@ uint32_t tox_event_group_moderation_get_target_peer_id(
Tox_Group_Mod_Event tox_event_group_moderation_get_mod_type(
const Tox_Event_Group_Moderation *group_moderation);
typedef enum Tox_Event {
typedef enum Tox_Event_Type {
TOX_EVENT_SELF_CONNECTION_STATUS = 0,
TOX_EVENT_FRIEND_REQUEST = 1,
@ -390,7 +390,102 @@ typedef enum Tox_Event {
TOX_EVENT_GROUP_SELF_JOIN = 36,
TOX_EVENT_GROUP_JOIN_FAIL = 37,
TOX_EVENT_GROUP_MODERATION = 38,
} Tox_Event;
TOX_EVENT_INVALID = 255,
} Tox_Event_Type;
const char *tox_event_type_to_string(Tox_Event_Type type);
/**
* A single Tox core event.
*
* It could contain any of the above event types. Use `tox_event_get_type` to
* find out which one it is, then use one of the `get` functions to get the
* actual event object out. The `get` functions will return NULL in case of type
* mismatch.
*/
typedef struct Tox_Event Tox_Event;
Tox_Event_Type tox_event_get_type(const Tox_Event *event);
const Tox_Event_Conference_Connected *tox_event_get_conference_connected(
const Tox_Event *event);
const Tox_Event_Conference_Invite *tox_event_get_conference_invite(
const Tox_Event *event);
const Tox_Event_Conference_Message *tox_event_get_conference_message(
const Tox_Event *event);
const Tox_Event_Conference_Peer_List_Changed *tox_event_get_conference_peer_list_changed(
const Tox_Event *event);
const Tox_Event_Conference_Peer_Name *tox_event_get_conference_peer_name(
const Tox_Event *event);
const Tox_Event_Conference_Title *tox_event_get_conference_title(
const Tox_Event *event);
const Tox_Event_File_Chunk_Request *tox_event_get_file_chunk_request(
const Tox_Event *event);
const Tox_Event_File_Recv_Chunk *tox_event_get_file_recv_chunk(
const Tox_Event *event);
const Tox_Event_File_Recv_Control *tox_event_get_file_recv_control(
const Tox_Event *event);
const Tox_Event_File_Recv *tox_event_get_file_recv(
const Tox_Event *event);
const Tox_Event_Friend_Connection_Status *tox_event_get_friend_connection_status(
const Tox_Event *event);
const Tox_Event_Friend_Lossless_Packet *tox_event_get_friend_lossless_packet(
const Tox_Event *event);
const Tox_Event_Friend_Lossy_Packet *tox_event_get_friend_lossy_packet(
const Tox_Event *event);
const Tox_Event_Friend_Message *tox_event_get_friend_message(
const Tox_Event *event);
const Tox_Event_Friend_Name *tox_event_get_friend_name(
const Tox_Event *event);
const Tox_Event_Friend_Read_Receipt *tox_event_get_friend_read_receipt(
const Tox_Event *event);
const Tox_Event_Friend_Request *tox_event_get_friend_request(
const Tox_Event *event);
const Tox_Event_Friend_Status_Message *tox_event_get_friend_status_message(
const Tox_Event *event);
const Tox_Event_Friend_Status *tox_event_get_friend_status(
const Tox_Event *event);
const Tox_Event_Friend_Typing *tox_event_get_friend_typing(
const Tox_Event *event);
const Tox_Event_Self_Connection_Status *tox_event_get_self_connection_status(
const Tox_Event *event);
const Tox_Event_Group_Peer_Name *tox_event_get_group_peer_name(
const Tox_Event *event);
const Tox_Event_Group_Peer_Status *tox_event_get_group_peer_status(
const Tox_Event *event);
const Tox_Event_Group_Topic *tox_event_get_group_topic(
const Tox_Event *event);
const Tox_Event_Group_Privacy_State *tox_event_get_group_privacy_state(
const Tox_Event *event);
const Tox_Event_Group_Voice_State *tox_event_get_group_voice_state(
const Tox_Event *event);
const Tox_Event_Group_Topic_Lock *tox_event_get_group_topic_lock(
const Tox_Event *event);
const Tox_Event_Group_Peer_Limit *tox_event_get_group_peer_limit(
const Tox_Event *event);
const Tox_Event_Group_Password *tox_event_get_group_password(
const Tox_Event *event);
const Tox_Event_Group_Message *tox_event_get_group_message(
const Tox_Event *event);
const Tox_Event_Group_Private_Message *tox_event_get_group_private_message(
const Tox_Event *event);
const Tox_Event_Group_Custom_Packet *tox_event_get_group_custom_packet(
const Tox_Event *event);
const Tox_Event_Group_Custom_Private_Packet *tox_event_get_group_custom_private_packet(
const Tox_Event *event);
const Tox_Event_Group_Invite *tox_event_get_group_invite(
const Tox_Event *event);
const Tox_Event_Group_Peer_Join *tox_event_get_group_peer_join(
const Tox_Event *event);
const Tox_Event_Group_Peer_Exit *tox_event_get_group_peer_exit(
const Tox_Event *event);
const Tox_Event_Group_Self_Join *tox_event_get_group_self_join(
const Tox_Event *event);
const Tox_Event_Group_Join_Fail *tox_event_get_group_join_fail(
const Tox_Event *event);
const Tox_Event_Group_Moderation *tox_event_get_group_moderation(
const Tox_Event *event);
/**
* Container object for all Tox core events.
@ -399,6 +494,9 @@ typedef enum Tox_Event {
*/
typedef struct Tox_Events Tox_Events;
uint32_t tox_events_get_size(const Tox_Events *events);
const Tox_Event *tox_events_get(const Tox_Events *events, uint32_t index);
uint32_t tox_events_get_conference_connected_size(const Tox_Events *events);
uint32_t tox_events_get_conference_invite_size(const Tox_Events *events);
uint32_t tox_events_get_conference_message_size(const Tox_Events *events);
@ -573,7 +671,7 @@ Tox_Events *tox_events_iterate(Tox *tox, bool fail_hard, Tox_Err_Events_Iterate
void tox_events_free(Tox_Events *events);
uint32_t tox_events_bytes_size(const Tox_Events *events);
void tox_events_get_bytes(const Tox_Events *events, uint8_t *bytes);
bool tox_events_get_bytes(const Tox_Events *events, uint8_t *bytes);
Tox_Events *tox_events_load(const Tox_System *sys, const uint8_t *bytes, uint32_t bytes_size);

6
external/toxcore/c-toxcore/toxcore/tox_events_test.cc vendored
View File

@ -48,14 +48,14 @@ TEST(ToxEvents, NullEventsPacksToEmptyArray)
TEST(ToxEvents, PackedEventsCanBeUnpacked)
{
const Tox_System sys = tox_default_system();
// [[0, 1]] == Tox_Self_Connection_Status { .connection_status = TOX_CONNECTION_TCP }
std::array<uint8_t, 6> packed{0x91, 0x92, 0xcc, 0x00, 0xcc, 0x01};
// [[1, 1]] == Tox_Self_Connection_Status { .connection_status = TOX_CONNECTION_TCP }
std::array<uint8_t, 6> packed{0x91, 0x92, 0xcc, 0x01, 0xcc, 0x01};
Tox_Events *events = tox_events_load(&sys, packed.data(), packed.size());
ASSERT_NE(events, nullptr);
std::array<uint8_t, 4> bytes;
ASSERT_EQ(tox_events_bytes_size(events), bytes.size());
tox_events_get_bytes(events, bytes.data());
EXPECT_EQ(bytes, (std::array<uint8_t, 4>{0x91, 0x92, 0x00, 0x01}));
EXPECT_EQ(bytes, (std::array<uint8_t, 4>{0x91, 0x92, 0x01, 0x01}));
tox_events_free(events);
}

3
external/toxcore/c-toxcore/toxcore/tox_private.c vendored
View File

@ -167,7 +167,6 @@ uint16_t tox_dht_get_num_closelist_announce_capable(const Tox *tox){
return num_cap;
}
#ifndef VANILLA_NACL
size_t tox_group_peer_get_ip_address_size(const Tox *tox, uint32_t group_number, uint32_t peer_id,
Tox_Err_Group_Peer_Query *error)
{
@ -219,5 +218,3 @@ bool tox_group_peer_get_ip_address(const Tox *tox, uint32_t group_number, uint32
SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK);
return true;
}
#endif /* VANILLA_NACL */

7
external/toxcore/c-toxcore/toxcore/tox_test.cc vendored
View File

@ -82,6 +82,13 @@ TEST(Tox, OneTest)
struct Tox_Options *options = tox_options_new(nullptr);
ASSERT_NE(options, nullptr);
tox_options_set_log_callback(options,
[](Tox *tox, Tox_Log_Level level, const char *file, uint32_t line, const char *func,
const char *message, void *user_data) {
fprintf(stderr, "[%c] %s:%d(%s): %s\n", tox_log_level_to_string(level)[0], file, line,
func, message);
});
// Higher start/end point here to avoid conflict with the LAN discovery test.
tox_options_set_start_port(options, 33545);
tox_options_set_end_port(options, 33545 + 2000);

447
external/toxcore/c-toxcore/toxcore/tox_unpack.c vendored
View File

@ -9,276 +9,337 @@
#include "bin_unpack.h"
#include "ccompat.h"
static Tox_Conference_Type tox_conference_type_from_int(uint32_t value)
non_null()
static bool tox_conference_type_from_int(uint32_t value, Tox_Conference_Type *out)
{
switch (value) {
case 0:
return TOX_CONFERENCE_TYPE_TEXT;
case 1:
return TOX_CONFERENCE_TYPE_AV;
default:
return TOX_CONFERENCE_TYPE_TEXT;
case TOX_CONFERENCE_TYPE_TEXT: {
*out = TOX_CONFERENCE_TYPE_TEXT;
return true;
}
case TOX_CONFERENCE_TYPE_AV: {
*out = TOX_CONFERENCE_TYPE_AV;
return true;
}
default: {
*out = TOX_CONFERENCE_TYPE_TEXT;
return false;
}
}
}
bool tox_unpack_conference_type(Bin_Unpack *bu, Tox_Conference_Type *val)
bool tox_conference_type_unpack(Bin_Unpack *bu, Tox_Conference_Type *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_conference_type_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_conference_type_from_int(u32, val);
}
static Tox_Connection tox_connection_from_int(uint32_t value)
non_null()
static bool tox_connection_from_int(uint32_t value, Tox_Connection *out)
{
switch (value) {
case 0:
return TOX_CONNECTION_NONE;
case 1:
return TOX_CONNECTION_TCP;
case 2:
return TOX_CONNECTION_UDP;
default:
return TOX_CONNECTION_NONE;
case TOX_CONNECTION_NONE: {
*out = TOX_CONNECTION_NONE;
return true;
}
case TOX_CONNECTION_TCP: {
*out = TOX_CONNECTION_TCP;
return true;
}
case TOX_CONNECTION_UDP: {
*out = TOX_CONNECTION_UDP;
return true;
}
default: {
*out = TOX_CONNECTION_NONE;
return false;
}
}
}
bool tox_unpack_connection(Bin_Unpack *bu, Tox_Connection *val)
bool tox_connection_unpack(Bin_Unpack *bu, Tox_Connection *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_connection_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_connection_from_int(u32, val);
}
static Tox_File_Control tox_file_control_from_int(uint32_t value)
non_null()
static bool tox_file_control_from_int(uint32_t value, Tox_File_Control *out)
{
switch (value) {
case 0:
return TOX_FILE_CONTROL_RESUME;
case 1:
return TOX_FILE_CONTROL_PAUSE;
case 2:
return TOX_FILE_CONTROL_CANCEL;
default:
return TOX_FILE_CONTROL_RESUME;
case TOX_FILE_CONTROL_RESUME: {
*out = TOX_FILE_CONTROL_RESUME;
return true;
}
case TOX_FILE_CONTROL_PAUSE: {
*out = TOX_FILE_CONTROL_PAUSE;
return true;
}
case TOX_FILE_CONTROL_CANCEL: {
*out = TOX_FILE_CONTROL_CANCEL;
return true;
}
default: {
*out = TOX_FILE_CONTROL_RESUME;
return false;
}
}
}
bool tox_unpack_file_control(Bin_Unpack *bu, Tox_File_Control *val)
bool tox_file_control_unpack(Bin_Unpack *bu, Tox_File_Control *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_file_control_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_file_control_from_int(u32, val);
}
static Tox_Message_Type tox_message_type_from_int(uint32_t value)
non_null()
static bool tox_message_type_from_int(uint32_t value, Tox_Message_Type *out)
{
switch (value) {
case 0:
return TOX_MESSAGE_TYPE_NORMAL;
case 1:
return TOX_MESSAGE_TYPE_ACTION;
default:
return TOX_MESSAGE_TYPE_NORMAL;
case TOX_MESSAGE_TYPE_NORMAL: {
*out = TOX_MESSAGE_TYPE_NORMAL;
return true;
}
case TOX_MESSAGE_TYPE_ACTION: {
*out = TOX_MESSAGE_TYPE_ACTION;
return true;
}
default: {
*out = TOX_MESSAGE_TYPE_NORMAL;
return false;
}
}
}
bool tox_unpack_message_type(Bin_Unpack *bu, Tox_Message_Type *val)
bool tox_message_type_unpack(Bin_Unpack *bu, Tox_Message_Type *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_message_type_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_message_type_from_int(u32, val);
}
static Tox_User_Status tox_user_status_from_int(uint32_t value)
non_null()
static bool tox_user_status_from_int(uint32_t value, Tox_User_Status *out)
{
switch (value) {
case 0:
return TOX_USER_STATUS_NONE;
case 1:
return TOX_USER_STATUS_AWAY;
case 2:
return TOX_USER_STATUS_BUSY;
default:
return TOX_USER_STATUS_NONE;
case TOX_USER_STATUS_NONE: {
*out = TOX_USER_STATUS_NONE;
return true;
}
case TOX_USER_STATUS_AWAY: {
*out = TOX_USER_STATUS_AWAY;
return true;
}
case TOX_USER_STATUS_BUSY: {
*out = TOX_USER_STATUS_BUSY;
return true;
}
default: {
*out = TOX_USER_STATUS_NONE;
return false;
}
}
}
bool tox_unpack_user_status(Bin_Unpack *bu, Tox_User_Status *val)
bool tox_user_status_unpack(Bin_Unpack *bu, Tox_User_Status *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_user_status_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_user_status_from_int(u32, val);
}
static Tox_Group_Privacy_State tox_group_privacy_state_from_int(uint32_t value)
non_null()
static bool tox_group_privacy_state_from_int(uint32_t value, Tox_Group_Privacy_State *out)
{
switch (value) {
case 0:
return TOX_GROUP_PRIVACY_STATE_PUBLIC;
case 1:
return TOX_GROUP_PRIVACY_STATE_PRIVATE;
default:
return TOX_GROUP_PRIVACY_STATE_PRIVATE;
switch (value) {
case TOX_GROUP_PRIVACY_STATE_PUBLIC: {
*out = TOX_GROUP_PRIVACY_STATE_PUBLIC;
return true;
}
case TOX_GROUP_PRIVACY_STATE_PRIVATE: {
*out = TOX_GROUP_PRIVACY_STATE_PRIVATE;
return true;
}
default: {
*out = TOX_GROUP_PRIVACY_STATE_PUBLIC;
return false;
}
}
}
bool tox_unpack_group_privacy_state(Bin_Unpack *bu, Tox_Group_Privacy_State *val)
bool tox_group_privacy_state_unpack(Bin_Unpack *bu, Tox_Group_Privacy_State *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_group_privacy_state_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_group_privacy_state_from_int(u32, val);
}
static Tox_Group_Voice_State tox_group_voice_state_from_int(uint32_t value)
non_null()
static bool tox_group_voice_state_from_int(uint32_t value, Tox_Group_Voice_State *out)
{
switch (value) {
case 0:
return TOX_GROUP_VOICE_STATE_ALL;
case 1:
return TOX_GROUP_VOICE_STATE_MODERATOR;
case 2:
return TOX_GROUP_VOICE_STATE_FOUNDER;
default:
return TOX_GROUP_VOICE_STATE_FOUNDER;
switch (value) {
case TOX_GROUP_VOICE_STATE_ALL: {
*out = TOX_GROUP_VOICE_STATE_ALL;
return true;
}
case TOX_GROUP_VOICE_STATE_MODERATOR: {
*out = TOX_GROUP_VOICE_STATE_MODERATOR;
return true;
}
case TOX_GROUP_VOICE_STATE_FOUNDER: {
*out = TOX_GROUP_VOICE_STATE_FOUNDER;
return true;
}
default: {
*out = TOX_GROUP_VOICE_STATE_ALL;
return false;
}
}
}
bool tox_unpack_group_voice_state(Bin_Unpack *bu, Tox_Group_Voice_State *val)
bool tox_group_voice_state_unpack(Bin_Unpack *bu, Tox_Group_Voice_State *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_group_voice_state_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_group_voice_state_from_int(u32, val);
}
static Tox_Group_Topic_Lock tox_group_topic_lock_from_int(uint32_t value)
non_null()
static bool tox_group_topic_lock_from_int(uint32_t value, Tox_Group_Topic_Lock *out)
{
switch (value) {
case 0:
return TOX_GROUP_TOPIC_LOCK_ENABLED;
case 1:
return TOX_GROUP_TOPIC_LOCK_DISABLED;
default:
return TOX_GROUP_TOPIC_LOCK_ENABLED;
switch (value) {
case TOX_GROUP_TOPIC_LOCK_ENABLED: {
*out = TOX_GROUP_TOPIC_LOCK_ENABLED;
return true;
}
case TOX_GROUP_TOPIC_LOCK_DISABLED: {
*out = TOX_GROUP_TOPIC_LOCK_DISABLED;
return true;
}
default: {
*out = TOX_GROUP_TOPIC_LOCK_ENABLED;
return false;
}
}
}
bool tox_unpack_group_topic_lock(Bin_Unpack *bu, Tox_Group_Topic_Lock *val)
bool tox_group_topic_lock_unpack(Bin_Unpack *bu, Tox_Group_Topic_Lock *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_group_topic_lock_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_group_topic_lock_from_int(u32, val);
}
static Tox_Group_Join_Fail tox_group_join_fail_from_int(uint32_t value)
non_null()
static bool tox_group_join_fail_from_int(uint32_t value, Tox_Group_Join_Fail *out)
{
switch (value) {
case 0:
return TOX_GROUP_JOIN_FAIL_PEER_LIMIT;
case 1:
return TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD;
case 2:
return TOX_GROUP_JOIN_FAIL_UNKNOWN;
default:
return TOX_GROUP_JOIN_FAIL_UNKNOWN;
switch (value) {
case TOX_GROUP_JOIN_FAIL_PEER_LIMIT: {
*out = TOX_GROUP_JOIN_FAIL_PEER_LIMIT;
return true;
}
case TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD: {
*out = TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD;
return true;
}
case TOX_GROUP_JOIN_FAIL_UNKNOWN: {
*out = TOX_GROUP_JOIN_FAIL_UNKNOWN;
return true;
}
default: {
*out = TOX_GROUP_JOIN_FAIL_PEER_LIMIT;
return false;
}
}
}
bool tox_unpack_group_join_fail(Bin_Unpack *bu, Tox_Group_Join_Fail *val)
bool tox_group_join_fail_unpack(Bin_Unpack *bu, Tox_Group_Join_Fail *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_group_join_fail_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_group_join_fail_from_int(u32, val);
}
static Tox_Group_Mod_Event tox_group_mod_event_from_int(uint32_t value)
non_null()
static bool tox_group_mod_event_from_int(uint32_t value, Tox_Group_Mod_Event *out)
{
switch (value) {
case 0:
return TOX_GROUP_MOD_EVENT_KICK;
case 1:
return TOX_GROUP_MOD_EVENT_OBSERVER;
case 2:
return TOX_GROUP_MOD_EVENT_USER;
case 3:
return TOX_GROUP_MOD_EVENT_MODERATOR;
default:
return TOX_GROUP_MOD_EVENT_MODERATOR;
switch (value) {
case TOX_GROUP_MOD_EVENT_KICK: {
*out = TOX_GROUP_MOD_EVENT_KICK;
return true;
}
case TOX_GROUP_MOD_EVENT_OBSERVER: {
*out = TOX_GROUP_MOD_EVENT_OBSERVER;
return true;
}
case TOX_GROUP_MOD_EVENT_USER: {
*out = TOX_GROUP_MOD_EVENT_USER;
return true;
}
case TOX_GROUP_MOD_EVENT_MODERATOR: {
*out = TOX_GROUP_MOD_EVENT_MODERATOR;
return true;
}
default: {
*out = TOX_GROUP_MOD_EVENT_KICK;
return false;
}
}
}
bool tox_unpack_group_mod_event(Bin_Unpack *bu, Tox_Group_Mod_Event *val)
bool tox_group_mod_event_unpack(Bin_Unpack *bu, Tox_Group_Mod_Event *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_group_mod_event_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_group_mod_event_from_int(u32, val);
}
static Tox_Group_Exit_Type tox_group_exit_type_from_int(uint32_t value)
non_null()
static bool tox_group_exit_type_from_int(uint32_t value, Tox_Group_Exit_Type *out)
{
switch (value) {
case 0:
return TOX_GROUP_EXIT_TYPE_QUIT;
case 1:
return TOX_GROUP_EXIT_TYPE_TIMEOUT;
case 2:
return TOX_GROUP_EXIT_TYPE_DISCONNECTED;
case 3:
return TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED;
case 4:
return TOX_GROUP_EXIT_TYPE_KICK;
case 5:
return TOX_GROUP_EXIT_TYPE_SYNC_ERROR;
default:
return TOX_GROUP_EXIT_TYPE_QUIT;
switch (value) {
case TOX_GROUP_EXIT_TYPE_QUIT: {
*out = TOX_GROUP_EXIT_TYPE_QUIT;
return true;
}
case TOX_GROUP_EXIT_TYPE_TIMEOUT: {
*out = TOX_GROUP_EXIT_TYPE_TIMEOUT;
return true;
}
case TOX_GROUP_EXIT_TYPE_DISCONNECTED: {
*out = TOX_GROUP_EXIT_TYPE_DISCONNECTED;
return true;
}
case TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED: {
*out = TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED;
return true;
}
case TOX_GROUP_EXIT_TYPE_KICK: {
*out = TOX_GROUP_EXIT_TYPE_KICK;
return true;
}
case TOX_GROUP_EXIT_TYPE_SYNC_ERROR: {
*out = TOX_GROUP_EXIT_TYPE_SYNC_ERROR;
return true;
}
default: {
*out = TOX_GROUP_EXIT_TYPE_QUIT;
return false;
}
}
}
bool tox_unpack_group_exit_type(Bin_Unpack *bu, Tox_Group_Exit_Type *val)
bool tox_group_exit_type_unpack(Bin_Unpack *bu, Tox_Group_Exit_Type *val)
{
uint32_t u32;
if (!bin_unpack_u32(bu, &u32)) {
return false;
}
*val = tox_group_exit_type_from_int(u32);
return true;
return bin_unpack_u32(bu, &u32)
&& tox_group_exit_type_from_int(u32, val);
}

22
external/toxcore/c-toxcore/toxcore/tox_unpack.h vendored
View File

@ -9,16 +9,16 @@
#include "bin_unpack.h"
#include "tox.h"
non_null() bool tox_unpack_conference_type(Bin_Unpack *bu, Tox_Conference_Type *val);
non_null() bool tox_unpack_connection(Bin_Unpack *bu, Tox_Connection *val);
non_null() bool tox_unpack_file_control(Bin_Unpack *bu, Tox_File_Control *val);
non_null() bool tox_unpack_message_type(Bin_Unpack *bu, Tox_Message_Type *val);
non_null() bool tox_unpack_user_status(Bin_Unpack *bu, Tox_User_Status *val);
non_null() bool tox_unpack_group_privacy_state(Bin_Unpack *bu, Tox_Group_Privacy_State *val);
non_null() bool tox_unpack_group_voice_state(Bin_Unpack *bu, Tox_Group_Voice_State *val);
non_null() bool tox_unpack_group_topic_lock(Bin_Unpack *bu, Tox_Group_Topic_Lock *val);
non_null() bool tox_unpack_group_join_fail(Bin_Unpack *bu, Tox_Group_Join_Fail *val);
non_null() bool tox_unpack_group_mod_event(Bin_Unpack *bu, Tox_Group_Mod_Event *val);
non_null() bool tox_unpack_group_exit_type(Bin_Unpack *bu, Tox_Group_Exit_Type *val);
non_null() bool tox_conference_type_unpack(Bin_Unpack *bu, Tox_Conference_Type *val);
non_null() bool tox_connection_unpack(Bin_Unpack *bu, Tox_Connection *val);
non_null() bool tox_file_control_unpack(Bin_Unpack *bu, Tox_File_Control *val);
non_null() bool tox_message_type_unpack(Bin_Unpack *bu, Tox_Message_Type *val);
non_null() bool tox_user_status_unpack(Bin_Unpack *bu, Tox_User_Status *val);
non_null() bool tox_group_privacy_state_unpack(Bin_Unpack *bu, Tox_Group_Privacy_State *val);
non_null() bool tox_group_voice_state_unpack(Bin_Unpack *bu, Tox_Group_Voice_State *val);
non_null() bool tox_group_topic_lock_unpack(Bin_Unpack *bu, Tox_Group_Topic_Lock *val);
non_null() bool tox_group_join_fail_unpack(Bin_Unpack *bu, Tox_Group_Join_Fail *val);
non_null() bool tox_group_mod_event_unpack(Bin_Unpack *bu, Tox_Group_Mod_Event *val);
non_null() bool tox_group_exit_type_unpack(Bin_Unpack *bu, Tox_Group_Exit_Type *val);
#endif // C_TOXCORE_TOXCORE_TOX_UNPACK_H