/work/toxcore/events/group_private_message.c

Source (jump to first uncovered line)
/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright © 2023-2025 The TokTok team.
 */

#include "events_alloc.h"

#include <assert.h>
#include <stdlib.h>
#include <string.h>

#include "../attributes.h"
#include "../bin_pack.h"
#include "../bin_unpack.h"
#include "../ccompat.h"
#include "../mem.h"
#include "../tox.h"
#include "../tox_event.h"
#include "../tox_events.h"
#include "../tox_pack.h"
#include "../tox_unpack.h"

/*****************************************************
 *
 * :: struct and accessors
 *
 *****************************************************/

struct Tox_Event_Group_Private_Message {
    uint32_t group_number;
    uint32_t peer_id;
    Tox_Message_Type message_type;
    uint8_t *message;
    uint32_t message_length;
    uint32_t message_id;
};

static void tox_event_group_private_message_set_group_number(Tox_Event_Group_Private_Message *_Nonnull group_private_message, uint32_t group_number)
{
    assert(group_private_message != nullptr);
    group_private_message->group_number = group_number;
}
uint32_t tox_event_group_private_message_get_group_number(const Tox_Event_Group_Private_Message *group_private_message)
{
    assert(group_private_message != nullptr);
    return group_private_message->group_number;
}

static void tox_event_group_private_message_set_peer_id(Tox_Event_Group_Private_Message *_Nonnull group_private_message, uint32_t peer_id)
{
    assert(group_private_message != nullptr);
    group_private_message->peer_id = peer_id;
}
uint32_t tox_event_group_private_message_get_peer_id(const Tox_Event_Group_Private_Message *group_private_message)
{
    assert(group_private_message != nullptr);
    return group_private_message->peer_id;
}

static void tox_event_group_private_message_set_message_type(Tox_Event_Group_Private_Message *_Nonnull group_private_message, Tox_Message_Type message_type)
{
    assert(group_private_message != nullptr);
    group_private_message->message_type = message_type;
}
Tox_Message_Type tox_event_group_private_message_get_message_type(const Tox_Event_Group_Private_Message *group_private_message)
{
    assert(group_private_message != nullptr);
    return group_private_message->message_type;
}

static bool tox_event_group_private_message_set_message(Tox_Event_Group_Private_Message *_Nonnull group_private_message,
        const uint8_t *_Nullable message, uint32_t message_length)
{
    assert(group_private_message != nullptr);
    if (group_private_message->message != nullptr) {
        free(group_private_message->message);
        group_private_message->message = nullptr;
        group_private_message->message_length = 0;
    }

    if (message == nullptr) {
        assert(message_length == 0);
        return true;
    }

    uint8_t *message_copy = (uint8_t *)malloc(message_length);

    if (message_copy == nullptr) {
        return false;
    }

    memcpy(message_copy, message, message_length);
    group_private_message->message = message_copy;
    group_private_message->message_length = message_length;
    return true;
}
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;
}
const uint8_t *tox_event_group_private_message_get_message(const Tox_Event_Group_Private_Message *group_private_message)
{
    assert(group_private_message != nullptr);
    return group_private_message->message;
}

static void tox_event_group_private_message_set_message_id(Tox_Event_Group_Private_Message *_Nonnull group_private_message, uint32_t message_id)
{
    assert(group_private_message != nullptr);
    group_private_message->message_id = message_id;
}
uint32_t tox_event_group_private_message_get_message_id(const Tox_Event_Group_Private_Message *group_private_message)
{
    assert(group_private_message != nullptr);
    return group_private_message->message_id;
}

static void tox_event_group_private_message_construct(Tox_Event_Group_Private_Message *_Nonnull group_private_message)
{
    *group_private_message = (Tox_Event_Group_Private_Message) {
        0
    };
}
static void tox_event_group_private_message_destruct(Tox_Event_Group_Private_Message *_Nonnull group_private_message, const Memory *_Nonnull mem)
{
    free(group_private_message->message);
}

bool tox_event_group_private_message_pack(
    const Tox_Event_Group_Private_Message *event, Bin_Pack *bp)
{
    return bin_pack_array(bp, 5)
           && bin_pack_u32(bp, event->group_number)
           && bin_pack_u32(bp, event->peer_id)
           && tox_message_type_pack(event->message_type, bp)
           && bin_pack_bin(bp, event->message, event->message_length)
           && bin_pack_u32(bp, event->message_id);
}

