cleanup: Some random cleanups, mostly related to mem.

iphydf · iphydf · commit 05abe083cb6d · 2025-01-15T12:47:24.000Z
diff --git a/auto_tests/proxy_test.c b/auto_tests/proxy_test.c
@@ -1,9 +1,9 @@
 /* Tests that we can send messages to friends.
  */
 
+#include <pthread.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <string.h>
 
 #include "auto_test_support.h"
 
diff --git a/toxav/audio.c b/toxav/audio.c
@@ -195,7 +195,7 @@ void ac_iterate(ACSession *ac)
     free(temp_audio_buffer);
 }
 
-int ac_queue_message(Mono_Time *mono_time, void *cs, struct RTPMessage *msg)
+int ac_queue_message(const Mono_Time *mono_time, void *cs, struct RTPMessage *msg)
 {
     ACSession *ac = (ACSession *)cs;
 
diff --git a/toxav/audio.h b/toxav/audio.h
@@ -67,7 +67,7 @@ ACSession *ac_new(Mono_Time *mono_time, const Logger *log, ToxAV *av, uint32_t f
                   toxav_audio_receive_frame_cb *cb, void *cb_data);
 void ac_kill(ACSession *ac);
 void ac_iterate(ACSession *ac);
-int ac_queue_message(Mono_Time *mono_time, void *cs, struct RTPMessage *msg);
+int ac_queue_message(const Mono_Time *mono_time, void *cs, struct RTPMessage *msg);
 int ac_reconfigure_encoder(ACSession *ac, uint32_t bit_rate, uint32_t sampling_rate, uint8_t channels);
 
 #endif /* C_TOXCORE_TOXAV_AUDIO_H */
diff --git a/toxav/rtp.c b/toxav/rtp.c
@@ -823,7 +823,7 @@ static struct RTPHeader rtp_default_header(const RTPSession *session, uint32_t l
     header.ma = 0;
     header.pt = session->payload_type % 128;
     header.sequnum = session->sequnum;
-    Mono_Time *mt = toxav_get_av_mono_time(session->toxav);
+    const Mono_Time *mt = toxav_get_av_mono_time(session->toxav);
     if (mt != nullptr) {
         header.timestamp = current_time_monotonic(mt);
     } else {
diff --git a/toxav/rtp.h b/toxav/rtp.h
@@ -147,7 +147,7 @@ struct RTPWorkBufferList {
 
 #define DISMISS_FIRST_LOST_VIDEO_PACKET_COUNT 10
 
-typedef int rtp_m_cb(Mono_Time *mono_time, void *cs, struct RTPMessage *msg);
+typedef int rtp_m_cb(const Mono_Time *mono_time, void *cs, struct RTPMessage *msg);
 
 /**
  * RTP control session.
diff --git a/toxav/toxav.c b/toxav/toxav.c
@@ -5,7 +5,6 @@
 #include "toxav.h"
 
 #include <assert.h>
-#include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
@@ -21,7 +20,7 @@
 #include "../toxcore/network.h"
 #include "../toxcore/tox.h"
 #include "../toxcore/tox_private.h"
-#include "../toxcore/tox_struct.h"
+#include "../toxcore/tox_struct.h"  // IWYU pragma: keep
 #include "../toxcore/util.h"
 
 // TODO(zoff99): don't hardcode this, let the application choose it
@@ -342,7 +341,7 @@ uint32_t toxav_iteration_interval(const ToxAV *av)
  * @param frame_time the duration of the current frame in ms
  * @param start_time the timestamp when decoding of this frame started
  */
-static void calc_interval(ToxAV *av, DecodeTimeStats *stats, int32_t frame_time, uint64_t start_time)
+static void calc_interval(const ToxAV *av, DecodeTimeStats *stats, int32_t frame_time, uint64_t start_time)
 {
     stats->interval = frame_time < stats->average ? 0 : (frame_time - stats->average);
     stats->total += current_time_monotonic(av->toxav_mono_time) - start_time;
diff --git a/toxav/video.c b/toxav/video.c
@@ -8,14 +8,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "msi.h"
 #include "ring_buffer.h"
 #include "rtp.h"
 
 #include "../toxcore/ccompat.h"
 #include "../toxcore/logger.h"
 #include "../toxcore/mono_time.h"
-#include "../toxcore/network.h"
 
 /**
  * Soft deadline the decoder should attempt to meet, in "us" (microseconds).
@@ -143,7 +141,7 @@ static void vc_init_encoder_cfg(const Logger *log, vpx_codec_enc_cfg_t *cfg, int
 #endif /* 0 */
 }
 
-VCSession *vc_new(const Logger *log, Mono_Time *mono_time, ToxAV *av, uint32_t friend_number,
+VCSession *vc_new(const Logger *log, const Mono_Time *mono_time, ToxAV *av, uint32_t friend_number,
                   toxav_video_receive_frame_cb *cb, void *cb_data)
 {
     VCSession *vc = (VCSession *)calloc(1, sizeof(VCSession));
@@ -346,7 +344,7 @@ void vc_iterate(VCSession *vc)
     }
 }
 
-int vc_queue_message(Mono_Time *mono_time, void *cs, struct RTPMessage *msg)
+int vc_queue_message(const Mono_Time *mono_time, void *cs, struct RTPMessage *msg)
 {
     VCSession *vc = (VCSession *)cs;
 
diff --git a/toxav/video.h b/toxav/video.h
@@ -44,11 +44,11 @@ typedef struct VCSession {
     const Logger *log;
 } VCSession;
 
-VCSession *vc_new(const Logger *log, Mono_Time *mono_time, ToxAV *av, uint32_t friend_number,
+VCSession *vc_new(const Logger *log, const Mono_Time *mono_time, ToxAV *av, uint32_t friend_number,
                   toxav_video_receive_frame_cb *cb, void *cb_data);
 void vc_kill(VCSession *vc);
 void vc_iterate(VCSession *vc);
-int vc_queue_message(Mono_Time *mono_time, void *cs, struct RTPMessage *msg);
+int vc_queue_message(const Mono_Time *mono_time, void *cs, struct RTPMessage *msg);
 int vc_reconfigure_encoder(VCSession *vc, uint32_t bit_rate, uint16_t width, uint16_t height, int16_t kf_max_dist);
 
 #endif /* C_TOXCORE_TOXAV_VIDEO_H */
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
@@ -137,15 +137,15 @@ void getaddress(const Messenger *m, uint8_t *address)
 }
 
 non_null()
-static bool send_online_packet(Messenger *m, int friendcon_id)
+static bool send_online_packet(const Messenger *m, int friendcon_id)
 {
     const uint8_t packet[1] = {PACKET_ID_ONLINE};
     return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), packet,
                              sizeof(packet), false) != -1;
 }
 
 non_null()
-static bool send_offline_packet(Messenger *m, int friendcon_id)
+static bool send_offline_packet(const Messenger *m, int friendcon_id)
 {
     const uint8_t packet[1] = {PACKET_ID_OFFLINE};
     return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), packet,
diff --git a/toxcore/group.c b/toxcore/group.c
@@ -248,7 +248,7 @@ static bool is_groupnumber_valid(const Group_Chats *g_c, uint32_t groupnumber)
 
 /** @brief Set the size of the groupchat list to num.
  *
- * @retval false if realloc fails.
+ * @retval false if mem_vrealloc fails.
  * @retval true if it succeeds.
  */
 non_null()
@@ -1067,7 +1067,7 @@ static bool freeze_peer(Group_Chats *g_c, uint32_t groupnumber, int peer_index,
         return false;
     }
 
-    Group_Peer *temp = (Group_Peer *)mem_vrealloc(g_c->m->mem, g->frozen, g->numfrozen + 1, sizeof(Group_Peer));
+    Group_Peer *temp = (Group_Peer *)mem_vrealloc(g_c->mem, g->frozen, g->numfrozen + 1, sizeof(Group_Peer));
 
     if (temp == nullptr) {
         return false;
@@ -1085,7 +1085,7 @@ static bool freeze_peer(Group_Chats *g_c, uint32_t groupnumber, int peer_index,
 
     ++g->numfrozen;
 
-    delete_old_frozen(g, g_c->m->mem);
+    delete_old_frozen(g, g_c->mem);
 
     return true;
 }
@@ -1572,7 +1572,7 @@ int group_set_max_frozen(const Group_Chats *g_c, uint32_t groupnumber, uint32_t
     }
 
     g->maxfrozen = maxfrozen;
-    delete_old_frozen(g, g_c->m->mem);
+    delete_old_frozen(g, g_c->mem);
     return 0;
 }
 
@@ -3805,19 +3805,19 @@ bool conferences_load_state_section(Group_Chats *g_c, const uint8_t *data, uint3
 }
 
 /** Create new groupchat instance. */
-Group_Chats *new_groupchats(const Mono_Time *mono_time, Messenger *m)
+Group_Chats *new_groupchats(const Mono_Time *mono_time, const Memory *mem, Messenger *m)
 {
     if (m == nullptr) {
         return nullptr;
     }
 
-    Group_Chats *temp = (Group_Chats *)mem_alloc(m->mem, sizeof(Group_Chats));
+    Group_Chats *temp = (Group_Chats *)mem_alloc(mem, sizeof(Group_Chats));
 
     if (temp == nullptr) {
         return nullptr;
     }
 
-    temp->mem = m->mem;
+    temp->mem = mem;
     temp->mono_time = mono_time;
     temp->m = m;
     temp->fr_c = m->fr_c;
diff --git a/toxcore/group.h b/toxcore/group.h
@@ -15,6 +15,7 @@
 #include "Messenger.h"
 #include "attributes.h"
 #include "crypto_core.h"
+#include "mem.h"
 #include "mono_time.h"
 #include "state.h"
 
@@ -390,7 +391,7 @@ bool conferences_load_state_section(
 
 /** Create new groupchat instance. */
 non_null()
-Group_Chats *new_groupchats(const Mono_Time *mono_time, Messenger *m);
+Group_Chats *new_groupchats(const Mono_Time *mono_time, const Memory *mem, Messenger *m);
 
 /** main groupchats loop. */
 non_null(1) nullable(2)
diff --git a/toxcore/group_chats.c b/toxcore/group_chats.c
@@ -2736,7 +2736,7 @@ static bool send_gc_peer_exchange(const GC_Chat *chat, GC_Connection *gconn)
  * Return -5 if supplied group password is invalid.
  * Return -6 if we fail to add the peer to the peer list.
  * Return -7 if peer's role cannot be validated.
- * Return -8 if malloc fails.
+ * Return -8 if memory allocation fails.
  */
 non_null(1, 2, 4) nullable(6)
 static int handle_gc_peer_info_response(const GC_Session *c, GC_Chat *chat, uint32_t peer_number,
@@ -5534,7 +5534,7 @@ static int unwrap_group_handshake_packet(const Logger *log, const Memory *mem, c
  *
  * Return length of encrypted packet on success.
  * Return -1 if packet size is invalid.
- * Return -2 on malloc failure.
+ * Return -2 on memory allocation failure.
  * Return -3 if encryption fails.
  */
 non_null()
@@ -6825,7 +6825,7 @@ int peer_add(GC_Chat *chat, const IP_Port *ipp, const uint8_t *public_key)
     GC_Peer *tmp_group = (GC_Peer *)mem_vrealloc(chat->mem, chat->group, chat->numpeers + 1, sizeof(GC_Peer));
 
     if (tmp_group == nullptr) {
-        LOGGER_ERROR(chat->log, "Failed to allocate memory for group realloc");
+        LOGGER_ERROR(chat->log, "Failed to allocate memory for group mem_vrealloc");
 
         if (tcp_connection_num != -1) {
             kill_tcp_connection_to(chat->tcp_conn, tcp_connection_num);
diff --git a/toxcore/group_moderation.c b/toxcore/group_moderation.c
@@ -11,7 +11,6 @@
 
 #include <assert.h>
 
-
 #include <string.h>
 #include <time.h>
 
diff --git a/toxcore/group_onion_announce.h b/toxcore/group_onion_announce.h
@@ -17,9 +17,9 @@ void gca_onion_init(GC_Announces_List *group_announce, Onion_Announce *onion_a);
 
 non_null()
 int create_gca_announce_request(
-    const Memory *mem, const Random *rng, uint8_t *packet, uint16_t max_packet_length, const uint8_t *dest_client_id,
-    const uint8_t *public_key, const uint8_t *secret_key, const uint8_t *ping_id,
-    const uint8_t *client_id, const uint8_t *data_public_key, uint64_t sendback_data,
-    const uint8_t *gc_data, uint16_t gc_data_length);
+    const Memory *mem, const Random *rng, uint8_t *packet, uint16_t max_packet_length,
+    const uint8_t *dest_client_id, const uint8_t *public_key, const uint8_t *secret_key,
+    const uint8_t *ping_id, const uint8_t *client_id, const uint8_t *data_public_key,
+    uint64_t sendback_data, const uint8_t *gc_data, uint16_t gc_data_length);
 
 #endif /* C_TOXCORE_TOXCORE_GROUP_ONION_ANNOUNCE_H */
diff --git a/toxcore/list.c b/toxcore/list.c
@@ -115,7 +115,7 @@ static bool resize(BS_List *list, uint32_t new_size)
         return true;
     }
 
-    uint8_t *data = (uint8_t *)mem_vrealloc(list->mem, list->data, list->element_size, new_size);
+    uint8_t *data = (uint8_t *)mem_brealloc(list->mem, list->data, new_size * list->element_size);
 
     if (data == nullptr) {
         return false;
diff --git a/toxcore/logger.c b/toxcore/logger.c
@@ -8,6 +8,7 @@
  */
 #include "logger.h"
 
+#include <assert.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -52,6 +53,7 @@ void logger_kill(Logger *log)
 
 void logger_callback_log(Logger *log, logger_cb *function, void *context, void *userdata)
 {
+    assert(log != nullptr);
     log->callback = function;
     log->context  = context;
     log->userdata = userdata;
diff --git a/toxcore/mem.c b/toxcore/mem.c
@@ -53,6 +53,12 @@ void *mem_balloc(const Memory *mem, uint32_t size)
     return ptr;
 }
 
+void *mem_brealloc(const Memory *mem, void *ptr, uint32_t size)
+{
+    void *const new_ptr = mem->funcs->realloc(mem->obj, ptr, size);
+    return new_ptr;
+}
+
 void *mem_alloc(const Memory *mem, uint32_t size)
 {
     void *const ptr = mem->funcs->calloc(mem->obj, 1, size);
diff --git a/toxcore/mem.h b/toxcore/mem.h
@@ -45,6 +45,14 @@ const Memory *os_memory(void);
  */
 non_null() void *mem_balloc(const Memory *mem, uint32_t size);
 
+/**
+ * @brief Resize an array of a given size for built-in types.
+ *
+ * If used for a type other than byte-sized types, `size` needs to be manually
+ * multiplied by the element size.
+ */
+non_null(1) nullable(2) void *mem_brealloc(const Memory *mem, void *ptr, uint32_t size);
+
 /**
  * @brief Allocate a single object.
  *
diff --git a/toxcore/mono_time.c b/toxcore/mono_time.c
@@ -218,7 +218,7 @@ void mono_time_set_current_time_callback(Mono_Time *mono_time,
  * The starting point is unspecified and in particular is likely not comparable
  * to the return value of `mono_time_get_ms()`.
  */
-uint64_t current_time_monotonic(Mono_Time *mono_time)
+uint64_t current_time_monotonic(const Mono_Time *mono_time)
 {
     return mono_time->current_time_callback(mono_time->user_data);
 }
diff --git a/toxcore/mono_time.h b/toxcore/mono_time.h
@@ -87,7 +87,7 @@ bool mono_time_is_timeout(const Mono_Time *mono_time, uint64_t timestamp, uint64
  * to the return value of `mono_time_get_ms()`.
  */
 non_null()
-uint64_t current_time_monotonic(Mono_Time *mono_time);
+uint64_t current_time_monotonic(const Mono_Time *mono_time);
 
 /**
  * Override implementation of `current_time_monotonic()` (for tests).
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
diff --git a/toxcore/net_crypto.h b/toxcore/net_crypto.h
diff --git a/toxcore/tox.c b/toxcore/tox.c

Original file line number	Diff line number	Diff line change
`@@ -195,7 +195,7 @@ void ac_iterate(ACSession *ac)`
`195`	`195`	`free(temp_audio_buffer);`
`196`	`196`	`}`
`197`	`197`
`198`		`-int ac_queue_message(Mono_Time mono_time, void cs, struct RTPMessage *msg)`
	`198`	`+int ac_queue_message(const Mono_Time mono_time, void cs, struct RTPMessage *msg)`
`199`	`199`	`{`
`200`	`200`	`ACSession ac = (ACSession )cs;`
`201`	`201`
Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,12 @@`
`8`	`8`	`#include <stdlib.h>`
`9`	`9`	`#include <string.h>`
`10`	`10`
`11`		`-#include "msi.h"`
`12`	`11`	`#include "ring_buffer.h"`
`13`	`12`	`#include "rtp.h"`
`14`	`13`
`15`	`14`	`#include "../toxcore/ccompat.h"`
`16`	`15`	`#include "../toxcore/logger.h"`
`17`	`16`	`#include "../toxcore/mono_time.h"`
`18`		`-#include "../toxcore/network.h"`
`19`	`17`
`20`	`18`	`/**`
`21`	`19`	`* Soft deadline the decoder should attempt to meet, in "us" (microseconds).`
`@@ -143,7 +141,7 @@ static void vc_init_encoder_cfg(const Logger log, vpx_codec_enc_cfg_t cfg, int`
`143`	`141`	`#endif /* 0 */`
`144`	`142`	`}`
`145`	`143`
`146`		`-VCSession vc_new(const Logger log, Mono_Time mono_time, ToxAV av, uint32_t friend_number,`
	`144`	`+VCSession vc_new(const Logger log, const Mono_Time mono_time, ToxAV av, uint32_t friend_number,`
`147`	`145`	`toxav_video_receive_frame_cb cb, void cb_data)`
`148`	`146`	`{`
`149`	`147`	`VCSession vc = (VCSession )calloc(1, sizeof(VCSession));`
`@@ -346,7 +344,7 @@ void vc_iterate(VCSession *vc)`
`346`	`344`	`}`
`347`	`345`	`}`
`348`	`346`
`349`		`-int vc_queue_message(Mono_Time mono_time, void cs, struct RTPMessage *msg)`
	`347`	`+int vc_queue_message(const Mono_Time mono_time, void cs, struct RTPMessage *msg)`
`350`	`348`	`{`
`351`	`349`	`VCSession vc = (VCSession )cs;`
`352`	`350`
Original file line number	Diff line number	Diff line change
`@@ -137,15 +137,15 @@ void getaddress(const Messenger m, uint8_t address)`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`non_null()`
`140`		`-static bool send_online_packet(Messenger *m, int friendcon_id)`
	`140`	`+static bool send_online_packet(const Messenger *m, int friendcon_id)`
`141`	`141`	`{`
`142`	`142`	`const uint8_t packet[1] = {PACKET_ID_ONLINE};`
`143`	`143`	`return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), packet,`
`144`	`144`	`sizeof(packet), false) != -1;`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`non_null()`
`148`		`-static bool send_offline_packet(Messenger *m, int friendcon_id)`
	`148`	`+static bool send_offline_packet(const Messenger *m, int friendcon_id)`
`149`	`149`	`{`
`150`	`150`	`const uint8_t packet[1] = {PACKET_ID_OFFLINE};`
`151`	`151`	`return write_cryptpacket(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c, friendcon_id), packet,`
Original file line number	Diff line number	Diff line change
`@@ -248,7 +248,7 @@ static bool is_groupnumber_valid(const Group_Chats *g_c, uint32_t groupnumber)`
`248`	`248`
`249`	`249`	`/** @brief Set the size of the groupchat list to num.`
`250`	`250`	`*`
`251`		`- * @retval false if realloc fails.`
	`251`	`+ * @retval false if mem_vrealloc fails.`
`252`	`252`	`* @retval true if it succeeds.`
`253`	`253`	`*/`
`254`	`254`	`non_null()`
`@@ -1067,7 +1067,7 @@ static bool freeze_peer(Group_Chats *g_c, uint32_t groupnumber, int peer_index,`
`1067`	`1067`	`return false;`
`1068`	`1068`	`}`
`1069`	`1069`
`1070`		`- Group_Peer temp = (Group_Peer )mem_vrealloc(g_c->m->mem, g->frozen, g->numfrozen + 1, sizeof(Group_Peer));`
	`1070`	`+ Group_Peer temp = (Group_Peer )mem_vrealloc(g_c->mem, g->frozen, g->numfrozen + 1, sizeof(Group_Peer));`
`1071`	`1071`
`1072`	`1072`	`if (temp == nullptr) {`
`1073`	`1073`	`return false;`
`@@ -1085,7 +1085,7 @@ static bool freeze_peer(Group_Chats *g_c, uint32_t groupnumber, int peer_index,`
`1085`	`1085`
`1086`	`1086`	`++g->numfrozen;`
`1087`	`1087`
`1088`		`- delete_old_frozen(g, g_c->m->mem);`
	`1088`	`+ delete_old_frozen(g, g_c->mem);`
`1089`	`1089`
`1090`	`1090`	`return true;`
`1091`	`1091`	`}`
`@@ -1572,7 +1572,7 @@ int group_set_max_frozen(const Group_Chats *g_c, uint32_t groupnumber, uint32_t`
`1572`	`1572`	`}`
`1573`	`1573`
`1574`	`1574`	`g->maxfrozen = maxfrozen;`
`1575`		`- delete_old_frozen(g, g_c->m->mem);`
	`1575`	`+ delete_old_frozen(g, g_c->mem);`
`1576`	`1576`	`return 0;`
`1577`	`1577`	`}`
`1578`	`1578`
`@@ -3805,19 +3805,19 @@ bool conferences_load_state_section(Group_Chats g_c, const uint8_t data, uint3`
`3805`	`3805`	`}`
`3806`	`3806`
`3807`	`3807`	`/** Create new groupchat instance. */`
`3808`		`-Group_Chats new_groupchats(const Mono_Time mono_time, Messenger *m)`
	`3808`	`+Group_Chats new_groupchats(const Mono_Time mono_time, const Memory mem, Messenger m)`
`3809`	`3809`	`{`
`3810`	`3810`	`if (m == nullptr) {`
`3811`	`3811`	`return nullptr;`
`3812`	`3812`	`}`
`3813`	`3813`
`3814`		`- Group_Chats temp = (Group_Chats )mem_alloc(m->mem, sizeof(Group_Chats));`
	`3814`	`+ Group_Chats temp = (Group_Chats )mem_alloc(mem, sizeof(Group_Chats));`
`3815`	`3815`
`3816`	`3816`	`if (temp == nullptr) {`
`3817`	`3817`	`return nullptr;`
`3818`	`3818`	`}`
`3819`	`3819`
`3820`		`- temp->mem = m->mem;`
	`3820`	`+ temp->mem = mem;`
`3821`	`3821`	`temp->mono_time = mono_time;`
`3822`	`3822`	`temp->m = m;`
`3823`	`3823`	`temp->fr_c = m->fr_c;`