Tha_14/tomato-testing
1
0
Fork 0
forked from Green-Sky/tomato
Code Pull Requests Actions Packages Releases Activity

Squashed 'external/toxcore/c-toxcore/' changes from e29e185c03..f1df709b87

Browse Source 
f1df709b87 feat: add ngc events
1b6c907235 refactor: Make event dispatch ordered by receive time.
b7f9367f6f test: Upgrade cppcheck, fix some warnings.
766e62bc89 chore: Use `pkg_search_module` directly in cmake.
00ff078f91 cleanup: Use target_link_libraries directly in cmake.
c58928cc89 chore: Add `IMPORTED_TARGET` to pkg-config packages.
895a6af122 cleanup: Remove NaCl support.
41dfb1c1c0 fix: unpack enum function names in event impl generator
447666d1a1 chore: Disable targets for cross-compilation.
572924e924 chore: Build a docker image with coverage info in it.
415cb78f5e cleanup: Some portability/warning fixes for Windows builds.
425216d9ec fix: Correct a use-after-free and fix some memory leaks.
4b1cfa3e08 refactor: Change all enum-like `#define` sequences into enums.
d3c2704fa9 chore: Fix make_single_file to support core-only.
0ce46b644e refactor: Change the `TCP_PACKET_*` defines into an enum.
22cd38ad50 adopt event impl generation tool to #2392
f31ea1088a add the event impl generation tool
4e603bb613 refactor: Use `enum-from-int` rule from tokstyle.
19d8f180d6 chore: Update github actions `uses`.
6a895be0c7 test: Make esp32 build actually try to instantiate tox.
65d09c9bfb cleanup: Remove test net support.
REVERT: e29e185c03 feat: add ngc events

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: f1df709b8792da4c0e946d826b11df77d565064d
This commit is contained in:
Green Sky
2023-12-27 12:37:22 +01:00
parent 83e200df43
commit b2ae9530a4
173 changed files with 9191 additions and 5633 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
toxcore/events/conference_connected.c
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
toxcore/events/conference_invite.c
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
toxcore/events/conference_message.c
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
toxcore/events/conference_peer_list_changed.c
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
toxcore/events/conference_peer_name.c
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
toxcore/events/conference_title.c
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
toxcore/events/events_alloc.c
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
toxcore/events/events_alloc.h
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
toxcore/events/file_chunk_request.c
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
toxcore/events/file_recv.c
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
toxcore/events/file_recv_chunk.c
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
toxcore/events/file_recv_control.c
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
toxcore/events/friend_connection_status.c
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
toxcore/events/friend_lossless_packet.c
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
toxcore/events/friend_lossy_packet.c
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
toxcore/events/friend_message.c
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
toxcore/events/friend_name.c
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
toxcore/events/friend_read_receipt.c
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
toxcore/events/friend_request.c
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
toxcore/events/friend_status.c
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
toxcore/events/friend_status_message.c
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
toxcore/events/friend_typing.c
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
toxcore/events/group_custom_packet.c
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
toxcore/events/group_custom_private_packet.c
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
toxcore/events/group_invite.c
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
toxcore/events/group_join_fail.c
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
toxcore/events/group_message.c
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
toxcore/events/group_moderation.c
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
toxcore/events/group_password.c
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
toxcore/events/group_peer_exit.c
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
toxcore/events/group_peer_join.c
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
toxcore/events/group_peer_limit.c
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
toxcore/events/group_peer_name.c
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
toxcore/events/group_peer_status.c
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
toxcore/events/group_privacy_state.c
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
toxcore/events/group_private_message.c
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
toxcore/events/group_self_join.c
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
toxcore/events/group_topic.c
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
toxcore/events/group_topic_lock.c
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
toxcore/events/group_voice_state.c
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
toxcore/events/self_connection_status.c
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;
}