/* SPDX-License-Identifier: GPL-3.0-or-later

 * Copyright © 2016-2026 The TokTok team.

 * Copyright © 2013 Tox project.

 */

/**

 * The Tox public API.

 */

#ifndef _XOPEN_SOURCE

#define _XOPEN_SOURCE 600

#endif /* _XOPEN_SOURCE */

#include "tox.h"

#include <assert.h>

#include <stdlib.h>

#include <string.h>

#include "DHT.h"

#include "Messenger.h"

#include "TCP_client.h"

#include "attributes.h"

#include "ccompat.h"

#include "crypto_core.h"

#include "friend_requests.h"

#include "group.h"

#include "group_chats.h"

#include "group_common.h"

#include "logger.h"

#include "mem.h"

#include "mono_time.h"

#include "net.h"

#include "net_crypto.h"

#include "network.h"

#include "onion_client.h"

#include "state.h"

#include "tox_log_level.h"

#include "tox_options.h"

#include "tox_private.h"

#include "tox_struct.h" // IWYU pragma: keep

#include "util.h"

#include "../toxencryptsave/defines.h"

#define SET_ERROR_PARAMETER(param, x) \

    do {                              \

        if (param != nullptr) {       \

            *param = x;               \

        }                             \

    } while (0)

static_assert(TOX_HASH_LENGTH == CRYPTO_SHA256_SIZE,

              "TOX_HASH_LENGTH is assumed to be equal to CRYPTO_SHA256_SIZE");

static_assert(FILE_ID_LENGTH == CRYPTO_SYMMETRIC_KEY_SIZE,

              "FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE");

static_assert(TOX_DHT_NODE_IP_STRING_SIZE == IP_NTOA_LEN,

              "TOX_DHT_NODE_IP_STRING_SIZE is assumed to be equal to IP_NTOA_LEN");

static_assert(TOX_GROUP_PEER_IP_STRING_MAX_LENGTH == IP_NTOA_LEN,

              "TOX_GROUP_PEER_IP_STRING_MAX_LENGTH is assumed to be equal to IP_NTOA_LEN");

static_assert(TOX_DHT_NODE_PUBLIC_KEY_SIZE == CRYPTO_PUBLIC_KEY_SIZE,

              "TOX_DHT_NODE_PUBLIC_KEY_SIZE is assumed to be equal to CRYPTO_PUBLIC_KEY_SIZE");

static_assert(TOX_FILE_ID_LENGTH == CRYPTO_SYMMETRIC_KEY_SIZE,

              "TOX_FILE_ID_LENGTH is assumed to be equal to CRYPTO_SYMMETRIC_KEY_SIZE");

static_assert(TOX_FILE_ID_LENGTH == TOX_HASH_LENGTH,

              "TOX_FILE_ID_LENGTH is assumed to be equal to TOX_HASH_LENGTH");

static_assert(TOX_PUBLIC_KEY_SIZE == CRYPTO_PUBLIC_KEY_SIZE,

              "TOX_PUBLIC_KEY_SIZE is assumed to be equal to CRYPTO_PUBLIC_KEY_SIZE");

static_assert(TOX_SECRET_KEY_SIZE == CRYPTO_SECRET_KEY_SIZE,

              "TOX_SECRET_KEY_SIZE is assumed to be equal to CRYPTO_SECRET_KEY_SIZE");

static_assert(TOX_MAX_NAME_LENGTH == MAX_NAME_LENGTH,

              "TOX_MAX_NAME_LENGTH is assumed to be equal to MAX_NAME_LENGTH");

static_assert(TOX_MAX_STATUS_MESSAGE_LENGTH == MAX_STATUSMESSAGE_LENGTH,

              "TOX_MAX_STATUS_MESSAGE_LENGTH is assumed to be equal to MAX_STATUSMESSAGE_LENGTH");

static_assert(TOX_GROUP_MAX_MESSAGE_LENGTH == GROUP_MAX_MESSAGE_LENGTH,

              "TOX_GROUP_MAX_MESSAGE_LENGTH is assumed to be equal to GROUP_MAX_MESSAGE_LENGTH");