static bool tox_event_group_private_message_unpack_into(Tox_Event_Group_Private_Message *_Nonnull event, Bin_Unpack *_Nonnull bu)
{
    assert(event != nullptr);
    if (!bin_unpack_array_fixed(bu, 5, nullptr)) {
        return false;
    }

    return bin_unpack_u32(bu, &event->group_number)
           && bin_unpack_u32(bu, &event->peer_id)
           && tox_message_type_unpack(&event->message_type, bu)
           && bin_unpack_bin(bu, &event->message, &event->message_length)
           && bin_unpack_u32(bu, &event->message_id);
}

/*****************************************************
 *
 * :: new/free/add/get/size/unpack
 *
 *****************************************************/

const Tox_Event_Group_Private_Message *tox_event_get_group_private_message(const Tox_Event *event)
{
    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;
    }

    tox_event_group_private_message_construct(group_private_message);
    return group_private_message;
}

void tox_event_group_private_message_free(Tox_Event_Group_Private_Message *group_private_message, const Memory *mem)
{
    if (group_private_message != nullptr) {
        tox_event_group_private_message_destruct(group_private_message, mem);
    }
    mem_delete(mem, group_private_message);
}

static Tox_Event_Group_Private_Message *tox_events_add_group_private_message(Tox_Events *_Nonnull events, const Memory *_Nonnull mem)
{
    Tox_Event_Group_Private_Message *const group_private_message = tox_event_group_private_message_new(mem);

    if (group_private_message == nullptr) {
        return nullptr;
    }

    Tox_Event event;
    event.type = TOX_EVENT_GROUP_PRIVATE_MESSAGE;
    event.data.group_private_message = group_private_message;

    if (!tox_events_add(events, &event)) {
        tox_event_group_private_message_free(group_private_message, mem);
        return nullptr;
    }
    return group_private_message;
}

bool tox_event_group_private_message_unpack(
    Tox_Event_Group_Private_Message **event, Bin_Unpack *bu, const Memory *mem)
{
    assert(event != nullptr);
    assert(*event == nullptr);
    *event = tox_event_group_private_message_new(mem);

    if (*event == nullptr) {
        return false;
    }

    return tox_event_group_private_message_unpack_into(*event, bu);
}

static Tox_Event_Group_Private_Message *tox_event_group_private_message_alloc(void *_Nonnull user_data)
{
    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;
}

/*****************************************************
 *
 * :: event handler
 *
 *****************************************************/

void tox_events_handle_group_private_message(
    Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type message_type, const uint8_t *message, size_t message_length, uint32_t message_id,
    void *user_data)
{
    Tox_Event_Group_Private_Message *group_private_message = tox_event_group_private_message_alloc(user_data);

    if (group_private_message == nullptr) {
        return;
    }

    tox_event_group_private_message_set_group_number(group_private_message, group_number);
    tox_event_group_private_message_set_peer_id(group_private_message, peer_id);
    tox_event_group_private_message_set_message_type(group_private_message, message_type);
    tox_event_group_private_message_set_message(group_private_message, message, message_length);
    tox_event_group_private_message_set_message_id(group_private_message, message_id);
}

Coverage Report

Created: 2025-10-08 19:34

