Tha_14/tomato-testing
1
0
Fork 0
forked from Green-Sky/tomato
Code Pull Requests Actions Packages Releases Activity
4f02c2b55b
tomato-testing/toxcore/group_common.h
Green Sky 4f02c2b55b Squashed 'external/toxcore/c-toxcore/' changes from 75f3c33943..d4b06edc2a 
d4b06edc2a feat: add ngc events
cd34b60f0f feat: allow for larger incoming NGC packets
94cf9d1f36 fix: Fix memory leak in the error path of loading savedata.
fc623a5281 tox_new() should return null when savedata loading fails
06d949a701 fix: always respond to version packets with toxcore version
REVERT: 75f3c33943 adopt to #2415 changes
REVERT: 38e4c82fe0 feat: add ngc events

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: d4b06edc2a35bad51b0f0950d74f61c8c70630ab
2023-11-17 16:01:52 +01:00

413 lines
17 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2016-2022 The TokTok team.
*/
/**
* Common groupchat data structures.
*/
#ifndef GROUP_COMMON_H
#define GROUP_COMMON_H
#include <stdbool.h>
#include <stdint.h>
#include "DHT.h"
#include "TCP_connection.h"
#include "group_moderation.h"
#define MAX_GC_PART_MESSAGE_SIZE 128
#define MAX_GC_NICK_SIZE 128
#define MAX_GC_TOPIC_SIZE 512
#define MAX_GC_GROUP_NAME_SIZE 48
#define GC_MESSAGE_PSEUDO_ID_SIZE 4
#define GROUP_MAX_MESSAGE_LENGTH 1372
/* Max size of a packet chunk. Packets larger than this must be split up.
*
* For an explanation on why this value was chosen, see the following link: https://archive.ph/vsCOG
*/
#define MAX_GC_PACKET_CHUNK_SIZE 500
/* Max size of an incoming packet chunk that is allowed */
#define MAX_GC_PACKET_INCOMING_CHUNK_SIZE 1372
#define MAX_GC_MESSAGE_SIZE GROUP_MAX_MESSAGE_LENGTH
#define MAX_GC_MESSAGE_RAW_SIZE (MAX_GC_MESSAGE_SIZE + GC_MESSAGE_PSEUDO_ID_SIZE)
#define MAX_GC_CUSTOM_LOSSLESS_PACKET_SIZE 1373
#define MAX_GC_CUSTOM_LOSSY_PACKET_SIZE MAX_GC_PACKET_CHUNK_SIZE
#define MAX_GC_PASSWORD_SIZE 32
#define MAX_GC_SAVED_INVITES 10
#define MAX_GC_PEERS_DEFAULT 100
#define MAX_GC_SAVED_TIMEOUTS 12
#define GC_MAX_SAVED_PEERS 100
#define GC_SAVED_PEER_SIZE (ENC_PUBLIC_KEY_SIZE + sizeof(Node_format) + sizeof(IP_Port))
/* Max size of a complete encrypted packet including headers. */
#define MAX_GC_PACKET_SIZE (MAX_GC_PACKET_CHUNK_SIZE * 100)
/* Max number of messages to store in the send/recv arrays */
#define GCC_BUFFER_SIZE 8192
/** Self UDP status. Must correspond to return values from `ipport_self_copy()`. */
typedef enum Self_UDP_Status {
SELF_UDP_STATUS_NONE = 0x00,
SELF_UDP_STATUS_WAN = 0x01,
SELF_UDP_STATUS_LAN = 0x02,
} Self_UDP_Status;
/** Group exit types. */
typedef enum Group_Exit_Type {
GC_EXIT_TYPE_QUIT = 0x00, // Peer left the group
GC_EXIT_TYPE_TIMEOUT = 0x01, // Peer connection timed out
GC_EXIT_TYPE_DISCONNECTED = 0x02, // Peer diconnected from group
GC_EXIT_TYPE_SELF_DISCONNECTED = 0x03, // Self disconnected from group
GC_EXIT_TYPE_KICKED = 0x04, // Peer was kicked from the group
GC_EXIT_TYPE_SYNC_ERR = 0x05, // Peer failed to sync with the group
GC_EXIT_TYPE_NO_CALLBACK = 0x06, // The peer exit callback should not be triggered
} Group_Exit_Type;
typedef struct GC_Exit_Info {
uint8_t part_message[MAX_GC_PART_MESSAGE_SIZE];
uint16_t length;
Group_Exit_Type exit_type;
} GC_Exit_Info;
typedef struct GC_PeerAddress {
uint8_t public_key[EXT_PUBLIC_KEY_SIZE];
IP_Port ip_port;
} GC_PeerAddress;
typedef struct GC_Message_Array_Entry {
uint8_t *data;
uint16_t data_length;
uint8_t packet_type;
uint64_t message_id;
uint64_t time_added;
uint64_t last_send_try;
} GC_Message_Array_Entry;
typedef struct GC_Connection {
uint64_t send_message_id; /* message_id of the next message we send to peer */
uint16_t send_array_start; /* send_array index of oldest item */
GC_Message_Array_Entry *send_array;
uint64_t received_message_id; /* message_id of peer's last message to us */
GC_Message_Array_Entry *recv_array;
uint64_t last_chunk_id; /* The message ID of the last packet fragment we received */
GC_PeerAddress addr; /* holds peer's extended real public key and ip_port */
uint32_t public_key_hash; /* Jenkins one at a time hash of peer's real encryption public key */
uint8_t session_public_key[ENC_PUBLIC_KEY_SIZE]; /* self session public key for this peer */
uint8_t session_secret_key[ENC_SECRET_KEY_SIZE]; /* self session secret key for this peer */
uint8_t session_shared_key[CRYPTO_SHARED_KEY_SIZE]; /* made with our session sk and peer's session pk */
int tcp_connection_num;
uint64_t last_sent_tcp_relays_time; /* the last time we attempted to send this peer our tcp relays */
uint16_t tcp_relay_share_index;
uint64_t last_received_direct_time; /* the last time we received a direct UDP packet from this connection */
uint64_t last_sent_ip_time; /* the last time we sent our ip info to this peer in a ping packet */
Node_format connected_tcp_relays[MAX_FRIEND_TCP_CONNECTIONS];
uint16_t tcp_relays_count;
uint64_t last_received_packet_time; /* The last time we successfully processed any packet from this peer */
uint64_t last_requested_packet_time; /* The last time we requested a missing packet from this peer */
uint64_t last_sent_ping_time;
uint64_t last_sync_response; /* the last time we sent this peer a sync response */
uint8_t oob_relay_pk[CRYPTO_PUBLIC_KEY_SIZE];
bool self_is_closer; /* true if we're "closer" to the chat_id than this peer (uses real pk's) */
bool confirmed; /* true if this peer has given us their info */
bool handshaked; /* true if we've successfully handshaked with this peer */
uint16_t handshake_attempts;
uint64_t last_handshake_request;
uint64_t last_handshake_response;
uint8_t pending_handshake_type;
bool is_pending_handshake_response;
bool is_oob_handshake;
uint64_t last_key_rotation; /* the last time we rotated session keys for this peer */
bool pending_key_rotation_request;
bool pending_delete; /* true if this peer has been marked for deletion */
GC_Exit_Info exit_info;
} GC_Connection;
/***
* Group roles. Roles are hierarchical in that each role has a set of privileges plus
* all the privileges of the roles below it.
*/
typedef enum Group_Role {
/** Group creator. All-powerful. Cannot be demoted or kicked. */
GR_FOUNDER = 0x00,
/**
* May promote or demote peers below them to any role below them.
* May also kick peers below them and set the topic.
*/
GR_MODERATOR = 0x01,
/** may interact normally with the group. */
GR_USER = 0x02,
/** May not interact with the group but may observe. */
GR_OBSERVER = 0x03,
} Group_Role;
typedef enum Group_Peer_Status {
GS_NONE = 0x00,
GS_AWAY = 0x01,
GS_BUSY = 0x02,
} Group_Peer_Status;
/**
* Group voice states. The state determines which Group Roles have permission to speak.
*/
typedef enum Group_Voice_State {
/** Every group role except Observers may speak. */
GV_ALL = 0x00,
/** Only Moderators and the Founder may speak. */
GV_MODS = 0x01,
/** Only the Founder may speak. */
GV_FOUNDER = 0x02,
} Group_Voice_State;
/** Group connection states. */
typedef enum GC_Conn_State {
CS_NONE = 0x00, // Indicates a group is not initialized
CS_DISCONNECTED = 0x01, // Not receiving or sending any packets
CS_CONNECTING = 0x02, // Attempting to establish a connection with peers in the group
CS_CONNECTED = 0x03, // Has successfully received a sync response from a peer in the group
} GC_Conn_State;
/** Group privacy states. */
typedef enum Group_Privacy_State {
GI_PUBLIC = 0x00, // Anyone with the chat ID may join the group
GI_PRIVATE = 0x01, // Peers may only join the group via a friend invite
} Group_Privacy_State;
/** Handshake join types. */
typedef enum Group_Handshake_Join_Type {
HJ_PUBLIC = 0x00, // Indicates the group was joined via the DHT
HJ_PRIVATE = 0x01, // Indicates the group was joined via private friend invite
} Group_Handshake_Join_Type;
typedef struct GC_SavedPeerInfo {
uint8_t public_key[ENC_PUBLIC_KEY_SIZE];
Node_format tcp_relay;
IP_Port ip_port;
} GC_SavedPeerInfo;
/** Holds info about peers who recently timed out */
typedef struct GC_TimedOutPeer {
GC_SavedPeerInfo addr;
uint64_t last_seen; // the time the peer disconnected
uint64_t last_reconn_try; // the last time we tried to establish a new connection
} GC_TimedOutPeer;
typedef struct GC_Peer {
/* Below state is sent to other peers in peer info exchange */
uint8_t nick[MAX_GC_NICK_SIZE];
uint16_t nick_length;
uint8_t status;
/* Below state is local only */
Group_Role role;
uint32_t peer_id; // permanent ID (used for the public API)
bool ignore;
GC_Connection gconn;
} GC_Peer;
typedef struct GC_SharedState {
uint32_t version;
uint8_t founder_public_key[EXT_PUBLIC_KEY_SIZE];
uint16_t maxpeers;
uint16_t group_name_len;
uint8_t group_name[MAX_GC_GROUP_NAME_SIZE];
Group_Privacy_State privacy_state; // GI_PUBLIC (uses DHT) or GI_PRIVATE (invite only)
uint16_t password_length;
uint8_t password[MAX_GC_PASSWORD_SIZE];
uint8_t mod_list_hash[MOD_MODERATION_HASH_SIZE];
uint32_t topic_lock; // equal to GC_TOPIC_LOCK_ENABLED when lock is enabled
Group_Voice_State voice_state;
} GC_SharedState;
typedef struct GC_TopicInfo {
uint32_t version;
uint16_t length;
uint16_t checksum; // used for syncing problems. the checksum with the highest value gets priority.
uint8_t topic[MAX_GC_TOPIC_SIZE];
uint8_t public_sig_key[SIG_PUBLIC_KEY_SIZE]; // Public signature key of the topic setter
} GC_TopicInfo;
typedef struct GC_Chat {
Mono_Time *mono_time;
const Logger *log;
const Memory *mem;
const Random *rng;
uint32_t connected_tcp_relays;
Self_UDP_Status self_udp_status;
IP_Port self_ip_port;
Networking_Core *net;
TCP_Connections *tcp_conn;
uint64_t last_checked_tcp_relays;
Group_Handshake_Join_Type join_type;
GC_Peer *group;
Moderation moderation;
GC_Conn_State connection_state;
GC_SharedState shared_state;
uint8_t shared_state_sig[SIGNATURE_SIZE]; // signed by founder using the chat secret key
GC_TopicInfo topic_info;
uint8_t topic_sig[SIGNATURE_SIZE]; // signed by the peer who set the current topic
uint16_t topic_prev_checksum; // checksum of the previous topic
uint64_t topic_time_set;
uint16_t peers_checksum; // sum of the public key hash of every confirmed peer in the group
uint16_t roles_checksum; // sum of every confirmed peer's role plus the first byte of their public key
uint32_t numpeers;
int group_number;
uint8_t chat_public_key[EXT_PUBLIC_KEY_SIZE]; // the chat_id is the sig portion
uint8_t chat_secret_key[EXT_SECRET_KEY_SIZE]; // only used by the founder
uint8_t self_public_key[EXT_PUBLIC_KEY_SIZE];
uint8_t self_secret_key[EXT_SECRET_KEY_SIZE];
uint64_t time_connected;
uint64_t last_ping_interval;
uint64_t last_sync_request; // The last time we sent a sync request to any peer
uint64_t last_sync_response_peer_list; // The last time we sent the peer list to any peer
uint64_t last_time_peers_loaded;
/* keeps track of frequency of new inbound connections */
uint8_t connection_o_metre;
uint64_t connection_cooldown_timer;
bool block_handshakes;
int32_t saved_invites[MAX_GC_SAVED_INVITES];
uint8_t saved_invites_index;
/** A list of recently seen peers in case we disconnect from a private group.
* Peers are added once they're confirmed, and only if there are vacant
* spots (older connections get priority). An entry is removed only when the list
* is full, its respective peer goes offline, and an online peer who isn't yet
* present in the list can be added.
*/
GC_SavedPeerInfo saved_peers[GC_MAX_SAVED_PEERS];
GC_TimedOutPeer timeout_list[MAX_GC_SAVED_TIMEOUTS];
size_t timeout_list_index;
uint64_t last_timed_out_reconn_try; // the last time we tried to reconnect to timed out peers
bool update_self_announces; // true if we should try to update our announcements
uint64_t last_self_announce_check; // the last time we checked if we should update our announcements
uint64_t last_time_self_announce; // the last time we announced the group
uint8_t announced_tcp_relay_pk[CRYPTO_PUBLIC_KEY_SIZE]; // The pk of the last TCP relay we announced
uint8_t m_group_public_key[CRYPTO_PUBLIC_KEY_SIZE]; // public key for group's messenger friend connection
int friend_connection_id; // identifier for group's messenger friend connection
} GC_Chat;
#ifndef MESSENGER_DEFINED
#define MESSENGER_DEFINED
typedef struct Messenger Messenger;
#endif /* MESSENGER_DEFINED */
typedef void gc_message_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int type,
const uint8_t *data, size_t length, uint32_t message_id, void *user_data);
typedef void gc_private_message_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int type,
const uint8_t *data, size_t length, void *user_data);
typedef void gc_custom_packet_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, const uint8_t *data,
size_t length, void *user_data);
typedef void gc_custom_private_packet_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id,
const uint8_t *data,
size_t length, void *user_data);
typedef void gc_moderation_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, uint32_t target_peer,
unsigned int mod_event, void *user_data);
typedef void gc_nick_change_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, const uint8_t *data,
size_t length, void *user_data);
typedef void gc_status_change_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int status,
void *user_data);
typedef void gc_topic_change_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, const uint8_t *data,
size_t length, void *user_data);
typedef void gc_topic_lock_cb(const Messenger *m, uint32_t group_number, unsigned int topic_lock, void *user_data);
typedef void gc_voice_state_cb(const Messenger *m, uint32_t group_number, unsigned int voice_state, void *user_data);
typedef void gc_peer_limit_cb(const Messenger *m, uint32_t group_number, uint32_t max_peers, void *user_data);
typedef void gc_privacy_state_cb(const Messenger *m, uint32_t group_number, unsigned int state, void *user_data);
typedef void gc_password_cb(const Messenger *m, uint32_t group_number, const uint8_t *data, size_t length,
void *user_data);
typedef void gc_peer_join_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, void *user_data);
typedef void gc_peer_exit_cb(const Messenger *m, uint32_t group_number, uint32_t peer_id, unsigned int exit_type,
const uint8_t *nick, size_t nick_len, const uint8_t *data, size_t length, void *user_data);
typedef void gc_self_join_cb(const Messenger *m, uint32_t group_number, void *user_data);
typedef void gc_rejected_cb(const Messenger *m, uint32_t group_number, unsigned int type, void *user_data);
typedef struct GC_Session {
Messenger *messenger;
GC_Chat *chats;
struct GC_Announces_List *announces_list;
uint32_t chats_index;
gc_message_cb *message;
gc_private_message_cb *private_message;
gc_custom_packet_cb *custom_packet;
gc_custom_private_packet_cb *custom_private_packet;
gc_moderation_cb *moderation;
gc_nick_change_cb *nick_change;
gc_status_change_cb *status_change;
gc_topic_change_cb *topic_change;
gc_topic_lock_cb *topic_lock;
gc_voice_state_cb *voice_state;
gc_peer_limit_cb *peer_limit;
gc_privacy_state_cb *privacy_state;
gc_password_cb *password;
gc_peer_join_cb *peer_join;
gc_peer_exit_cb *peer_exit;
gc_self_join_cb *self_join;
gc_rejected_cb *rejected;
} GC_Session;
/** @brief Adds a new peer to group_number's peer list.
*
* Return peer_number on success.
* Return -1 on failure.
* Return -2 if a peer with public_key is already in our peerlist.
*/
non_null(1, 3) nullable(2)
int peer_add(GC_Chat *chat, const IP_Port *ipp, const uint8_t *public_key);
/** @brief Unpacks saved peers from `data` of size `length` into `chat`.
*
* Returns the number of unpacked peers on success.
* Returns -1 on failure.
*/
non_null()
int unpack_gc_saved_peers(GC_Chat *chat, const uint8_t *data, uint16_t length);
/** @brief Packs all valid entries from saved peerlist into `data`.
*
* If `processed` is non-null it will be set to the length of the packed data.
*
* Return the number of packed saved peers on success.
* Return -1 if buffer is too small.
*/
non_null(1, 2) nullable(4)
int pack_gc_saved_peers(const GC_Chat *chat, uint8_t *data, uint16_t length, uint16_t *processed);
#endif // GROUP_COMMON_H
View Git Blame Copy Permalink