static_assert(TOX_MAX_CUSTOM_PACKET_SIZE == MAX_GC_CUSTOM_LOSSLESS_PACKET_SIZE,

              "TOX_MAX_CUSTOM_PACKET_SIZE is assumed to be equal to MAX_GC_CUSTOM_LOSSLESS_PACKET_SIZE");

struct Tox_Userdata {

    Tox *_Nonnull tox;

    void *_Nullable user_data;

};

static logger_cb tox_log_handler;

static void tox_log_handler(void *context, Logger_Level level, const char *file, uint32_t line, const char *func,

                            const char *message, void *userdata)

{

    Tox *tox = (Tox *)context;

    assert(tox != nullptr);

    if (tox->log_callback != nullptr) {

        tox->log_callback(tox, (Tox_Log_Level)level, file, line, func, message, userdata);

    }

}

static m_self_connection_status_cb tox_self_connection_status_handler;

static void tox_self_connection_status_handler(Messenger *m, Onion_Connection_Status connection_status, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->self_connection_status_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->self_connection_status_callback(tox_data->tox, (Tox_Connection)connection_status, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_name_cb tox_friend_name_handler;

static void tox_friend_name_handler(Messenger *m, uint32_t friend_number, const uint8_t *name, size_t length,

                                    void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_name_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_name_callback(tox_data->tox, friend_number, name, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_status_message_cb tox_friend_status_message_handler;

static void tox_friend_status_message_handler(Messenger *m, uint32_t friend_number, const uint8_t *message,

        size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_status_message_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_status_message_callback(tox_data->tox, friend_number, message, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_status_cb tox_friend_status_handler;

static void tox_friend_status_handler(Messenger *m, uint32_t friend_number, unsigned int status, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_status_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_status_callback(tox_data->tox, friend_number, (Tox_User_Status)status, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_connection_status_cb tox_friend_connection_status_handler;

static void tox_friend_connection_status_handler(Messenger *m, uint32_t friend_number, unsigned int connection_status,

        void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_connection_status_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_connection_status_callback(tox_data->tox, friend_number, (Tox_Connection)connection_status,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_typing_cb tox_friend_typing_handler;

static void tox_friend_typing_handler(Messenger *m, uint32_t friend_number, bool is_typing, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_typing_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_typing_callback(tox_data->tox, friend_number, is_typing, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_read_receipt_cb tox_friend_read_receipt_handler;

static void tox_friend_read_receipt_handler(Messenger *m, uint32_t friend_number, uint32_t message_id, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_read_receipt_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_read_receipt_callback(tox_data->tox, friend_number, message_id, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_request_cb tox_friend_request_handler;

static void tox_friend_request_handler(Messenger *m, const Tox_Public_Key public_key, const uint8_t *message, size_t length,

                                       void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_request_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_request_callback(tox_data->tox, public_key, message, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_message_cb tox_friend_message_handler;

static void tox_friend_message_handler(Messenger *m, uint32_t friend_number, unsigned int message_type,

                                       const uint8_t *message, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->friend_message_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_message_callback(tox_data->tox, friend_number, (Tox_Message_Type)message_type, message, length,

                                               tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_file_recv_control_cb tox_file_recv_control_handler;

static void tox_file_recv_control_handler(Messenger *m, uint32_t friend_number, uint32_t file_number,

        unsigned int control, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->file_recv_control_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->file_recv_control_callback(tox_data->tox, friend_number, file_number, (Tox_File_Control)control,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_file_chunk_request_cb tox_file_chunk_request_handler;

static void tox_file_chunk_request_handler(Messenger *m, uint32_t friend_number, uint32_t file_number,

        uint64_t position, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->file_chunk_request_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->file_chunk_request_callback(tox_data->tox, friend_number, file_number, position, length,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_file_recv_cb tox_file_recv_handler;

static void tox_file_recv_handler(Messenger *m, 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)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->file_recv_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->file_recv_callback(tox_data->tox, friend_number, file_number, kind, file_size, filename, filename_length,

                                          tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_file_recv_chunk_cb tox_file_recv_chunk_handler;

static void tox_file_recv_chunk_handler(Messenger *m, uint32_t friend_number, uint32_t file_number, uint64_t position,

                                        const uint8_t *data, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->file_recv_chunk_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->file_recv_chunk_callback(tox_data->tox, friend_number, file_number, position, data, length,

                                                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static g_conference_invite_cb tox_conference_invite_handler;

static void tox_conference_invite_handler(Messenger *m, uint32_t friend_number, int type, const uint8_t *cookie,

        size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->conference_invite_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->conference_invite_callback(tox_data->tox, friend_number, (Tox_Conference_Type)type, cookie, length,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static g_conference_connected_cb tox_conference_connected_handler;

static void tox_conference_connected_handler(Messenger *m, uint32_t conference_number, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->conference_connected_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->conference_connected_callback(tox_data->tox, conference_number, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static g_conference_message_cb tox_conference_message_handler;

static void tox_conference_message_handler(Messenger *m, uint32_t conference_number, uint32_t peer_number, int type,

        const uint8_t *message, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->conference_message_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->conference_message_callback(tox_data->tox, conference_number, peer_number, (Tox_Message_Type)type,

                message, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static title_cb tox_conference_title_handler;

static void tox_conference_title_handler(Messenger *m, uint32_t conference_number, uint32_t peer_number,

        const uint8_t *title, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->conference_title_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->conference_title_callback(tox_data->tox, conference_number, peer_number, title, length,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static peer_name_cb tox_conference_peer_name_handler;

static void tox_conference_peer_name_handler(Messenger *m, uint32_t conference_number, uint32_t peer_number,

        const uint8_t *name, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->conference_peer_name_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->conference_peer_name_callback(tox_data->tox, conference_number, peer_number, name, length,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static peer_list_changed_cb tox_conference_peer_list_changed_handler;

static void tox_conference_peer_list_changed_handler(Messenger *m, uint32_t conference_number, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->conference_peer_list_changed_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->conference_peer_list_changed_callback(tox_data->tox, conference_number, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static dht_nodes_response_cb tox_dht_nodes_response_handler;

static void tox_dht_nodes_response_handler(const DHT *dht, const Node_format *node, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->dht_nodes_response_callback == nullptr) {

        return;

    }

    Ip_Ntoa ip_str;

    net_ip_ntoa(&node->ip_port.ip, &ip_str);

    tox_unlock(tox_data->tox);

    tox_data->tox->dht_nodes_response_callback(

        tox_data->tox, node->public_key, ip_str.buf, ip_str.length, net_ntohs(node->ip_port.port),

        tox_data->user_data);

    tox_lock(tox_data->tox);

}

static m_friend_lossy_packet_cb tox_friend_lossy_packet_handler;

static void tox_friend_lossy_packet_handler(Messenger *m, uint32_t friend_number, uint8_t packet_id,

        const uint8_t *data, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    assert(data != nullptr);

    assert(length > 0);

    if (tox_data->tox->friend_lossy_packet_callback_per_pktid[packet_id] != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_lossy_packet_callback_per_pktid[packet_id](tox_data->tox, friend_number, data, length,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static m_friend_lossless_packet_cb tox_friend_lossless_packet_handler;

static void tox_friend_lossless_packet_handler(Messenger *m, uint32_t friend_number, uint8_t packet_id,

        const uint8_t *data, size_t length, void *user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    assert(data != nullptr);

    assert(length > 0);

    if (tox_data->tox->friend_lossless_packet_callback_per_pktid[packet_id] != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->friend_lossless_packet_callback_per_pktid[packet_id](tox_data->tox, friend_number, data, length,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_peer_name_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id,

                                        const uint8_t *_Nonnull name, size_t length, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_peer_name_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_peer_name_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), name, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_peer_status_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id,

        unsigned int status, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_peer_status_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_peer_status_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), (Tox_User_Status)status,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_topic_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id, const uint8_t *_Nonnull topic,

                                    size_t length, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_topic_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_topic_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), topic, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_topic_lock_handler(const Messenger *_Nonnull m, uint32_t group_number, unsigned int topic_lock,

        void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_topic_lock_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_topic_lock_callback(tox_data->tox, group_number, (Tox_Group_Topic_Lock)topic_lock,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_voice_state_handler(const Messenger *_Nonnull m, uint32_t group_number, unsigned int voice_state,

        void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_voice_state_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_voice_state_callback(tox_data->tox, group_number, (Tox_Group_Voice_State)voice_state,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_peer_limit_handler(const Messenger *_Nonnull m, uint32_t group_number, uint32_t peer_limit,

        void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_peer_limit_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_peer_limit_callback(tox_data->tox, group_number, peer_limit, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_privacy_state_handler(const Messenger *_Nonnull m, uint32_t group_number, unsigned int privacy_state,

        void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_privacy_state_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_privacy_state_callback(tox_data->tox, group_number, (Tox_Group_Privacy_State)privacy_state,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_password_handler(const Messenger *_Nonnull m, uint32_t group_number, const uint8_t *_Nullable password,

                                       size_t length, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_password_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_password_callback(tox_data->tox, group_number, password, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_message_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id, unsigned int type,

                                      const uint8_t *_Nonnull message, size_t length, Tox_Group_Message_Id message_id, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_message_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_message_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), (Tox_Message_Type)type, message, length,

                                              message_id, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_private_message_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id,

        unsigned int type, const uint8_t *_Nonnull message, size_t length, Tox_Group_Message_Id message_id, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_private_message_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_private_message_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), (Tox_Message_Type)type, message,

                length, message_id, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_custom_packet_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id,

        const uint8_t *_Nonnull data, size_t length, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_custom_packet_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_custom_packet_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), data, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_custom_private_packet_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id,

        const uint8_t *_Nonnull data, size_t length, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_custom_private_packet_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_custom_private_packet_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), data, length,

                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_invite_handler(const Messenger *_Nonnull m, uint32_t friend_number, const uint8_t *_Nonnull invite_data,

                                     size_t length, const uint8_t *_Nonnull group_name, size_t group_name_length, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_invite_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_invite_callback(tox_data->tox, friend_number, invite_data, length, group_name, group_name_length,

                                             tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_peer_join_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_peer_join_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_peer_join_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id), tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_peer_exit_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id peer_id,

                                        unsigned int exit_type, const uint8_t *_Nonnull name, size_t name_length,

                                        const uint8_t *_Nullable part_message, size_t length, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_peer_exit_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_peer_exit_callback(tox_data->tox, group_number, gc_peer_id_to_int(peer_id),

                                                (Tox_Group_Exit_Type)exit_type, name, name_length,

                                                part_message, length, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_self_join_handler(const Messenger *_Nonnull m, uint32_t group_number, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_self_join_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_self_join_callback(tox_data->tox, group_number, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_join_fail_handler(const Messenger *_Nonnull m, uint32_t group_number, unsigned int fail_type,

                                        void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_join_fail_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_join_fail_callback(tox_data->tox, group_number, (Tox_Group_Join_Fail)fail_type,

                                                tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

static void tox_group_moderation_handler(const Messenger *_Nonnull m, uint32_t group_number, GC_Peer_Id source_peer_number,

        GC_Peer_Id target_peer_number, unsigned int mod_type, void *_Nullable user_data)

{

    struct Tox_Userdata *tox_data = (struct Tox_Userdata *)user_data;

    if (tox_data->tox->group_moderation_callback != nullptr) {

        tox_unlock(tox_data->tox);

        tox_data->tox->group_moderation_callback(tox_data->tox, group_number,

                gc_peer_id_to_int(source_peer_number), gc_peer_id_to_int(target_peer_number),

                (Tox_Group_Mod_Event)mod_type, tox_data->user_data);

        tox_lock(tox_data->tox);

    }

}

bool tox_version_is_compatible(uint32_t major, uint32_t minor, uint32_t patch)

{

    return TOX_VERSION_IS_API_COMPATIBLE(major, minor, patch);

}

static State_Load_Status state_load_callback(void *_Nonnull outer, const uint8_t *_Nonnull data, uint32_t length, uint16_t type)

{

    const Tox *tox = (const Tox *)outer;

    State_Load_Status status = STATE_LOAD_STATUS_CONTINUE;

    if (messenger_load_state_section(tox->m, data, length, type, &status)

            || conferences_load_state_section(tox->m->conferences_object, data, length, type, &status)) {

        return status;

    }

    if (type == STATE_TYPE_END) {

        if (length != 0) {

            return STATE_LOAD_STATUS_ERROR;

        }

        return STATE_LOAD_STATUS_END;

    }

    LOGGER_ERROR(tox->m->log, "Load state: contains unrecognized part (len %u, type %u)",

                 length, type);

    return STATE_LOAD_STATUS_CONTINUE;

}

/** Load tox from data of size length. */

static int tox_load(Tox *_Nonnull tox, const uint8_t *_Nonnull data, uint32_t length)

{

    uint32_t data32[2];

    const uint32_t cookie_len = sizeof(data32);

    if (length < cookie_len) {

        return -1;

    }

    memcpy(data32, data, sizeof(uint32_t));

    lendian_bytes_to_host32(data32 + 1, data + sizeof(uint32_t));

    if (data32[0] != 0 || data32[1] != STATE_COOKIE_GLOBAL) {

        return -1;

    }

    return state_load(tox->m->log, state_load_callback, tox, data + cookie_len,

                      length - cookie_len, STATE_COOKIE_TYPE);

}

static Tox *_Nullable tox_new_system(const struct Tox_Options *_Nullable options, Tox_Err_New *_Nullable error, const Tox_System *_Nullable sys)

{

    struct Tox_Options *default_options = nullptr;

    if (options == nullptr) {

        Tox_Err_Options_New err;

        default_options = tox_options_new(&err);

        switch (err) {

            case TOX_ERR_OPTIONS_NEW_OK: {

                assert(default_options != nullptr);

                break;

            }

            case TOX_ERR_OPTIONS_NEW_MALLOC: {

                SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

                return nullptr;

            }

        }

    }

    const struct Tox_Options *const opts = options != nullptr ? options : default_options;

    assert(opts != nullptr);

    const Tox_System default_system = tox_default_system();

    if (sys == nullptr) {

        sys = &default_system;

    }

    if (sys->rng == nullptr || sys->ns == nullptr || sys->mem == nullptr) {

        // TODO(iphydf): Not quite right, but similar.

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

        tox_options_free(default_options);

        return nullptr;

    }

    const Random *const rng = sys->rng;

    const Network *const ns = sys->ns;

    const Memory *const mem = sys->mem;

    Messenger_Options m_options = {nullptr};

    m_options.dns_enabled = !tox_options_get_experimental_disable_dns(opts);

    bool load_savedata_sk = false;

    bool load_savedata_tox = false;

    if (tox_options_get_savedata_type(opts) != TOX_SAVEDATA_TYPE_NONE) {

        if (tox_options_get_savedata_data(opts) == nullptr || tox_options_get_savedata_length(opts) == 0) {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);

            tox_options_free(default_options);

            return nullptr;

        }

    }

    if (tox_options_get_savedata_type(opts) == TOX_SAVEDATA_TYPE_SECRET_KEY) {

        if (tox_options_get_savedata_length(opts) != TOX_SECRET_KEY_SIZE) {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);

            tox_options_free(default_options);

            return nullptr;

        }

        load_savedata_sk = true;

    } else if (tox_options_get_savedata_type(opts) == TOX_SAVEDATA_TYPE_TOX_SAVE) {

        if (tox_options_get_savedata_length(opts) < TOX_ENC_SAVE_MAGIC_LENGTH) {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);

            tox_options_free(default_options);

            return nullptr;

        }

        if (memcmp(tox_options_get_savedata_data(opts), TOX_ENC_SAVE_MAGIC_NUMBER, TOX_ENC_SAVE_MAGIC_LENGTH) == 0) {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_ENCRYPTED);

            tox_options_free(default_options);

            return nullptr;

        }

        load_savedata_tox = true;

    }

    m_options.ipv6enabled = tox_options_get_ipv6_enabled(opts);

    m_options.udp_disabled = !tox_options_get_udp_enabled(opts);

    m_options.port_range[0] = tox_options_get_start_port(opts);

    m_options.port_range[1] = tox_options_get_end_port(opts);

    m_options.tcp_server_port = tox_options_get_tcp_port(opts);

    m_options.hole_punching_enabled = tox_options_get_hole_punching_enabled(opts);

    m_options.local_discovery_enabled = tox_options_get_local_discovery_enabled(opts);

    m_options.dht_announcements_enabled = tox_options_get_dht_announcements_enabled(opts);

    m_options.groups_persistence_enabled = tox_options_get_experimental_groups_persistence(opts);

    if (m_options.udp_disabled) {

        m_options.local_discovery_enabled = false;

    }

    Tox *tox = (Tox *)mem_alloc(mem, sizeof(Tox));

    if (tox == nullptr) {

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

        tox_options_free(default_options);

        return nullptr;

    }

    tox->log_callback = tox_options_get_log_callback(opts);

    Logger *log = logger_new(mem);

    if (log == nullptr) {

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

        mem_delete(mem, tox);

        tox_options_free(default_options);

        return nullptr;

    }

    tox->log = log;

    m_options.log = tox->log;

    logger_callback_log(tox->log, tox_log_handler, tox, tox_options_get_log_user_data(opts));

    switch (tox_options_get_proxy_type(opts)) {

        case TOX_PROXY_TYPE_HTTP: {

            m_options.proxy_info.proxy_type = TCP_PROXY_HTTP;

            break;

        }

        case TOX_PROXY_TYPE_SOCKS5: {

            m_options.proxy_info.proxy_type = TCP_PROXY_SOCKS5;

            break;

        }

        case TOX_PROXY_TYPE_NONE: {

            m_options.proxy_info.proxy_type = TCP_PROXY_NONE;

            break;

        }

        default: {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_TYPE);

            logger_kill(tox->log);

            mem_delete(mem, tox);

            tox_options_free(default_options);

            return nullptr;

        }

    }

    tox->sys = *sys;

    if (m_options.proxy_info.proxy_type != TCP_PROXY_NONE) {

        if (tox_options_get_proxy_port(opts) == 0) {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_PORT);

            logger_kill(tox->log);

            mem_delete(mem, tox);

            tox_options_free(default_options);

            return nullptr;

        }

        ip_init(&m_options.proxy_info.ip_port.ip, m_options.ipv6enabled);

        if (m_options.ipv6enabled) {

            m_options.proxy_info.ip_port.ip.family = net_family_unspec();

        }

        const char *const proxy_host = tox_options_get_proxy_host(opts);

        const bool dns_enabled = !tox_options_get_experimental_disable_dns(opts);

        if (proxy_host == nullptr

                || !addr_resolve_or_parse_ip(ns, mem, proxy_host, &m_options.proxy_info.ip_port.ip, nullptr, dns_enabled)) {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PROXY_BAD_HOST);

            // TODO(irungentoo): TOX_ERR_NEW_PROXY_NOT_FOUND if domain.

            logger_kill(tox->log);

            mem_delete(mem, tox);

            tox_options_free(default_options);

            return nullptr;

        }

        m_options.proxy_info.ip_port.port = net_htons(tox_options_get_proxy_port(opts));

    }

    Mono_Time *temp_mono_time = mono_time_new(mem, sys->mono_time_callback, sys->mono_time_user_data);

    if (temp_mono_time == nullptr) {

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

        logger_kill(tox->log);

        mem_delete(mem, tox);

        tox_options_free(default_options);

        return nullptr;

    }

    tox->mono_time = temp_mono_time;

    if (tox_options_get_experimental_thread_safety(opts)) {

        pthread_mutex_t *mutex = (pthread_mutex_t *)mem_alloc(mem, sizeof(pthread_mutex_t));

        if (mutex == nullptr) {

            SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

            mono_time_free(mem, tox->mono_time);

            logger_kill(tox->log);

            mem_delete(mem, tox);

            tox_options_free(default_options);

            return nullptr;

        }

        pthread_mutex_init(mutex, nullptr);

        tox->mutex = mutex;

    } else {

        tox->mutex = nullptr;

    }

    tox_lock(tox);

    Messenger_Error m_error;

    Messenger *temp_m = new_messenger(tox->mono_time, mem, rng, ns, &m_options, &m_error);

    if (temp_m == nullptr) {

        switch (m_error) {

            case MESSENGER_ERROR_PORT:

            case MESSENGER_ERROR_TCP_SERVER: {

                SET_ERROR_PARAMETER(error, TOX_ERR_NEW_PORT_ALLOC);

                break;

            }

            case MESSENGER_ERROR_OTHER:

            case MESSENGER_ERROR_NONE: {

                SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

                break;

            }

        }

        mono_time_free(mem, tox->mono_time);

        tox_unlock(tox);

        if (tox->mutex != nullptr) {

            pthread_mutex_destroy(tox->mutex);

        }

        mem_delete(mem, tox->mutex);

        logger_kill(tox->log);

        mem_delete(mem, tox);

        tox_options_free(default_options);

        return nullptr;

    }

    tox->m = temp_m;

    tox->m->conferences_object = new_groupchats(tox->mono_time, mem, tox->m);

    if (tox->m->conferences_object == nullptr) {

        kill_messenger(tox->m);

        mono_time_free(mem, tox->mono_time);

        tox_unlock(tox);

        if (tox->mutex != nullptr) {

            pthread_mutex_destroy(tox->mutex);

        }

        mem_delete(mem, tox->mutex);

        logger_kill(tox->log);

        mem_delete(mem, tox);

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_MALLOC);

        tox_options_free(default_options);

        return nullptr;

    }

    if (load_savedata_tox

            && tox_load(tox, tox_options_get_savedata_data(opts), tox_options_get_savedata_length(opts)) == -1) {

        kill_groupchats(tox->m->conferences_object);

        kill_messenger(tox->m);

        mono_time_free(mem, tox->mono_time);

        tox_unlock(tox);

        if (tox->mutex != nullptr) {

            pthread_mutex_destroy(tox->mutex);

        }

        mem_delete(mem, tox->mutex);

        logger_kill(tox->log);

        mem_delete(mem, tox);

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_LOAD_BAD_FORMAT);

        tox_options_free(default_options);

        return nullptr;

    }

    if (load_savedata_sk) {

        load_secret_key(tox->m->net_crypto, tox_options_get_savedata_data(opts));

    }

    m_callback_namechange(tox->m, tox_friend_name_handler);

    m_callback_core_connection(tox->m, tox_self_connection_status_handler);

    m_callback_statusmessage(tox->m, tox_friend_status_message_handler);

    m_callback_userstatus(tox->m, tox_friend_status_handler);

    m_callback_connectionstatus(tox->m, tox_friend_connection_status_handler);

    m_callback_typingchange(tox->m, tox_friend_typing_handler);

    m_callback_read_receipt(tox->m, tox_friend_read_receipt_handler);

    m_callback_friendrequest(tox->m, tox_friend_request_handler);

    m_callback_friendmessage(tox->m, tox_friend_message_handler);

    callback_file_control(tox->m, tox_file_recv_control_handler);

    callback_file_reqchunk(tox->m, tox_file_chunk_request_handler);

    callback_file_sendrequest(tox->m, tox_file_recv_handler);

    callback_file_data(tox->m, tox_file_recv_chunk_handler);

    dht_callback_nodes_response(tox->m->dht, tox_dht_nodes_response_handler);

    g_callback_group_invite(tox->m->conferences_object, tox_conference_invite_handler);

    g_callback_group_connected(tox->m->conferences_object, tox_conference_connected_handler);

    g_callback_group_message(tox->m->conferences_object, tox_conference_message_handler);

    g_callback_group_title(tox->m->conferences_object, tox_conference_title_handler);

    g_callback_peer_name(tox->m->conferences_object, tox_conference_peer_name_handler);

    g_callback_peer_list_changed(tox->m->conferences_object, tox_conference_peer_list_changed_handler);

    custom_lossy_packet_registerhandler(tox->m, tox_friend_lossy_packet_handler);

    custom_lossless_packet_registerhandler(tox->m, tox_friend_lossless_packet_handler);

    m_callback_group_invite(tox->m, tox_group_invite_handler);

    gc_callback_message(tox->m, tox_group_message_handler);

    gc_callback_private_message(tox->m, tox_group_private_message_handler);

    gc_callback_custom_packet(tox->m, tox_group_custom_packet_handler);

    gc_callback_custom_private_packet(tox->m, tox_group_custom_private_packet_handler);

    gc_callback_moderation(tox->m, tox_group_moderation_handler);

    gc_callback_nick_change(tox->m, tox_group_peer_name_handler);

    gc_callback_status_change(tox->m, tox_group_peer_status_handler);

    gc_callback_topic_change(tox->m, tox_group_topic_handler);

    gc_callback_peer_limit(tox->m, tox_group_peer_limit_handler);

    gc_callback_privacy_state(tox->m, tox_group_privacy_state_handler);

    gc_callback_topic_lock(tox->m, tox_group_topic_lock_handler);

    gc_callback_password(tox->m, tox_group_password_handler);

    gc_callback_peer_join(tox->m, tox_group_peer_join_handler);

    gc_callback_peer_exit(tox->m, tox_group_peer_exit_handler);

    gc_callback_self_join(tox->m, tox_group_self_join_handler);

    gc_callback_rejected(tox->m, tox_group_join_fail_handler);

    gc_callback_voice_state(tox->m, tox_group_voice_state_handler);

    tox_unlock(tox);

    SET_ERROR_PARAMETER(error, TOX_ERR_NEW_OK);

    tox_options_free(default_options);

    return tox;

}

Tox *_Nullable tox_new(const struct Tox_Options *_Nullable options, Tox_Err_New *_Nullable error)

{

    return tox_new_system(options, error, nullptr);

}

Tox *tox_new_testing(const Tox_Options *options, Tox_Err_New *error,

                     const Tox_Options_Testing *testing, Tox_Err_New_Testing *testing_error)

{

    if (testing == nullptr) {

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_NULL);

        SET_ERROR_PARAMETER(testing_error, TOX_ERR_NEW_TESTING_NULL);

        return nullptr;

    }

    if (testing->operating_system == nullptr) {

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_NULL);

        SET_ERROR_PARAMETER(testing_error, TOX_ERR_NEW_TESTING_NULL);

        return nullptr;

    }

    const Tox_System *sys = testing->operating_system;

    if (sys->rng == nullptr || sys->ns == nullptr || sys->mem == nullptr) {

        SET_ERROR_PARAMETER(error, TOX_ERR_NEW_NULL);

        SET_ERROR_PARAMETER(testing_error, TOX_ERR_NEW_TESTING_NULL);

        return nullptr;

    }

    SET_ERROR_PARAMETER(testing_error, TOX_ERR_NEW_TESTING_OK);

    return tox_new_system(options, error, sys);

}

void tox_kill(Tox *_Nullable tox)

{

    if (tox == nullptr) {

        return;

    }

    tox_lock(tox);

    LOGGER_ASSERT(tox->m->log, tox->toxav_object == nullptr, "Attempted to kill tox while toxav is still alive");

    kill_groupchats(tox->m->conferences_object);

    kill_messenger(tox->m);

    logger_kill(tox->log);

    mono_time_free(tox->sys.mem, tox->mono_time);

    tox_unlock(tox);