Line	Count	Source (jump to first uncovered line)
1		/* SPDX-License-Identifier: GPL-3.0-or-later
2		* Copyright © 2023-2025 The TokTok team.
3		*/
4
5		#include "events_alloc.h"
6
7		#include <assert.h>
8		#include <stdlib.h>
9		#include <string.h>
10
11		#include "../attributes.h"
12		#include "../bin_pack.h"
13		#include "../bin_unpack.h"
14		#include "../ccompat.h"
15		#include "../mem.h"
16		#include "../tox.h"
17		#include "../tox_event.h"
18		#include "../tox_events.h"
19		#include "../tox_pack.h"
20		#include "../tox_unpack.h"
21
22		/*****************************************************
23		*
24		* :: struct and accessors
25		*
26		*****************************************************/
27
28		struct Tox_Event_Group_Private_Message {
29		uint32_t group_number;
30		uint32_t peer_id;
31		Tox_Message_Type message_type;
32		uint8_t *message;
33		uint32_t message_length;
34		uint32_t message_id;
35		};
36
37		static void tox_event_group_private_message_set_group_number(Tox_Event_Group_Private_Message *_Nonnull group_private_message, uint32_t group_number)
38	1	{
39	1	assert(group_private_message != nullptr);
40	1	group_private_message->group_number = group_number;
41	1	}
42		uint32_t tox_event_group_private_message_get_group_number(const Tox_Event_Group_Private_Message *group_private_message)
43	1	{
44	1	assert(group_private_message != nullptr);
45	1	return group_private_message->group_number;
46	1	}
47
48		static void tox_event_group_private_message_set_peer_id(Tox_Event_Group_Private_Message *_Nonnull group_private_message, uint32_t peer_id)
49	1	{
50	1	assert(group_private_message != nullptr);
51	1	group_private_message->peer_id = peer_id;
52	1	}
53		uint32_t tox_event_group_private_message_get_peer_id(const Tox_Event_Group_Private_Message *group_private_message)
54	1	{
55	1	assert(group_private_message != nullptr);
56	1	return group_private_message->peer_id;
57	1	}
58
59		static void tox_event_group_private_message_set_message_type(Tox_Event_Group_Private_Message *_Nonnull group_private_message, Tox_Message_Type message_type)
60	1	{
61	1	assert(group_private_message != nullptr);
62	1	group_private_message->message_type = message_type;
63	1	}
64		Tox_Message_Type tox_event_group_private_message_get_message_type(const Tox_Event_Group_Private_Message *group_private_message)
65	1	{
66	1	assert(group_private_message != nullptr);
67	1	return group_private_message->message_type;
68	1	}
69
70		static bool tox_event_group_private_message_set_message(Tox_Event_Group_Private_Message *_Nonnull group_private_message,
71		const uint8_t *_Nullable message, uint32_t message_length)
72	1	{
73	1	assert(group_private_message != nullptr);
74	1	if (group_private_message->message != nullptr) {
75	0	free(group_private_message->message);
76	0	group_private_message->message = nullptr;
77	0	group_private_message->message_length = 0;
78	0	}
79
80	1	if (message == nullptr) {
81	0	assert(message_length == 0);
82	0	return true;
83	0	}
84
85	1	uint8_t message_copy = (uint8_t )malloc(message_length);
86
87	1	if (message_copy == nullptr) {
88	0	return false;
89	0	}
90
91	1	memcpy(message_copy, message, message_length);
92	1	group_private_message->message = message_copy;
93	1	group_private_message->message_length = message_length;
94	1	return true;
95	1	}
96		uint32_t tox_event_group_private_message_get_message_length(const Tox_Event_Group_Private_Message *group_private_message)
97	1	{
98	1	assert(group_private_message != nullptr);
99	1	return group_private_message->message_length;
100	1	}
101		const uint8_t tox_event_group_private_message_get_message(const Tox_Event_Group_Private_Message group_private_message)
102	1	{
103	1	assert(group_private_message != nullptr);
104	1	return group_private_message->message;
105	1	}
106
107		static void tox_event_group_private_message_set_message_id(Tox_Event_Group_Private_Message *_Nonnull group_private_message, uint32_t message_id)
108	1	{
109	1	assert(group_private_message != nullptr);
110	1	group_private_message->message_id = message_id;
111	1	}
112		uint32_t tox_event_group_private_message_get_message_id(const Tox_Event_Group_Private_Message *group_private_message)
113	1	{
114	1	assert(group_private_message != nullptr);
115	1	return group_private_message->message_id;
116	1	}
117
118		static void tox_event_group_private_message_construct(Tox_Event_Group_Private_Message *_Nonnull group_private_message)
119	32	{
120	32	*group_private_message = (Tox_Event_Group_Private_Message) {
121	32	0
122	32	};
123	32	}
124		static void tox_event_group_private_message_destruct(Tox_Event_Group_Private_Message _Nonnull group_private_message, const Memory _Nonnull mem)
125	32	{
126	32	free(group_private_message->message);
127	32	}
128
129		bool tox_event_group_private_message_pack(
130		const Tox_Event_Group_Private_Message event, Bin_Pack bp)
131	38	{
132	38	return bin_pack_array(bp, 5)
133	38	&& bin_pack_u32(bp, event->group_number)
134	38	&& bin_pack_u32(bp, event->peer_id)
135	38	&& tox_message_type_pack(event->message_type, bp)
136	38	&& bin_pack_bin(bp, event->message, event->message_length)
137	38	&& bin_pack_u32(bp, event->message_id);
138	38	}
139
140		static bool tox_event_group_private_message_unpack_into(Tox_Event_Group_Private_Message _Nonnull event, Bin_Unpack _Nonnull bu)
141	31	{
142	31	assert(event != nullptr);
143	31	if (!bin_unpack_array_fixed(bu, 5, nullptr)) {
144	3	return false;
145	3	}
146
147	28	return bin_unpack_u32(bu, &event->group_number)
148	28	&& bin_unpack_u32(bu, &event->peer_id)
149	28	&& tox_message_type_unpack(&event->message_type, bu)
150	28	&& bin_unpack_bin(bu, &event->message, &event->message_length)
151	28	&& bin_unpack_u32(bu, &event->message_id);
152	31	}
153
154		/*****************************************************
155		*
156		* :: new/free/add/get/size/unpack
157		*
158		*****************************************************/
159
160		const Tox_Event_Group_Private_Message tox_event_get_group_private_message(const Tox_Event event)
161	0	{
162	0	return event->type == TOX_EVENT_GROUP_PRIVATE_MESSAGE ? event->data.group_private_message : nullptr;
163	0	}
164
165		Tox_Event_Group_Private_Message tox_event_group_private_message_new(const Memory mem)
166	33	{
167	33	Tox_Event_Group_Private_Message *const group_private_message =
168	33	(Tox_Event_Group_Private_Message *)mem_alloc(mem, sizeof(Tox_Event_Group_Private_Message));
169
170	33	if (group_private_message == nullptr) {
171	1	return nullptr;
172	1	}
173
174	32	tox_event_group_private_message_construct(group_private_message);
175	32	return group_private_message;
176	33	}
177
178		void tox_event_group_private_message_free(Tox_Event_Group_Private_Message group_private_message, const Memory mem)
179	33	{
180	33	if (group_private_message != nullptr) {
181	32	tox_event_group_private_message_destruct(group_private_message, mem);
182	32	}
183	33	mem_delete(mem, group_private_message);
184	33	}
185
186		static Tox_Event_Group_Private_Message tox_events_add_group_private_message(Tox_Events _Nonnull events, const Memory *_Nonnull mem)
187	1	{
188	1	Tox_Event_Group_Private_Message *const group_private_message = tox_event_group_private_message_new(mem);
189
190	1	if (group_private_message == nullptr) {
191	0	return nullptr;
192	0	}
193
194	1	Tox_Event event;
195	1	event.type = TOX_EVENT_GROUP_PRIVATE_MESSAGE;
196	1	event.data.group_private_message = group_private_message;
197
198	1	if (!tox_events_add(events, &event)) {
199	0	tox_event_group_private_message_free(group_private_message, mem);
200	0	return nullptr;
201	0	}
202	1	return group_private_message;
203	1	}
204
205		bool tox_event_group_private_message_unpack(
206		Tox_Event_Group_Private_Message *event, Bin_Unpack bu, const Memory *mem)
207	32	{
208	32	assert(event != nullptr);
209	32	assert(*event == nullptr);
210	32	*event = tox_event_group_private_message_new(mem);
211
212	32	if (*event == nullptr) {
213	1	return false;
214	1	}
215
216	31	return tox_event_group_private_message_unpack_into(*event, bu);
217	32	}
218
219		static Tox_Event_Group_Private_Message tox_event_group_private_message_alloc(void _Nonnull user_data)
220	1	{
221	1	Tox_Events_State *state = tox_events_alloc(user_data);
222	1	assert(state != nullptr);
223
224	1	if (state->events == nullptr) {
225	0	return nullptr;
226	0	}
227
228	1	Tox_Event_Group_Private_Message *group_private_message = tox_events_add_group_private_message(state->events, state->mem);
229
230	1	if (group_private_message == nullptr) {
231	0	state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
232	0	return nullptr;
233	0	}
234
235	1	return group_private_message;
236	1	}
237
238		/*****************************************************
239		*
240		* :: event handler
241		*
242		*****************************************************/
243
244		void tox_events_handle_group_private_message(
245		Tox tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type message_type, const uint8_t message, size_t message_length, uint32_t message_id,
246		void *user_data)
247	1	{
248	1	Tox_Event_Group_Private_Message *group_private_message = tox_event_group_private_message_alloc(user_data);
249
250	1	if (group_private_message == nullptr) {
251	0	return;
252	0	}
253
254	1	tox_event_group_private_message_set_group_number(group_private_message, group_number);
255	1	tox_event_group_private_message_set_peer_id(group_private_message, peer_id);
256	1	tox_event_group_private_message_set_message_type(group_private_message, message_type);
257	1	tox_event_group_private_message_set_message(group_private_message, message, message_length);
258	1	tox_event_group_private_message_set_message_id(group_private_message, message_id);
259	1	}