/work/toxcore/tox_unpack.c

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

#include "tox_unpack.h"

#include <stdint.h>

#include "attributes.h"
#include "bin_unpack.h"
#include "tox.h"

static bool tox_conference_type_from_int(uint32_t value, Tox_Conference_Type *_Nonnull out_enum)
{
    switch (value) {
        case TOX_CONFERENCE_TYPE_TEXT: {
            *out_enum = TOX_CONFERENCE_TYPE_TEXT;
            return true;
        }

        case TOX_CONFERENCE_TYPE_AV: {
            *out_enum = TOX_CONFERENCE_TYPE_AV;
            return true;
        }

        default: {
            *out_enum = TOX_CONFERENCE_TYPE_TEXT;
            return false;
        }
    }
}
bool tox_conference_type_unpack(Tox_Conference_Type *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_conference_type_from_int(u32, val);
}

static bool tox_connection_from_int(uint32_t value, Tox_Connection *_Nonnull out_enum)
{
    switch (value) {
        case TOX_CONNECTION_NONE: {
            *out_enum = TOX_CONNECTION_NONE;
            return true;
        }

        case TOX_CONNECTION_TCP: {
            *out_enum = TOX_CONNECTION_TCP;
            return true;
        }

        case TOX_CONNECTION_UDP: {
            *out_enum = TOX_CONNECTION_UDP;
            return true;
        }

        default: {
            *out_enum = TOX_CONNECTION_NONE;
            return false;
        }
    }
}

bool tox_connection_unpack(Tox_Connection *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_connection_from_int(u32, val);
}

static bool tox_file_control_from_int(uint32_t value, Tox_File_Control *_Nonnull out_enum)
{
    switch (value) {
        case TOX_FILE_CONTROL_RESUME: {
            *out_enum = TOX_FILE_CONTROL_RESUME;
            return true;
        }

        case TOX_FILE_CONTROL_PAUSE: {
            *out_enum = TOX_FILE_CONTROL_PAUSE;
            return true;
        }

        case TOX_FILE_CONTROL_CANCEL: {
            *out_enum = TOX_FILE_CONTROL_CANCEL;
            return true;
        }

        default: {
            *out_enum = TOX_FILE_CONTROL_RESUME;
            return false;
        }
    }
}

bool tox_file_control_unpack(Tox_File_Control *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_file_control_from_int(u32, val);
}

static bool tox_message_type_from_int(uint32_t value, Tox_Message_Type *_Nonnull out_enum)
{
    switch (value) {
        case TOX_MESSAGE_TYPE_NORMAL: {
            *out_enum = TOX_MESSAGE_TYPE_NORMAL;
            return true;
        }

        case TOX_MESSAGE_TYPE_ACTION: {
            *out_enum = TOX_MESSAGE_TYPE_ACTION;
            return true;
        }

        default: {
            *out_enum = TOX_MESSAGE_TYPE_NORMAL;
            return false;
        }
    }
}

bool tox_message_type_unpack(Tox_Message_Type *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_message_type_from_int(u32, val);
}

static bool tox_user_status_from_int(uint32_t value, Tox_User_Status *_Nonnull out_enum)
{
    switch (value) {
        case TOX_USER_STATUS_NONE: {
            *out_enum = TOX_USER_STATUS_NONE;
            return true;
        }

        case TOX_USER_STATUS_AWAY: {
            *out_enum = TOX_USER_STATUS_AWAY;
            return true;
        }

        case TOX_USER_STATUS_BUSY: {
            *out_enum = TOX_USER_STATUS_BUSY;
            return true;
        }

        default: {
            *out_enum = TOX_USER_STATUS_NONE;
            return false;
        }
    }
}

bool tox_user_status_unpack(Tox_User_Status *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_user_status_from_int(u32, val);
}

static bool tox_group_privacy_state_from_int(uint32_t value, Tox_Group_Privacy_State *_Nonnull out_enum)
{
    switch (value) {
        case TOX_GROUP_PRIVACY_STATE_PUBLIC: {
            *out_enum = TOX_GROUP_PRIVACY_STATE_PUBLIC;
            return true;
        }
        case TOX_GROUP_PRIVACY_STATE_PRIVATE: {
            *out_enum = TOX_GROUP_PRIVACY_STATE_PRIVATE;
            return true;
        }
        default: {
            *out_enum = TOX_GROUP_PRIVACY_STATE_PUBLIC;
            return false;
        }
    }
}
bool tox_group_privacy_state_unpack(Tox_Group_Privacy_State *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_group_privacy_state_from_int(u32, val);
}
static bool tox_group_voice_state_from_int(uint32_t value, Tox_Group_Voice_State *_Nonnull out_enum)
{
    switch (value) {
        case TOX_GROUP_VOICE_STATE_ALL: {
            *out_enum = TOX_GROUP_VOICE_STATE_ALL;
            return true;
        }
        case TOX_GROUP_VOICE_STATE_MODERATOR: {
            *out_enum = TOX_GROUP_VOICE_STATE_MODERATOR;
            return true;
        }
        case TOX_GROUP_VOICE_STATE_FOUNDER: {
            *out_enum = TOX_GROUP_VOICE_STATE_FOUNDER;
            return true;
        }
        default: {
            *out_enum = TOX_GROUP_VOICE_STATE_ALL;
            return false;
        }
    }
}
bool tox_group_voice_state_unpack(Tox_Group_Voice_State *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_group_voice_state_from_int(u32, val);
}

