forked from Green-Sky/tomato
Green Sky
227425b90e
git-subtree-dir: external/toxcore/c-toxcore git-subtree-split: 67badf69416a74e74f6d7eb51dd96f37282b8455
463 lines
13 KiB
C
463 lines
13 KiB
C
/* SPDX-License-Identifier: GPL-3.0-or-later
|
|
* Copyright © 2016-2020 The TokTok team.
|
|
* Copyright © 2015 Tox project.
|
|
*/
|
|
|
|
#include "group_announce.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "LAN_discovery.h"
|
|
#include "ccompat.h"
|
|
#include "mono_time.h"
|
|
#include "util.h"
|
|
|
|
/**
|
|
* Removes `announces` from `gc_announces_list`.
|
|
*/
|
|
non_null()
|
|
static void remove_announces(GC_Announces_List *gc_announces_list, GC_Announces *announces)
|
|
{
|
|
if (announces == nullptr || gc_announces_list == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (announces->prev_announce != nullptr) {
|
|
announces->prev_announce->next_announce = announces->next_announce;
|
|
} else {
|
|
gc_announces_list->root_announces = announces->next_announce;
|
|
}
|
|
|
|
if (announces->next_announce != nullptr) {
|
|
announces->next_announce->prev_announce = announces->prev_announce;
|
|
}
|
|
|
|
free(announces);
|
|
}
|
|
|
|
/**
|
|
* Returns the announce designated by `chat_id`.
|
|
* Returns null if no announce is found.
|
|
*/
|
|
non_null()
|
|
static GC_Announces *get_announces_by_chat_id(const GC_Announces_List *gc_announces_list, const uint8_t *chat_id)
|
|
{
|
|
GC_Announces *announces = gc_announces_list->root_announces;
|
|
|
|
while (announces != nullptr) {
|
|
if (memcmp(announces->chat_id, chat_id, CHAT_ID_SIZE) == 0) {
|
|
return announces;
|
|
}
|
|
|
|
announces = announces->next_announce;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
int gca_get_announces(const GC_Announces_List *gc_announces_list, GC_Announce *gc_announces, uint8_t max_nodes,
|
|
const uint8_t *chat_id, const uint8_t *except_public_key)
|
|
{
|
|
if (gc_announces == nullptr || gc_announces_list == nullptr || chat_id == nullptr || max_nodes == 0
|
|
|| except_public_key == nullptr) {
|
|
return -1;
|
|
}
|
|
|
|
const GC_Announces *announces = get_announces_by_chat_id(gc_announces_list, chat_id);
|
|
|
|
if (announces == nullptr) {
|
|
return 0;
|
|
}
|
|
|
|
uint16_t added_count = 0;
|
|
|
|
for (size_t i = 0; i < announces->index && i < GCA_MAX_SAVED_ANNOUNCES_PER_GC && added_count < max_nodes; ++i) {
|
|
const size_t index = i % GCA_MAX_SAVED_ANNOUNCES_PER_GC;
|
|
|
|
if (memcmp(except_public_key, &announces->peer_announces[index].base_announce.peer_public_key,
|
|
ENC_PUBLIC_KEY_SIZE) == 0) {
|
|
continue;
|
|
}
|
|
|
|
bool already_added = false;
|
|
|
|
for (size_t j = 0; j < added_count; ++j) {
|
|
if (memcmp(&gc_announces[j].peer_public_key, &announces->peer_announces[index].base_announce.peer_public_key,
|
|
ENC_PUBLIC_KEY_SIZE) == 0) {
|
|
already_added = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!already_added) {
|
|
gc_announces[added_count] = announces->peer_announces[index].base_announce;
|
|
++added_count;
|
|
}
|
|
}
|
|
|
|
return added_count;
|
|
}
|
|
|
|
uint16_t gca_pack_announces_list_size(uint16_t count)
|
|
{
|
|
return count * GCA_ANNOUNCE_MAX_SIZE;
|
|
}
|
|
|
|
int gca_pack_announce(const Logger *log, uint8_t *data, uint16_t length, const GC_Announce *announce)
|
|
{
|
|
if (length < GCA_ANNOUNCE_MAX_SIZE) {
|
|
LOGGER_ERROR(log, "Invalid announce length: %u", length);
|
|
return -1;
|
|
}
|
|
|
|
if (data == nullptr) {
|
|
LOGGER_ERROR(log, "data is null");
|
|
return -1;
|
|
}
|
|
|
|
if (announce == nullptr) {
|
|
LOGGER_ERROR(log, "announce is null");
|
|
return -1;
|
|
}
|
|
|
|
uint16_t offset = 0;
|
|
memcpy(data + offset, announce->peer_public_key, ENC_PUBLIC_KEY_SIZE);
|
|
offset += ENC_PUBLIC_KEY_SIZE;
|
|
|
|
data[offset] = announce->ip_port_is_set ? 1 : 0;
|
|
++offset;
|
|
|
|
data[offset] = announce->tcp_relays_count;
|
|
++offset;
|
|
|
|
if (!announce->ip_port_is_set && announce->tcp_relays_count == 0) {
|
|
LOGGER_ERROR(log, "Failed to pack announce: no valid ip_port or tcp relay");
|
|
return -1;
|
|
}
|
|
|
|
if (announce->ip_port_is_set) {
|
|
const int ip_port_length = pack_ip_port(log, data + offset, length - offset, &announce->ip_port);
|
|
|
|
if (ip_port_length == -1) {
|
|
LOGGER_ERROR(log, "Failed to pack ip_port");
|
|
return -1;
|
|
}
|
|
|
|
offset += ip_port_length;
|
|
}
|
|
|
|
const int nodes_length = pack_nodes(log, data + offset, length - offset, announce->tcp_relays,
|
|
announce->tcp_relays_count);
|
|
|
|
if (nodes_length == -1) {
|
|
LOGGER_ERROR(log, "Failed to pack TCP nodes");
|
|
return -1;
|
|
}
|
|
|
|
return nodes_length + offset;
|
|
}
|
|
|
|
/**
|
|
* Unpacks `announce` into `data` buffer of size `length`.
|
|
*
|
|
* Returns the size of the unpacked data on success.
|
|
* Returns -1 on failure.
|
|
*/
|
|
non_null()
|
|
static int gca_unpack_announce(const Logger *log, const uint8_t *data, uint16_t length, GC_Announce *announce)
|
|
{
|
|
if (length < ENC_PUBLIC_KEY_SIZE + 2) {
|
|
LOGGER_ERROR(log, "Invalid announce length: %u", length);
|
|
return -1;
|
|
}
|
|
|
|
if (data == nullptr) {
|
|
LOGGER_ERROR(log, "data is null");
|
|
return -1;
|
|
}
|
|
|
|
if (announce == nullptr) {
|
|
LOGGER_ERROR(log, "announce is null");
|
|
return -1;
|
|
}
|
|
|
|
uint16_t offset = 0;
|
|
memcpy(announce->peer_public_key, data + offset, ENC_PUBLIC_KEY_SIZE);
|
|
offset += ENC_PUBLIC_KEY_SIZE;
|
|
|
|
net_unpack_bool(&data[offset], &announce->ip_port_is_set);
|
|
++offset;
|
|
|
|
announce->tcp_relays_count = data[offset];
|
|
++offset;
|
|
|
|
if (announce->tcp_relays_count > GCA_MAX_ANNOUNCED_TCP_RELAYS) {
|
|
return -1;
|
|
}
|
|
|
|
if (announce->ip_port_is_set) {
|
|
if (length - offset == 0) {
|
|
return -1;
|
|
}
|
|
|
|
const int ip_port_length = unpack_ip_port(&announce->ip_port, data + offset, length - offset, false);
|
|
|
|
if (ip_port_length == -1) {
|
|
LOGGER_ERROR(log, "Failed to unpack ip_port");
|
|
return -1;
|
|
}
|
|
|
|
offset += ip_port_length;
|
|
}
|
|
|
|
uint16_t nodes_length;
|
|
const int nodes_count = unpack_nodes(announce->tcp_relays, announce->tcp_relays_count, &nodes_length,
|
|
data + offset, length - offset, true);
|
|
|
|
if (nodes_count != announce->tcp_relays_count) {
|
|
LOGGER_ERROR(log, "Failed to unpack TCP nodes");
|
|
return -1;
|
|
}
|
|
|
|
return offset + nodes_length;
|
|
}
|
|
|
|
int gca_pack_public_announce(const Logger *log, uint8_t *data, uint16_t length,
|
|
const GC_Public_Announce *public_announce)
|
|
{
|
|
if (public_announce == nullptr || data == nullptr || length < CHAT_ID_SIZE) {
|
|
return -1;
|
|
}
|
|
|
|
memcpy(data, public_announce->chat_public_key, CHAT_ID_SIZE);
|
|
|
|
const int packed_size = gca_pack_announce(log, data + CHAT_ID_SIZE, length - CHAT_ID_SIZE,
|
|
&public_announce->base_announce);
|
|
|
|
if (packed_size < 0) {
|
|
LOGGER_ERROR(log, "Failed to pack public group announce");
|
|
return -1;
|
|
}
|
|
|
|
return packed_size + CHAT_ID_SIZE;
|
|
}
|
|
|
|
int gca_unpack_public_announce(const Logger *log, const uint8_t *data, uint16_t length,
|
|
GC_Public_Announce *public_announce)
|
|
{
|
|
if (length < CHAT_ID_SIZE) {
|
|
LOGGER_ERROR(log, "invalid public announce length: %u", length);
|
|
return -1;
|
|
}
|
|
|
|
if (data == nullptr) {
|
|
LOGGER_ERROR(log, "data is null");
|
|
return -1;
|
|
}
|
|
|
|
if (public_announce == nullptr) {
|
|
LOGGER_ERROR(log, "public_announce is null");
|
|
return -1;
|
|
}
|
|
|
|
memcpy(public_announce->chat_public_key, data, CHAT_ID_SIZE);
|
|
|
|
const int base_announce_size = gca_unpack_announce(log, data + ENC_PUBLIC_KEY_SIZE, length - ENC_PUBLIC_KEY_SIZE,
|
|
&public_announce->base_announce);
|
|
|
|
if (base_announce_size == -1) {
|
|
LOGGER_ERROR(log, "Failed to unpack group announce");
|
|
return -1;
|
|
}
|
|
|
|
return base_announce_size + CHAT_ID_SIZE;
|
|
}
|
|
|
|
int gca_pack_announces_list(const Logger *log, uint8_t *data, uint16_t length, const GC_Announce *announces,
|
|
uint8_t announces_count, size_t *processed)
|
|
{
|
|
if (data == nullptr) {
|
|
LOGGER_ERROR(log, "data is null");
|
|
return -1;
|
|
}
|
|
|
|
if (announces == nullptr) {
|
|
LOGGER_ERROR(log, "announces is null");
|
|
return -1;
|
|
}
|
|
|
|
uint16_t offset = 0;
|
|
|
|
for (size_t i = 0; i < announces_count; ++i) {
|
|
const int packed_length = gca_pack_announce(log, data + offset, length - offset, &announces[i]);
|
|
|
|
if (packed_length < 0) {
|
|
LOGGER_ERROR(log, "Failed to pack group announce");
|
|
return -1;
|
|
}
|
|
|
|
offset += packed_length;
|
|
}
|
|
|
|
if (processed != nullptr) {
|
|
*processed = offset;
|
|
}
|
|
|
|
return announces_count;
|
|
}
|
|
|
|
int gca_unpack_announces_list(const Logger *log, const uint8_t *data, uint16_t length, GC_Announce *announces,
|
|
uint8_t max_count)
|
|
{
|
|
if (data == nullptr) {
|
|
LOGGER_ERROR(log, "data is null");
|
|
return -1;
|
|
}
|
|
|
|
if (announces == nullptr) {
|
|
LOGGER_ERROR(log, "announces is null");
|
|
return -1;
|
|
}
|
|
|
|
uint16_t offset = 0;
|
|
int announces_count = 0;
|
|
|
|
for (size_t i = 0; i < max_count && length > offset; ++i) {
|
|
const int unpacked_length = gca_unpack_announce(log, data + offset, length - offset, &announces[i]);
|
|
|
|
if (unpacked_length == -1) {
|
|
LOGGER_WARNING(log, "Failed to unpack group announce: %d %d", length, offset);
|
|
return -1;
|
|
}
|
|
|
|
offset += unpacked_length;
|
|
++announces_count;
|
|
}
|
|
|
|
return announces_count;
|
|
}
|
|
|
|
GC_Peer_Announce *gca_add_announce(const Mono_Time *mono_time, GC_Announces_List *gc_announces_list,
|
|
const GC_Public_Announce *public_announce)
|
|
{
|
|
if (gc_announces_list == nullptr || public_announce == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
GC_Announces *announces = get_announces_by_chat_id(gc_announces_list, public_announce->chat_public_key);
|
|
|
|
// No entry for this chat_id exists so we create one
|
|
if (announces == nullptr) {
|
|
announces = (GC_Announces *)calloc(1, sizeof(GC_Announces));
|
|
|
|
if (announces == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
announces->index = 0;
|
|
announces->prev_announce = nullptr;
|
|
|
|
if (gc_announces_list->root_announces != nullptr) {
|
|
gc_announces_list->root_announces->prev_announce = announces;
|
|
}
|
|
|
|
announces->next_announce = gc_announces_list->root_announces;
|
|
gc_announces_list->root_announces = announces;
|
|
memcpy(announces->chat_id, public_announce->chat_public_key, CHAT_ID_SIZE);
|
|
}
|
|
|
|
const uint64_t cur_time = mono_time_get(mono_time);
|
|
|
|
announces->last_announce_received_timestamp = cur_time;
|
|
|
|
const uint64_t index = announces->index % GCA_MAX_SAVED_ANNOUNCES_PER_GC;
|
|
|
|
GC_Peer_Announce *gc_peer_announce = &announces->peer_announces[index];
|
|
|
|
gc_peer_announce->base_announce = public_announce->base_announce;
|
|
|
|
gc_peer_announce->timestamp = cur_time;
|
|
|
|
++announces->index;
|
|
|
|
return gc_peer_announce;
|
|
}
|
|
|
|
bool gca_is_valid_announce(const GC_Announce *announce)
|
|
{
|
|
if (announce == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
return announce->tcp_relays_count > 0 || announce->ip_port_is_set;
|
|
}
|
|
|
|
GC_Announces_List *new_gca_list(void)
|
|
{
|
|
GC_Announces_List *announces_list = (GC_Announces_List *)calloc(1, sizeof(GC_Announces_List));
|
|
return announces_list;
|
|
}
|
|
|
|
void kill_gca(GC_Announces_List *announces_list)
|
|
{
|
|
if (announces_list == nullptr) {
|
|
return;
|
|
}
|
|
|
|
GC_Announces *root = announces_list->root_announces;
|
|
|
|
while (root != nullptr) {
|
|
GC_Announces *next = root->next_announce;
|
|
free(root);
|
|
root = next;
|
|
}
|
|
|
|
free(announces_list);
|
|
}
|
|
|
|
/* How long we save a peer's announce before we consider it stale and remove it. */
|
|
#define GCA_ANNOUNCE_SAVE_TIMEOUT 30
|
|
|
|
/* How often we run do_gca() */
|
|
#define GCA_DO_GCA_TIMEOUT 1
|
|
|
|
void do_gca(const Mono_Time *mono_time, GC_Announces_List *gc_announces_list)
|
|
{
|
|
if (gc_announces_list == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (!mono_time_is_timeout(mono_time, gc_announces_list->last_timeout_check, GCA_DO_GCA_TIMEOUT)) {
|
|
return;
|
|
}
|
|
|
|
gc_announces_list->last_timeout_check = mono_time_get(mono_time);
|
|
|
|
GC_Announces *announces = gc_announces_list->root_announces;
|
|
|
|
while (announces != nullptr) {
|
|
if (mono_time_is_timeout(mono_time, announces->last_announce_received_timestamp, GCA_ANNOUNCE_SAVE_TIMEOUT)) {
|
|
GC_Announces *to_delete = announces;
|
|
announces = announces->next_announce;
|
|
remove_announces(gc_announces_list, to_delete);
|
|
continue;
|
|
}
|
|
|
|
announces = announces->next_announce;
|
|
}
|
|
}
|
|
|
|
void cleanup_gca(GC_Announces_List *gc_announces_list, const uint8_t *chat_id)
|
|
{
|
|
if (gc_announces_list == nullptr || chat_id == nullptr) {
|
|
return;
|
|
}
|
|
|
|
GC_Announces *announces = get_announces_by_chat_id(gc_announces_list, chat_id);
|
|
|
|
if (announces != nullptr) {
|
|
remove_announces(gc_announces_list, announces);
|
|
}
|
|
}
|