diff options
Diffstat (limited to 'protocols/Tox/libtox/src/toxcore/group_common.h')
| -rw-r--r-- | protocols/Tox/libtox/src/toxcore/group_common.h | 409 |
1 files changed, 409 insertions, 0 deletions
diff --git a/protocols/Tox/libtox/src/toxcore/group_common.h b/protocols/Tox/libtox/src/toxcore/group_common.h new file mode 100644 index 0000000000..ef901e8a3a --- /dev/null +++ b/protocols/Tox/libtox/src/toxcore/group_common.h @@ -0,0 +1,409 @@ +/* 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 + +#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 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 |