static bool tox_group_topic_lock_from_int(uint32_t value, Tox_Group_Topic_Lock *_Nonnull out_enum)
{
    switch (value) {
        case TOX_GROUP_TOPIC_LOCK_ENABLED: {
            *out_enum = TOX_GROUP_TOPIC_LOCK_ENABLED;
            return true;
        }
        case TOX_GROUP_TOPIC_LOCK_DISABLED: {
            *out_enum = TOX_GROUP_TOPIC_LOCK_DISABLED;
            return true;
        }
        default: {
            *out_enum = TOX_GROUP_TOPIC_LOCK_ENABLED;
            return false;
        }
    }
}
bool tox_group_topic_lock_unpack(Tox_Group_Topic_Lock *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_group_topic_lock_from_int(u32, val);
}

static bool tox_group_join_fail_from_int(uint32_t value, Tox_Group_Join_Fail *_Nonnull out_enum)
{
    switch (value) {
        case TOX_GROUP_JOIN_FAIL_PEER_LIMIT: {
            *out_enum = TOX_GROUP_JOIN_FAIL_PEER_LIMIT;
            return true;
        }
        case TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD: {
            *out_enum = TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD;
            return true;
        }
        case TOX_GROUP_JOIN_FAIL_UNKNOWN: {
            *out_enum = TOX_GROUP_JOIN_FAIL_UNKNOWN;
            return true;
        }
        default: {
            *out_enum = TOX_GROUP_JOIN_FAIL_PEER_LIMIT;
            return false;
        }
    }
}
bool tox_group_join_fail_unpack(Tox_Group_Join_Fail *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_group_join_fail_from_int(u32, val);
}

static bool tox_group_mod_event_from_int(uint32_t value, Tox_Group_Mod_Event *_Nonnull out_enum)
{
    switch (value) {
        case TOX_GROUP_MOD_EVENT_KICK: {
            *out_enum = TOX_GROUP_MOD_EVENT_KICK;
            return true;
        }
        case TOX_GROUP_MOD_EVENT_OBSERVER: {
            *out_enum = TOX_GROUP_MOD_EVENT_OBSERVER;
            return true;
        }
        case TOX_GROUP_MOD_EVENT_USER: {
            *out_enum = TOX_GROUP_MOD_EVENT_USER;
            return true;
        }
        case TOX_GROUP_MOD_EVENT_MODERATOR: {
            *out_enum = TOX_GROUP_MOD_EVENT_MODERATOR;
            return true;
        }
        default: {
            *out_enum = TOX_GROUP_MOD_EVENT_KICK;
            return false;
        }
    }
}
bool tox_group_mod_event_unpack(Tox_Group_Mod_Event *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_group_mod_event_from_int(u32, val);
}

static bool tox_group_exit_type_from_int(uint32_t value, Tox_Group_Exit_Type *_Nonnull out_enum)
{
    switch (value) {
        case TOX_GROUP_EXIT_TYPE_QUIT: {
            *out_enum = TOX_GROUP_EXIT_TYPE_QUIT;
            return true;
        }
        case TOX_GROUP_EXIT_TYPE_TIMEOUT: {
            *out_enum = TOX_GROUP_EXIT_TYPE_TIMEOUT;
            return true;
        }
        case TOX_GROUP_EXIT_TYPE_DISCONNECTED: {
            *out_enum = TOX_GROUP_EXIT_TYPE_DISCONNECTED;
            return true;
        }
        case TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED: {
            *out_enum = TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED;
            return true;
        }
        case TOX_GROUP_EXIT_TYPE_KICK: {
            *out_enum = TOX_GROUP_EXIT_TYPE_KICK;
            return true;
        }
        case TOX_GROUP_EXIT_TYPE_SYNC_ERROR: {
            *out_enum = TOX_GROUP_EXIT_TYPE_SYNC_ERROR;
            return true;
        }
        default: {
            *out_enum = TOX_GROUP_EXIT_TYPE_QUIT;
            return false;
        }
    }
}
bool tox_group_exit_type_unpack(Tox_Group_Exit_Type *val, Bin_Unpack *bu)
{
    uint32_t u32;
    return bin_unpack_u32(bu, &u32)
           && tox_group_exit_type_from_int(u32, val);
}

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 © 2022-2025 The TokTok team.
3		*/
4
5		#include "tox_unpack.h"
6
7		#include <stdint.h>
8
9		#include "attributes.h"
10		#include "bin_unpack.h"
11		#include "tox.h"
12
13		static bool tox_conference_type_from_int(uint32_t value, Tox_Conference_Type *_Nonnull out_enum)
14	21	{
15	21	switch (value) {
16	12	case TOX_CONFERENCE_TYPE_TEXT: {
17	12	*out_enum = TOX_CONFERENCE_TYPE_TEXT;
18	12	return true;
19	0	}
20
21	8	case TOX_CONFERENCE_TYPE_AV: {
22	8	*out_enum = TOX_CONFERENCE_TYPE_AV;
23	8	return true;
24	0	}
25
26	1	default: {
27	1	*out_enum = TOX_CONFERENCE_TYPE_TEXT;
28	1	return false;
29	0	}
30	21	}
31	21	}
32		bool tox_conference_type_unpack(Tox_Conference_Type val, Bin_Unpack bu)
33	22	{
34	22	uint32_t u32;
35	22	return bin_unpack_u32(bu, &u32)
36	22	&& tox_conference_type_from_int(u32, val);
37	22	}
38
39		static bool tox_connection_from_int(uint32_t value, Tox_Connection *_Nonnull out_enum)
40	213	{
41	213	switch (value) {
42	121	case TOX_CONNECTION_NONE: {
43	121	*out_enum = TOX_CONNECTION_NONE;
44	121	return true;
45	0	}
46
47	60	case TOX_CONNECTION_TCP: {
48	60	*out_enum = TOX_CONNECTION_TCP;
49	60	return true;
50	0	}
51
52	31	case TOX_CONNECTION_UDP: {
53	31	*out_enum = TOX_CONNECTION_UDP;
54	31	return true;
55	0	}
56
57	1	default: {
58	1	*out_enum = TOX_CONNECTION_NONE;
59	1	return false;
60	0	}
61	213	}
62	213	}
63
64		bool tox_connection_unpack(Tox_Connection val, Bin_Unpack bu)
65	216	{
66	216	uint32_t u32;
67	216	return bin_unpack_u32(bu, &u32)
68	216	&& tox_connection_from_int(u32, val);
69	216	}
70
71		static bool tox_file_control_from_int(uint32_t value, Tox_File_Control *_Nonnull out_enum)
72	29	{
73	29	switch (value) {
74	11	case TOX_FILE_CONTROL_RESUME: {
75	11	*out_enum = TOX_FILE_CONTROL_RESUME;
76	11	return true;
77	0	}
78
79	3	case TOX_FILE_CONTROL_PAUSE: {
80	3	*out_enum = TOX_FILE_CONTROL_PAUSE;
81	3	return true;
82	0	}
83
84	14	case TOX_FILE_CONTROL_CANCEL: {
85	14	*out_enum = TOX_FILE_CONTROL_CANCEL;
86	14	return true;
87	0	}
88
89	1	default: {
90	1	*out_enum = TOX_FILE_CONTROL_RESUME;
91	1	return false;
92	0	}
93	29	}
94	29	}
95
96		bool tox_file_control_unpack(Tox_File_Control val, Bin_Unpack bu)
97	31	{
98	31	uint32_t u32;
99	31	return bin_unpack_u32(bu, &u32)
100	31	&& tox_file_control_from_int(u32, val);
101	31	}
102
103		static bool tox_message_type_from_int(uint32_t value, Tox_Message_Type *_Nonnull out_enum)
104	83	{
105	83	switch (value) {
106	29	case TOX_MESSAGE_TYPE_NORMAL: {
107	29	*out_enum = TOX_MESSAGE_TYPE_NORMAL;
108	29	return true;
109	0	}
110
111	51	case TOX_MESSAGE_TYPE_ACTION: {
112	51	*out_enum = TOX_MESSAGE_TYPE_ACTION;
113	51	return true;
114	0	}
115
116	3	default: {
117	3	*out_enum = TOX_MESSAGE_TYPE_NORMAL;
118	3	return false;
119	0	}
120	83	}
121	83	}
122
123		bool tox_message_type_unpack(Tox_Message_Type val, Bin_Unpack bu)
124	89	{
125	89	uint32_t u32;
126	89	return bin_unpack_u32(bu, &u32)
127	89	&& tox_message_type_from_int(u32, val);
128	89	}
129
130		static bool tox_user_status_from_int(uint32_t value, Tox_User_Status *_Nonnull out_enum)
131	39	{
132	39	switch (value) {
133	15	case TOX_USER_STATUS_NONE: {
134	15	*out_enum = TOX_USER_STATUS_NONE;
135	15	return true;
136	0	}
137
138	12	case TOX_USER_STATUS_AWAY: {
139	12	*out_enum = TOX_USER_STATUS_AWAY;
140	12	return true;
141	0	}
142
143	11	case TOX_USER_STATUS_BUSY: {
144	11	*out_enum = TOX_USER_STATUS_BUSY;
145	11	return true;
146	0	}
147
148	1	default: {
149	1	*out_enum = TOX_USER_STATUS_NONE;
150	1	return false;
151	0	}
152	39	}
153	39	}
154
155		bool tox_user_status_unpack(Tox_User_Status val, Bin_Unpack bu)
156	43	{
157	43	uint32_t u32;
158	43	return bin_unpack_u32(bu, &u32)
159	43	&& tox_user_status_from_int(u32, val);
160	43	}
161
162		static bool tox_group_privacy_state_from_int(uint32_t value, Tox_Group_Privacy_State *_Nonnull out_enum)
163	21	{
164	21	switch (value) {
165	10	case TOX_GROUP_PRIVACY_STATE_PUBLIC: {
166	10	*out_enum = TOX_GROUP_PRIVACY_STATE_PUBLIC;
167	10	return true;
168	0	}
169	10	case TOX_GROUP_PRIVACY_STATE_PRIVATE: {
170	10	*out_enum = TOX_GROUP_PRIVACY_STATE_PRIVATE;
171	10	return true;
172	0	}
173	1	default: {
174	1	*out_enum = TOX_GROUP_PRIVACY_STATE_PUBLIC;
175	1	return false;
176	0	}
177	21	}
178	21	}
179		bool tox_group_privacy_state_unpack(Tox_Group_Privacy_State val, Bin_Unpack bu)
180	22	{
181	22	uint32_t u32;
182	22	return bin_unpack_u32(bu, &u32)
183	22	&& tox_group_privacy_state_from_int(u32, val);
184	22	}
185		static bool tox_group_voice_state_from_int(uint32_t value, Tox_Group_Voice_State *_Nonnull out_enum)
186	42	{
187	42	switch (value) {
188	7	case TOX_GROUP_VOICE_STATE_ALL: {
189	7	*out_enum = TOX_GROUP_VOICE_STATE_ALL;
190	7	return true;
191	0	}
192	24	case TOX_GROUP_VOICE_STATE_MODERATOR: {
193	24	*out_enum = TOX_GROUP_VOICE_STATE_MODERATOR;
194	24	return true;
195	0	}
196	10	case TOX_GROUP_VOICE_STATE_FOUNDER: {
197	10	*out_enum = TOX_GROUP_VOICE_STATE_FOUNDER;
198	10	return true;
199	0	}
200	1	default: {
201	1	*out_enum = TOX_GROUP_VOICE_STATE_ALL;
202	1	return false;
203	0	}
204	42	}
205	42	}
206		bool tox_group_voice_state_unpack(Tox_Group_Voice_State val, Bin_Unpack bu)
207	45	{
208	45	uint32_t u32;
209	45	return bin_unpack_u32(bu, &u32)
210	45	&& tox_group_voice_state_from_int(u32, val);
211	45	}
212
213		static bool tox_group_topic_lock_from_int(uint32_t value, Tox_Group_Topic_Lock *_Nonnull out_enum)
214	21	{
215	21	switch (value) {
216	10	case TOX_GROUP_TOPIC_LOCK_ENABLED: {
217	10	*out_enum = TOX_GROUP_TOPIC_LOCK_ENABLED;
218	10	return true;
219	0	}
220	10	case TOX_GROUP_TOPIC_LOCK_DISABLED: {
221	10	*out_enum = TOX_GROUP_TOPIC_LOCK_DISABLED;
222	10	return true;
223	0	}
224	1	default: {
225	1	*out_enum = TOX_GROUP_TOPIC_LOCK_ENABLED;
226	1	return false;
227	0	}
228	21	}
229	21	}
230		bool tox_group_topic_lock_unpack(Tox_Group_Topic_Lock val, Bin_Unpack bu)
231	22	{
232	22	uint32_t u32;
233	22	return bin_unpack_u32(bu, &u32)
234	22	&& tox_group_topic_lock_from_int(u32, val);
235	22	}
236
237		static bool tox_group_join_fail_from_int(uint32_t value, Tox_Group_Join_Fail *_Nonnull out_enum)
238	23	{
239	23	switch (value) {
240	8	case TOX_GROUP_JOIN_FAIL_PEER_LIMIT: {
241	8	*out_enum = TOX_GROUP_JOIN_FAIL_PEER_LIMIT;
242	8	return true;
243	0	}
244	10	case TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD: {
245	10	*out_enum = TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD;
246	10	return true;
247	0	}
248	4	case TOX_GROUP_JOIN_FAIL_UNKNOWN: {
249	4	*out_enum = TOX_GROUP_JOIN_FAIL_UNKNOWN;
250	4	return true;
251	0	}
252	1	default: {
253	1	*out_enum = TOX_GROUP_JOIN_FAIL_PEER_LIMIT;
254	1	return false;
255	0	}
256	23	}
257	23	}
258		bool tox_group_join_fail_unpack(Tox_Group_Join_Fail val, Bin_Unpack bu)
259	24	{
260	24	uint32_t u32;
261	24	return bin_unpack_u32(bu, &u32)
262	24	&& tox_group_join_fail_from_int(u32, val);
263	24	}
264
265		static bool tox_group_mod_event_from_int(uint32_t value, Tox_Group_Mod_Event *_Nonnull out_enum)
266	31	{
267	31	switch (value) {
268	6	case TOX_GROUP_MOD_EVENT_KICK: {
269	6	*out_enum = TOX_GROUP_MOD_EVENT_KICK;
270	6	return true;
271	0	}
272	3	case TOX_GROUP_MOD_EVENT_OBSERVER: {
273	3	*out_enum = TOX_GROUP_MOD_EVENT_OBSERVER;
274	3	return true;
275	0	}
276	10	case TOX_GROUP_MOD_EVENT_USER: {
277	10	*out_enum = TOX_GROUP_MOD_EVENT_USER;
278	10	return true;
279	0	}
280	10	case TOX_GROUP_MOD_EVENT_MODERATOR: {
281	10	*out_enum = TOX_GROUP_MOD_EVENT_MODERATOR;
282	10	return true;
283	0	}
284	2	default: {
285	2	*out_enum = TOX_GROUP_MOD_EVENT_KICK;
286	2	return false;
287	0	}
288	31	}
289	31	}
290		bool tox_group_mod_event_unpack(Tox_Group_Mod_Event val, Bin_Unpack bu)
291	35	{
292	35	uint32_t u32;
293	35	return bin_unpack_u32(bu, &u32)
294	35	&& tox_group_mod_event_from_int(u32, val);
295	35	}
296
297		static bool tox_group_exit_type_from_int(uint32_t value, Tox_Group_Exit_Type *_Nonnull out_enum)
298	50	{
299	50	switch (value) {
300	7	case TOX_GROUP_EXIT_TYPE_QUIT: {
301	7	*out_enum = TOX_GROUP_EXIT_TYPE_QUIT;
302	7	return true;
303	0	}
304	20	case TOX_GROUP_EXIT_TYPE_TIMEOUT: {
305	20	*out_enum = TOX_GROUP_EXIT_TYPE_TIMEOUT;
306	20	return true;
307	0	}
308	3	case TOX_GROUP_EXIT_TYPE_DISCONNECTED: {
309	3	*out_enum = TOX_GROUP_EXIT_TYPE_DISCONNECTED;
310	3	return true;
311	0	}
312	12	case TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED: {
313	12	*out_enum = TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED;
314	12	return true;
315	0	}
316	4	case TOX_GROUP_EXIT_TYPE_KICK: {
317	4	*out_enum = TOX_GROUP_EXIT_TYPE_KICK;
318	4	return true;
319	0	}
320	3	case TOX_GROUP_EXIT_TYPE_SYNC_ERROR: {
321	3	*out_enum = TOX_GROUP_EXIT_TYPE_SYNC_ERROR;
322	3	return true;
323	0	}
324	1	default: {
325	1	*out_enum = TOX_GROUP_EXIT_TYPE_QUIT;
326	1	return false;
327	0	}
328	50	}
329	50	}
330		bool tox_group_exit_type_unpack(Tox_Group_Exit_Type val, Bin_Unpack bu)
331	51	{
332	51	uint32_t u32;
333	51	return bin_unpack_u32(bu, &u32)
334	51	&& tox_group_exit_type_from_int(u32, val);
335	51	}