Green-Sky/NGC_HS1
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Green-Sky:b1906172851017a87c83a81400dc7936a68bf362
Branches Tags
Green-Sky:master
...
compare: Green-Sky:master
Branches Tags
Green-Sky:master

15 Commits
b190617285 ... master

Author SHA1 Message Date
Green Sky
f940d44952 better includes 2023-01-13 17:33:03 +01:00
Green Sky
9e262120b0 timeout started filetransfers 2023-01-13 16:23:28 +01:00
Green Sky
1f4c2a39c5 fix it 2023-01-13 03:22:04 +01:00
Green Sky
f7313aa2bf compiled again, some kinda bug still there 2023-01-13 00:39:56 +01:00
Green Sky
89f9610730 midway through refactor, ft done (?) 2023-01-12 22:48:51 +01:00
Green Sky
2031ef94b6 remove ngc ext (moved to gh) 2023-01-12 20:26:21 +01:00
Green Sky
e974522a38 fix message reading and writing 2023-01-12 03:24:15 +01:00
Green Sky
f8816d5c53 notify toxic as if we are toxcore 2023-01-12 03:04:20 +01:00
Green Sky
e858f23fc1 works 2023-01-12 02:36:29 +01:00
Green Sky
dbcf2777c0 tf now more or less working 2023-01-11 19:00:49 +01:00
Green Sky
776be06433 accept init ack, send sequenced, handle data ack 
still need handle data and send ack
 2023-01-11 03:14:11 +01:00
Green Sky
6852cdd046 add logging cats 2023-01-04 20:25:41 +01:00
Green Sky
d4f3d3c4fb prot simp, iterate starte, more send code 2022-10-26 02:58:42 +02:00
Green Sky
428048c79f simplify ft_send.dot 2022-10-23 01:23:38 +02:00
Green Sky
d9e9a6b83d dot ft recv mostly done 2022-10-21 17:25:05 +02:00
10 changed files with 889 additions and 597 deletions
Expand all files Collapse all files

6
ft_recv.dot
View File

@ -15,15 +15,19 @@ digraph ft_send {
start -> starting [label="send FT_INIT_ACK"];
starting -> starting [label="if timeout or get FT_INIT send FT_INIT_ACK"];
starting -> got_data [label="got FT_DATA"];
starting -> fail [label="if timeout too often"];
got_data -> fail [label="peer offline"];
subgraph cluster_data {
label="for each data chunk";
style=filled;
starting -> got_data [label="got FT_DATA"];
got_data -> wait_for_all_data [label="send FT_DATA_ACK"];
}
wait_for_all_data -> fail [label="peer offline"];
wait_for_all_data -> done [label="all chunks received and acked"];
}

32
ft_send.dot
View File

@ -14,39 +14,17 @@ digraph ft_send {
done [shape=doublecircle];
// peer offline (how)
start -> fail [label="peer offline"]
start -> fail [label="peer offline"];
// TODO: move to single node with loop
subgraph cluster_init {
label="Send Init";
style=filled;
//color=lightgrey;
// if it fails
sent_init1 -> sent_init2 [label="send FT_INIT"]
// if it fails again
sent_init2 -> sent_init3 [label="send FT_INIT"]
}
start -> sent_init1 [label="send FT_INIT"]
start -> sent_init [label="send FT_INIT"];
// peer offline (how)
sent_init1 -> fail [label="peer offline"]
sent_init -> fail [label="peer offline OR timeout too often"];
// peer offline (how)
sent_init2 -> fail [label="peer offline"]
// give up after 3. attempt
sent_init3 -> fail [label="no ack / peer offline"]
sent_init -> sent_init [label="timeout & sentcount <= 3, send FT_INIT"];
// got an ack after an init
sent_init1 -> have_data [label="got init_ack"]
sent_init2 -> have_data [label="got init_ack"]
sent_init3 -> have_data [label="got init_ack"]
sent_init -> have_data [label="got init_ack"]
subgraph cluster_data {
label="for each data chunk";

102
ngc_ext_common.cpp
View File

@ -1,102 +0,0 @@
#include "./ngc_ext_common.hpp"
//#include <cstdint>
//#include <cassert>
#include <new>
//#include <map>
//#include <list>
//#include <set>
//#include <optional>
//#include <algorithm>
bool _GroupKey::operator<(const _GroupKey& rhs) const {
for (size_t i = 0; i < data.size(); i++) {
if (data[i] < rhs.data[i]) {
return true;
} else if (data[i] > rhs.data[i]) {
return false;
}
}
return false; // equal
}
bool _GroupKey::operator==(const _GroupKey& rhs) const {
for (size_t i = 0; i < data.size(); i++) {
if (data[i] != rhs.data[i]) {
return false;
}
}
return true;
}
bool _PeerKey::operator<(const _PeerKey& rhs) const {
for (size_t i = 0; i < data.size(); i++) {
if (data[i] < rhs.data[i]) {
return true;
} else if (data[i] > rhs.data[i]) {
return false;
}
}
return false; // equal
}
bool _PeerKey::operator==(const _PeerKey& rhs) const {
for (size_t i = 0; i < data.size(); i++) {
if (data[i] != rhs.data[i]) {
return false;
}
}
return true;
}
NGC_EXT_CTX* NGC_EXT_new(void) {
auto* ctx = new NGC_EXT_CTX;
// TODO: this is likely not necessary
for (auto& it : ctx->callbacks) {
it = nullptr;
}
return ctx;
}
void NGC_EXT_kill(NGC_EXT_CTX* ngc_ext_ctx) {
delete ngc_ext_ctx;
}
#define _EXT_HAVE(x, error) if ((length - curser) < (x)) { error; }
void NGC_EXT_handle_group_custom_packet(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
const uint8_t *data,
size_t length
//void *user_data
) {
size_t curser = 0;
_EXT_HAVE(1, return)
_PacketType pkg_type = static_cast<_PacketType>(*(data + curser));
curser++;
fprintf(stderr, "custom_packet [%s] %lu\n", _pkgid2str(pkg_type), length);
if (pkg_type == INVALID) {
fprintf(stderr, "(invalid)\n");
return;
}
auto handle_fn = ngc_ext_ctx->callbacks[pkg_type];
if (handle_fn == nullptr) {
fprintf(stderr, "!!! no handler for packet\n");
return;
}
handle_fn(tox, ngc_ext_ctx, group_number, peer_number, data+curser, length-curser);
}
#undef _EXT_HAVE

46
ngc_ext_common.h
View File

@ -1,46 +0,0 @@
#ifndef C_NGC_EXT_COMMON_H
#define C_NGC_EXT_COMMON_H
// this is a c header
#include <tox/tox.h>
#ifdef __cplusplus
extern "C" {
#endif
// copy from tox.h:
#ifndef TOX_DEFINED
#define TOX_DEFINED
typedef struct Tox Tox;
#endif /* TOX_DEFINED */
typedef struct NGC_EXT_CTX NGC_EXT_CTX;
NGC_EXT_CTX* NGC_EXT_new(void);
void NGC_EXT_kill(NGC_EXT_CTX* ngc_ext_ctx);
void NGC_EXT_handle_group_custom_packet(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
// bool private,
const uint8_t *data,
size_t length
//void *user_data
);
#ifdef __cplusplus
}
#endif
#endif // C_NGC_EXT_COMMON_H

144
ngc_ext_common.hpp
View File

@ -1,144 +0,0 @@
#pragma once
#include <tox/tox.h>
#include "ngc_ext_common.h"
#include "ngc_hs1.h"
#include "ngc_ft1.h"
//#include <cstdint>
//#include <cassert>
//#include <new>
//#include <map>
//#include <list>
//#include <set>
//#include <optional>
//#include <algorithm>
#include <array>
enum _PacketType : uint8_t {
// TODO: why?
INVALID = 0u,
//TODO: make it possible to go further back
// request last (few) message_ids for a peer
// - peer_key bytes (peer key we want to know ids for)
// - 1 byte (uint8_t count ids, atleast 1)
HS1_REQUEST_LAST_IDS = 1u,
// respond to a request with 0 or more message ids, sorted by newest first
// - peer_key bytes (the msg_ids are from)
// - 1 byte (uint8_t count ids, can be 0)
// - array [
// - msg_id bytes (the message id)
// - ]
HS1_RESPONSE_LAST_IDS,
// request the other side to initiate a FT
// - 1 byte (file_kind)
// - X bytes (file_kind dependent id, differnt sizes)
FT1_REQUEST = 8u,
// TODO: request result negative, speed up not found
// tell the other side you want to start a FT
// TODO: might use id layer instead. with it, it would look similar to friends_ft
// - 1 byte (file_kind)
// - 8 bytes (data size, can be 0 if unknown, BUT files have to be atleast 1 byte)
// - 1 byte (temporary_file_tf_id, for this peer only, technically just a prefix to distinguish between simultainious fts)
// - X bytes (file_kind dependent id, differnt sizes)
FT1_INIT,
// acknowlage init (like an accept)
// like tox ft control continue
// - 1 byte (transfer_id)
FT1_INIT_ACK,
// TODO: init deny, speed up non acceptance
// data fragment
// - 1 byte (temporary_file_tf_id)
// - 2 bytes (sequece id)
// - X bytes (the data fragment)
// (size is implicit)
FT1_DATA,
// acknowlage data fragments
// TODO: last 3 should be sufficient, 5 should be generous, would eleminate the byte for size
// - 1 byte (temporary_file_tf_id)
// // this is implicit (pkg size)- 1 byte (number of sequence ids to ack, this kind of depends on window size)
// - array [ (of sequece ids)
// - 2 bytes (sequece id)
// - ]
FT1_DATA_ACK,
//// sender has gotten every data fragment acked, so we signal finish
//// - 1 byte (temporary_file_tf_id)
//FT1_DATA_FIN,
//// and we ack that, we need this, so file_id is not reused earlier
//// - 1 byte (temporary_file_tf_id)
//FT1_DATA_FIN_ACK,
};
struct _GroupKey {
std::array<uint8_t, TOX_GROUP_CHAT_ID_SIZE> data;
_GroupKey(void) = default;
_GroupKey(const _GroupKey& other) : data(other.data) {}
_GroupKey(_GroupKey&&) = delete;
bool operator<(const _GroupKey& rhs) const;
bool operator==(const _GroupKey& rhs) const;
size_t size(void) const { return data.size(); }
};
struct _PeerKey {
std::array<uint8_t, TOX_GROUP_PEER_PUBLIC_KEY_SIZE> data;
_PeerKey(void) = default;
_PeerKey(const _PeerKey& other) : data(other.data) {}
_PeerKey(_PeerKey&&) = delete;
bool operator<(const _PeerKey& rhs) const;
bool operator==(const _PeerKey& rhs) const;
size_t size(void) const { return data.size(); }
};
using handle_group_custom_packet_cb = void(*)(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
const uint8_t *data,
size_t length
);
struct NGC_EXT_CTX {
std::array<handle_group_custom_packet_cb, 256> callbacks;
NGC_HS1* ngc_hs1_ctx = nullptr;
NGC_FT1* ngc_ft1_ctx = nullptr;
};
[[maybe_unused]] static const char* _pkgid2str(_PacketType type) {
#define _EXT_CASE(x) case (x): return #x;
switch (type) {
_EXT_CASE(INVALID)
_EXT_CASE(HS1_REQUEST_LAST_IDS)
_EXT_CASE(HS1_RESPONSE_LAST_IDS)
_EXT_CASE(FT1_REQUEST)
_EXT_CASE(FT1_INIT)
_EXT_CASE(FT1_INIT_ACK)
_EXT_CASE(FT1_DATA)
_EXT_CASE(FT1_DATA_ACK)
_EXT_CASE(FT1_DATA_FIN)
_EXT_CASE(FT1_DATA_FIN_ACK)
default: return "<unk>";
}
#undef _EXT_CASE
}

617
ngc_ft1.cpp
View File

@ -1,13 +1,102 @@
#include "./ngc_ft1.h"
#include "ngc_ext_common.hpp"
#include "../tox_ngc_ext/ngc_ext.hpp"
#include <vector>
#include <deque>
#include <unordered_map>
#include <map>
#include <optional>
#include <cassert>
struct SendSequenceBuffer {
struct SSBEntry {
std::vector<uint8_t> data; // the data (variable size, but smaller than 500)
float time_since_activity {0.f};
};
// sequence_id -> entry
std::map<uint16_t, SSBEntry> entries;
uint16_t next_seq_id {0};
void erase(uint16_t seq) {
entries.erase(seq);
}
// inflight chunks
size_t size(void) const {
return entries.size();
}
uint16_t add(std::vector<uint8_t>&& data) {
entries[next_seq_id] = {data, 0.f};
return next_seq_id++;
}
template<typename FN>
void for_each(float time_delta, FN&& fn) {
for (auto& [id, entry] : entries) {
entry.time_since_activity += time_delta;
fn(id, entry.data, entry.time_since_activity);
}
}
};
struct RecvSequenceBuffer {
struct RSBEntry {
std::vector<uint8_t> data;
};
// sequence_id -> entry
std::map<uint16_t, RSBEntry> entries;
uint16_t next_seq_id {0};
// list of seq_ids to ack, this is seperate bc rsbentries are deleted once processed
std::deque<uint16_t> ack_seq_ids;
void erase(uint16_t seq) {
entries.erase(seq);
}
// inflight chunks
size_t size(void) const {
return entries.size();
}
void add(uint16_t seq_id, std::vector<uint8_t>&& data) {
entries[seq_id] = {data};
ack_seq_ids.push_back(seq_id);
if (ack_seq_ids.size() > 5) { // TODO: magic
ack_seq_ids.pop_front();
}
}
bool canPop(void) const {
return entries.count(next_seq_id);
}
std::vector<uint8_t> pop(void) {
assert(canPop());
auto tmp_data = entries.at(next_seq_id).data;
erase(next_seq_id);
next_seq_id++;
return tmp_data;
}
// for acking, might be bad since its front
std::vector<uint16_t> frontSeqIDs(size_t count = 5) const {
std::vector<uint16_t> seq_ids;
auto it = entries.cbegin();
for (size_t i = 0; i < 5 && it != entries.cend(); i++, it++) {
seq_ids.push_back(it->first);
}
return seq_ids;
}
};
struct NGC_FT1 {
NGC_FT1_options options;
@ -15,10 +104,15 @@ struct NGC_FT1 {
std::unordered_map<NGC_FT1_file_kind, NGC_FT1_recv_init_cb*> cb_recv_init;
std::unordered_map<NGC_FT1_file_kind, NGC_FT1_recv_data_cb*> cb_recv_data;
std::unordered_map<NGC_FT1_file_kind, NGC_FT1_send_data_cb*> cb_send_data;
std::unordered_map<NGC_FT1_file_kind, void*> ud_recv_request;
std::unordered_map<NGC_FT1_file_kind, void*> ud_recv_init;
std::unordered_map<NGC_FT1_file_kind, void*> ud_recv_data;
std::unordered_map<NGC_FT1_file_kind, void*> ud_send_data;
struct Group {
struct Peer {
struct RecvTransfer {
NGC_FT1_file_kind file_kind;
std::vector<uint8_t> file_id;
enum class State {
@ -30,13 +124,14 @@ struct NGC_FT1 {
size_t file_size {0};
size_t file_size_current {0};
// sequence array
// list of last x received seq_ids
// sequence id based reassembly
RecvSequenceBuffer rsb;
};
std::array<std::optional<RecvTransfer>, 256> recv_transfers;
size_t next_recv_transfer_idx {0}; // next id will be 0
struct SendTransfer {
NGC_FT1_file_kind file_kind;
std::vector<uint8_t> file_id;
enum class State {
@ -52,12 +147,15 @@ struct NGC_FT1 {
// delete
} state;
// float time_since_last_activity ?
size_t inits_sent {1}; // is sent when creating
float time_since_activity {0.f};
size_t file_size {0};
size_t file_size_current {0};
// sequence array
// list of sent but not acked seq_ids
SendSequenceBuffer ssb;
};
std::array<std::optional<SendTransfer>, 256> send_transfers;
size_t next_send_transfer_idx {0}; // next id will be 0
@ -73,89 +171,208 @@ static bool _send_pkg_FT1_INIT(const Tox* tox, uint32_t group_number, uint32_t p
static bool _send_pkg_FT1_INIT_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id);
static bool _send_pkg_FT1_DATA(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, uint16_t sequence_id, const uint8_t* data, size_t data_size);
static bool _send_pkg_FT1_DATA_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, const uint16_t* seq_ids, size_t seq_ids_size);
static bool _send_pkg_FT1_DATA_FIN(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id);
static bool _send_pkg_FT1_DATA_FIN_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id);
// handle pkgs
static void _handle_FT1_REQUEST(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
static void _handle_FT1_INIT(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_INIT_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA_FIN(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
//static void _handle_FT1_DATA_FIN_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length);
static void _handle_FT1_REQUEST(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length, void* user_data);
static void _handle_FT1_INIT(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length, void* user_data);
static void _handle_FT1_INIT_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length, void* user_data);
static void _handle_FT1_DATA(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length, void* user_data);
static void _handle_FT1_DATA_ACK(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t *data, size_t length, void* user_data);
NGC_FT1* NGC_FT1_new(const struct NGC_FT1_options* options) {
NGC_FT1* ngc_ft1_ctx = new NGC_FT1;
ngc_ft1_ctx->options = *options;
return ngc_ft1_ctx;
}
bool NGC_FT1_register_ext(NGC_FT1* ngc_ft1_ctx, NGC_EXT_CTX* ngc_ext_ctx) {
ngc_ext_ctx->callbacks[NGC_EXT::FT1_REQUEST] = _handle_FT1_REQUEST;
ngc_ext_ctx->callbacks[NGC_EXT::FT1_INIT] = _handle_FT1_INIT;
ngc_ext_ctx->callbacks[NGC_EXT::FT1_INIT_ACK] = _handle_FT1_INIT_ACK;
ngc_ext_ctx->callbacks[NGC_EXT::FT1_DATA] = _handle_FT1_DATA;
ngc_ext_ctx->callbacks[NGC_EXT::FT1_DATA_ACK] = _handle_FT1_DATA_ACK;
ngc_ext_ctx->user_data[NGC_EXT::FT1_REQUEST] = ngc_ft1_ctx;
ngc_ext_ctx->user_data[NGC_EXT::FT1_INIT] = ngc_ft1_ctx;
ngc_ext_ctx->user_data[NGC_EXT::FT1_INIT_ACK] = ngc_ft1_ctx;
ngc_ext_ctx->user_data[NGC_EXT::FT1_DATA] = ngc_ft1_ctx;
ngc_ext_ctx->user_data[NGC_EXT::FT1_DATA_ACK] = ngc_ft1_ctx;
return true;
}
#if 0
bool NGC_FT1_init(NGC_EXT_CTX* ngc_ext_ctx, const struct NGC_FT1_options* options) {
ngc_ext_ctx->ngc_ft1_ctx = new NGC_FT1;
ngc_ext_ctx->ngc_ft1_ctx->options = *options;
ngc_ext_ctx->callbacks[FT1_REQUEST] = _handle_FT1_REQUEST;
ngc_ext_ctx->callbacks[FT1_INIT] = _handle_FT1_INIT;
ngc_ext_ctx->callbacks[FT1_INIT_ACK] = nullptr;
ngc_ext_ctx->callbacks[FT1_DATA] = nullptr;
ngc_ext_ctx->callbacks[FT1_DATA_ACK] = nullptr;
ngc_ext_ctx->callbacks[FT1_DATA_FIN] = nullptr;
ngc_ext_ctx->callbacks[FT1_DATA_FIN_ACK] = nullptr;
ngc_ext_ctx->callbacks[FT1_INIT_ACK] = _handle_FT1_INIT_ACK;
ngc_ext_ctx->callbacks[FT1_DATA] = _handle_FT1_DATA;
ngc_ext_ctx->callbacks[FT1_DATA_ACK] = _handle_FT1_DATA_ACK;
return true;
}
#endif
void NGC_FT1_kill(NGC_FT1* ngc_ft1_ctx) {
delete ngc_ft1_ctx;
}
#if 0
void NGC_FT1_kill(NGC_EXT_CTX* ngc_ext_ctx) {
delete ngc_ext_ctx->ngc_ft1_ctx;
ngc_ext_ctx->ngc_ft1_ctx = nullptr;
}
#endif
void NGC_FT1_register_callback_recv_request(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_request_cb* callback) {
assert(ngc_ext_ctx);
assert(ngc_ext_ctx->ngc_ft1_ctx);
void NGC_FT1_iterate(Tox *tox, NGC_FT1* ngc_ft1_ctx) {
//void NGC_FT1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/) {
assert(ngc_ft1_ctx);
ngc_ext_ctx->ngc_ft1_ctx->cb_recv_request[file_kind] = callback;
}
for (auto& [group_number, group] : ngc_ft1_ctx->groups) {
for (auto& [peer_number, peer] : group.peers) {
//for (auto& tf_opt : peer.send_transfers) {
for (size_t idx = 0; idx < peer.send_transfers.size(); idx++) {
auto& tf_opt = peer.send_transfers[idx];
if (tf_opt) {
auto& tf = tf_opt.value();
void NGC_FT1_register_callback_recv_init(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_init_cb* callback) {
assert(ngc_ext_ctx);
assert(ngc_ext_ctx->ngc_ft1_ctx);
tf.time_since_activity += 0.025f; // TODO: actual delta
ngc_ext_ctx->ngc_ft1_ctx->cb_recv_init[file_kind] = callback;
}
switch (tf.state) {
using State = NGC_FT1::Group::Peer::SendTransfer::State;
case State::INIT_SENT:
if (tf.time_since_activity >= 20.f) {
if (tf.inits_sent >= 3) {
// delete, timed out 3 times
fprintf(stderr, "FT: warning, ft init timed out, deleting\n");
tf_opt.reset();
continue; // dangerous control flow
} else {
// timed out, resend
fprintf(stderr, "FT: warning, ft init timed out, resending\n");
_send_pkg_FT1_INIT(tox, group_number, peer_number, tf.file_kind, tf.file_size, idx, tf.file_id.data(), tf.file_id.size());
tf.inits_sent++;
tf.time_since_activity = 0.f;
}
}
break;
case State::SENDING: {
tf.ssb.for_each(0.025f, [&](uint16_t id, const std::vector<uint8_t>& data, float& time_since_activity) {
// no ack after 5 sec -> resend
if (time_since_activity >= 5.f) {
_send_pkg_FT1_DATA(tox, group_number, peer_number, idx, id, data.data(), data.size());
time_since_activity = 0.f;
}
});
void NGC_FT1_register_callback_recv_data(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_data_cb* callback) {
assert(ngc_ext_ctx);
assert(ngc_ext_ctx->ngc_ft1_ctx);
if (tf.time_since_activity >= 30.f) {
// no ack after 30sec, close ft
// TODO: notify app
fprintf(stderr, "FT: warning, sending ft in progress timed out, deleting\n");
tf_opt.reset();
continue; // dangerous control flow
}
ngc_ext_ctx->ngc_ft1_ctx->cb_recv_data[file_kind] = callback;
}
assert(ngc_ft1_ctx->cb_send_data.count(tf.file_kind));
void NGC_FT1_register_callback_send_data(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_send_data_cb* callback) {
assert(ngc_ext_ctx);
assert(ngc_ext_ctx->ngc_ft1_ctx);
// if chunks in flight < window size (1 lol)
while (tf.ssb.size() < 1) {
std::vector<uint8_t> new_data;
ngc_ext_ctx->ngc_ft1_ctx->cb_send_data[file_kind] = callback;
}
size_t chunk_size = std::min<size_t>(10u, tf.file_size - tf.file_size_current);
if (chunk_size == 0) {
// TODO: set to finishing?
break; // we done
}
new_data.resize(chunk_size);
// iterate
ngc_ft1_ctx->cb_send_data[tf.file_kind](
tox,
group_number, peer_number,
idx,
tf.file_size_current,
new_data.data(), new_data.size(),
ngc_ft1_ctx->ud_send_data.count(tf.file_kind) ? ngc_ft1_ctx->ud_send_data.at(tf.file_kind) : nullptr
);
uint16_t seq_id = tf.ssb.add(std::move(new_data));
_send_pkg_FT1_DATA(tox, group_number, peer_number, idx, seq_id, tf.ssb.entries.at(seq_id).data.data(), tf.ssb.entries.at(seq_id).data.size());
void NGC_FT1_send_request(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
fprintf(stderr, "FT: sent data size: %ld (seq %d)\n", chunk_size, seq_id);
uint32_t group_number,
tf.file_size_current += chunk_size;
}
}
break;
case State::FINISHING:
break;
NGC_FT1_file_kind file_kind,
// finfin o.o
const uint8_t* file_id,
size_t file_id_size
) {
// just call private for every peer in group?
for (;;) {
uint32_t peer_number = 0;
NGC_FT1_send_request_private(tox, ngc_ext_ctx, group_number, peer_number, file_kind, file_id, file_id_size);
assert(false && "not implemented");
default: // invalid state, delete
fprintf(stderr, "FT: error, ft in invalid state, deleting\n");
tf_opt.reset();
continue;
}
}
}
}
}
}
void NGC_FT1_register_callback_recv_request(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_recv_request_cb* callback,
void* user_data
) {
assert(ngc_ft1_ctx);
ngc_ft1_ctx->cb_recv_request[file_kind] = callback;
ngc_ft1_ctx->ud_recv_request[file_kind] = user_data;
}
void NGC_FT1_register_callback_recv_init(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_recv_init_cb* callback,
void* user_data
) {
assert(ngc_ft1_ctx);
ngc_ft1_ctx->cb_recv_init[file_kind] = callback;
ngc_ft1_ctx->ud_recv_init[file_kind] = user_data;
}
void NGC_FT1_register_callback_recv_data(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_recv_data_cb* callback,
void* user_data
) {
assert(ngc_ft1_ctx);
ngc_ft1_ctx->cb_recv_data[file_kind] = callback;
ngc_ft1_ctx->ud_recv_data[file_kind] = user_data;
}
void NGC_FT1_register_callback_send_data(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_send_data_cb* callback,
void* user_data
) {
assert(ngc_ft1_ctx);
ngc_ft1_ctx->cb_send_data[file_kind] = callback;
ngc_ft1_ctx->ud_send_data[file_kind] = user_data;
}
void NGC_FT1_send_request_private(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox, NGC_FT1* ngc_ft1_ctx,
uint32_t group_number,
uint32_t peer_number,
@ -166,8 +383,7 @@ void NGC_FT1_send_request_private(
size_t file_id_size
) {
assert(tox);
assert(ngc_ext_ctx);
assert(ngc_ext_ctx->ngc_ft1_ctx);
assert(ngc_ft1_ctx);
// record locally that we sent(or want to send) the request?
@ -175,21 +391,22 @@ void NGC_FT1_send_request_private(
}
bool NGC_FT1_send_init_private(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox, NGC_FT1* ngc_ft1_ctx,
uint32_t group_number, uint32_t peer_number,
NGC_FT1_file_kind file_kind,
const uint8_t* file_id, size_t file_id_size,
size_t file_size
size_t file_size,
uint8_t* transfer_id
) {
//fprintf(stderr, "TODO: init ft for %08X\n", msg_id);
fprintf(stderr, "init ft\n");
fprintf(stderr, "FT: init ft\n");
if (tox_group_peer_get_connection_status(tox, group_number, peer_number, nullptr) == TOX_CONNECTION_NONE) {
fprintf(stderr, "error: cant init ft, peer offline\n");
fprintf(stderr, "FT: error: cant init ft, peer offline\n");
return false;
}
auto& peer = ngc_ext_ctx->ngc_ft1_ctx->groups[group_number].peers[peer_number];
auto& peer = ngc_ft1_ctx->groups[group_number].peers[peer_number];
// allocate transfer_id
size_t idx = peer.next_send_transfer_idx;
@ -209,7 +426,7 @@ bool NGC_FT1_send_init_private(
} while (i != idx);
if (!found) {
fprintf(stderr, "error: cant init ft, no free transfer slot\n");
fprintf(stderr, "FT: error: cant init ft, no free transfer slot\n");
return false;
}
}
@ -217,12 +434,19 @@ bool NGC_FT1_send_init_private(
_send_pkg_FT1_INIT(tox, group_number, peer_number, file_kind, file_size, idx, file_id, file_id_size);
peer.send_transfers[idx] = NGC_FT1::Group::Peer::SendTransfer{
file_kind,
std::vector(file_id, file_id+file_id_size),
NGC_FT1::Group::Peer::SendTransfer::State::INIT_SENT,
1,
0.f,
file_size,
0,
};
if (transfer_id != nullptr) {
*transfer_id = idx;
}
return true;
}
@ -231,7 +455,7 @@ static bool _send_pkg_FT1_REQUEST(const Tox* tox, uint32_t group_number, uint32_
// - 1 byte (TODO: more?) file_kind
// - X bytes file_id
std::vector<uint8_t> pkg;
pkg.push_back(FT1_REQUEST);
pkg.push_back(NGC_EXT::FT1_REQUEST);
pkg.push_back(file_kind);
for (size_t i = 0; i < file_id_size; i++) {
pkg.push_back(file_id[i]);
@ -249,7 +473,7 @@ static bool _send_pkg_FT1_INIT(const Tox* tox, uint32_t group_number, uint32_t p
// - X bytes (file_kind dependent id, differnt sizes)
std::vector<uint8_t> pkg;
pkg.push_back(FT1_INIT);
pkg.push_back(NGC_EXT::FT1_INIT);
pkg.push_back(file_kind);
for (size_t i = 0; i < sizeof(file_size); i++) {
pkg.push_back((file_size>>(i*8)) & 0xff);
@ -268,7 +492,7 @@ static bool _send_pkg_FT1_INIT_ACK(const Tox* tox, uint32_t group_number, uint32
// - 1 byte packet id
// - 1 byte transfer_id
std::vector<uint8_t> pkg;
pkg.push_back(FT1_INIT_ACK);
pkg.push_back(NGC_EXT::FT1_INIT_ACK);
pkg.push_back(transfer_id);
// lossless
@ -276,12 +500,13 @@ static bool _send_pkg_FT1_INIT_ACK(const Tox* tox, uint32_t group_number, uint32
}
static bool _send_pkg_FT1_DATA(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, uint16_t sequence_id, const uint8_t* data, size_t data_size) {
assert(data_size > 0);
// TODO
// check header_size+data_size <= max pkg size
std::vector<uint8_t> pkg;
pkg.push_back(FT1_DATA);
pkg.push_back(NGC_EXT::FT1_DATA);
pkg.push_back(transfer_id);
pkg.push_back(sequence_id & 0xff);
pkg.push_back((sequence_id >> (1*8)) & 0xff);
@ -297,7 +522,7 @@ static bool _send_pkg_FT1_DATA(const Tox* tox, uint32_t group_number, uint32_t p
static bool _send_pkg_FT1_DATA_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, const uint16_t* seq_ids, size_t seq_ids_size) {
std::vector<uint8_t> pkg;
pkg.push_back(FT1_DATA_ACK);
pkg.push_back(NGC_EXT::FT1_DATA_ACK);
pkg.push_back(transfer_id);
// TODO: optimize
@ -310,24 +535,6 @@ static bool _send_pkg_FT1_DATA_ACK(const Tox* tox, uint32_t group_number, uint32
return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}
static bool _send_pkg_FT1_DATA_FIN(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id) {
std::vector<uint8_t> pkg;
pkg.push_back(FT1_DATA_FIN);
pkg.push_back(transfer_id);
// lossless?
return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}
static bool _send_pkg_FT1_DATA_FIN_ACK(const Tox* tox, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id) {
std::vector<uint8_t> pkg;
pkg.push_back(FT1_DATA_FIN_ACK);
pkg.push_back(transfer_id);
// lossless?
return tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
}
#define _DATA_HAVE(x, error) if ((length - curser) < (x)) { error; }
static void _handle_FT1_REQUEST(
@ -338,34 +545,39 @@ static void _handle_FT1_REQUEST(
uint32_t peer_number,
const uint8_t *data,
size_t length
size_t length,
void* user_data
) {
NGC_FT1* ngc_ft1_ctx = static_cast<NGC_FT1*>(user_data);
size_t curser = 0;
// TODO: might be uint16_t or even larger
uint8_t file_kind_u8;
_DATA_HAVE(sizeof(file_kind_u8), fprintf(stderr, "packet too small, missing file_kind\n"); return)
_DATA_HAVE(sizeof(file_kind_u8), fprintf(stderr, "FT: packet too small, missing file_kind\n"); return)
file_kind_u8 = data[curser++];
auto file_kind = static_cast<NGC_FT1_file_kind>(file_kind_u8);
fprintf(stderr, "got FT request with file_kind %u [", file_kind_u8);
fprintf(stderr, "FT: got FT request with file_kind %u [", file_kind_u8);
for (size_t curser_copy = curser; curser_copy < length; curser_copy++) {
fprintf(stderr, "%02X", data[curser_copy]);
}
fprintf(stderr, "]\n");
NGC_FT1_recv_request_cb* fn_ptr = nullptr;
if (ngc_ext_ctx->ngc_ft1_ctx->cb_recv_request.count(file_kind)) {
fn_ptr = ngc_ext_ctx->ngc_ft1_ctx->cb_recv_request.at(file_kind);
if (ngc_ft1_ctx->cb_recv_request.count(file_kind)) {
fn_ptr = ngc_ft1_ctx->cb_recv_request.at(file_kind);
}
void* ud_ptr = nullptr;
if (ngc_ft1_ctx->ud_recv_request.count(file_kind)) {
ud_ptr = ngc_ft1_ctx->ud_recv_request.at(file_kind);
}
if (fn_ptr) {
fn_ptr(tox, ngc_ext_ctx, group_number, peer_number, data+curser, length-curser);
fn_ptr(tox, group_number, peer_number, data+curser, length-curser, ud_ptr);
} else {
fprintf(stderr, "missing cb for requests\n");
fprintf(stderr, "FT: missing cb for requests\n");
}
}
static void _handle_FT1_INIT(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
@ -374,33 +586,36 @@ static void _handle_FT1_INIT(
uint32_t peer_number,
const uint8_t *data,
size_t length
size_t length,
void* user_data
) {
NGC_FT1* ngc_ft1_ctx = static_cast<NGC_FT1*>(user_data);
size_t curser = 0;
// - 1 byte (file_kind)
// TODO: might be uint16_t or even larger
uint8_t file_kind_u8;
_DATA_HAVE(sizeof(file_kind_u8), fprintf(stderr, "packet too small, missing file_kind\n"); return)
_DATA_HAVE(sizeof(file_kind_u8), fprintf(stderr, "FT: packet too small, missing file_kind\n"); return)
file_kind_u8 = data[curser++];
auto file_kind = static_cast<NGC_FT1_file_kind>(file_kind_u8);
// - 8 bytes (data size)
size_t file_size {0u};
_DATA_HAVE(sizeof(file_size), fprintf(stderr, "packet too small, missing file_size\n"); return)
_DATA_HAVE(sizeof(file_size), fprintf(stderr, "FT: packet too small, missing file_size\n"); return)
for (size_t i = 0; i < sizeof(file_size); i++, curser++) {
file_size |= size_t(data[curser]) << (i*8);
}
// - 1 byte (temporary_file_tf_id, for this peer only, technically just a prefix to distinguish between simultainious fts)
uint8_t transfer_id;
_DATA_HAVE(sizeof(transfer_id), fprintf(stderr, "packet too small, missing transfer_id\n"); return)
_DATA_HAVE(sizeof(transfer_id), fprintf(stderr, "FT: packet too small, missing transfer_id\n"); return)
transfer_id = data[curser++];
// - X bytes (file_kind dependent id, differnt sizes)
fprintf(stderr, "got FT init with file_kind:%u file_size:%lu tf_id:%u [", file_kind_u8, file_size, transfer_id);
const std::vector file_id(data+curser, data+curser+(length-curser));
fprintf(stderr, "FT: got FT init with file_kind:%u file_size:%lu tf_id:%u [", file_kind_u8, file_size, transfer_id);
for (size_t curser_copy = curser; curser_copy < length; curser_copy++) {
fprintf(stderr, "%02X", data[curser_copy]);
}
@ -410,24 +625,222 @@ static void _handle_FT1_INIT(
// did we allready ack this and the other side just did not see the ack?
NGC_FT1_recv_init_cb* fn_ptr = nullptr;
if (ngc_ext_ctx->ngc_ft1_ctx->cb_recv_init.count(file_kind)) {
fn_ptr = ngc_ext_ctx->ngc_ft1_ctx->cb_recv_init.at(file_kind);
if (ngc_ft1_ctx->cb_recv_init.count(file_kind)) {
fn_ptr = ngc_ft1_ctx->cb_recv_init.at(file_kind);
}
void* ud_ptr = nullptr;
if (ngc_ft1_ctx->ud_recv_init.count(file_kind)) {
ud_ptr = ngc_ft1_ctx->ud_recv_init.at(file_kind);
}
bool accept_ft;
if (fn_ptr) {
// last part of message (file_id) is not yet parsed, just give it to cb
accept_ft = fn_ptr(tox, ngc_ext_ctx, group_number, peer_number, data+curser, length-curser, transfer_id, file_size);
accept_ft = fn_ptr(tox, group_number, peer_number, data+curser, length-curser, transfer_id, file_size, ud_ptr);
} else {
fprintf(stderr, "missing cb for init\n");
fprintf(stderr, "FT: missing cb for init\n");
accept_ft = false;
}
if (accept_ft) {
_send_pkg_FT1_INIT_ACK(tox, group_number, peer_number, transfer_id);
fprintf(stderr, "accepted init\n");
fprintf(stderr, "FT: accepted init\n");
auto& peer = ngc_ft1_ctx->groups[group_number].peers[peer_number];
if (peer.recv_transfers[transfer_id].has_value()) {
fprintf(stderr, "FT: overwriting existing recv_transfer %d\n", transfer_id);
}
peer.recv_transfers[transfer_id] = NGC_FT1::Group::Peer::RecvTransfer{
file_kind,
file_id,
NGC_FT1::Group::Peer::RecvTransfer::State::INITED,
file_size,
0u,
};
} else {
// TODO deny?
fprintf(stderr, "rejected init\n");
fprintf(stderr, "FT: rejected init\n");
}
}
static void _handle_FT1_INIT_ACK(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
const uint8_t *data,
size_t length,
void* user_data
) {
NGC_FT1* ngc_ft1_ctx = static_cast<NGC_FT1*>(user_data);
size_t curser = 0;
// - 1 byte (transfer_id)
uint8_t transfer_id;
_DATA_HAVE(sizeof(transfer_id), fprintf(stderr, "FT: packet too small, missing transfer_id\n"); return)
transfer_id = data[curser++];
// we now should start sending data
auto& groups = ngc_ft1_ctx->groups;
if (!groups.count(group_number)) {
fprintf(stderr, "FT: init_ack for unknown group\n");
return;
}
NGC_FT1::Group::Peer& peer = groups[group_number].peers[peer_number];
if (!peer.send_transfers[transfer_id].has_value()) {
fprintf(stderr, "FT: inti_ack for unknown transfer\n");
return;
}
NGC_FT1::Group::Peer::SendTransfer& transfer = peer.send_transfers[transfer_id].value();
using State = NGC_FT1::Group::Peer::SendTransfer::State;
if (transfer.state != State::INIT_SENT) {
fprintf(stderr, "FT: inti_ack but not in INIT_SENT state\n");
return;
}
// iterate will now call NGC_FT1_send_data_cb
transfer.state = State::SENDING;
transfer.time_since_activity = 0.f;
}
static void _handle_FT1_DATA(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
const uint8_t *data, size_t length,
void* user_data
) {
NGC_FT1* ngc_ft1_ctx = static_cast<NGC_FT1*>(user_data);
size_t curser = 0;
// - 1 byte (transfer_id)
uint8_t transfer_id;
_DATA_HAVE(sizeof(transfer_id), fprintf(stderr, "FT: packet too small, missing transfer_id\n"); return)
transfer_id = data[curser++];
// - 2 bytes (sequence_id)
uint16_t sequence_id;
_DATA_HAVE(sizeof(sequence_id), fprintf(stderr, "FT: packet too small, missing sequence_id\n"); return)
sequence_id = data[curser++];
sequence_id |= data[curser++] << (1*8);
if (curser == length) {
fprintf(stderr, "FT: data of size 0!\n");
return;
}
auto& groups = ngc_ft1_ctx->groups;
if (!groups.count(group_number)) {
fprintf(stderr, "FT: data for unknown group\n");
return;
}
NGC_FT1::Group::Peer& peer = groups[group_number].peers[peer_number];
if (!peer.recv_transfers[transfer_id].has_value()) {
fprintf(stderr, "FT: data for unknown transfer\n");
return;
}
auto& transfer = peer.recv_transfers[transfer_id].value();
// do reassembly, ignore dups
transfer.rsb.add(sequence_id, std::vector<uint8_t>(data+curser, data+curser+(length-curser)));
NGC_FT1_recv_data_cb* fn_ptr = nullptr;
if (ngc_ft1_ctx->cb_recv_data.count(transfer.file_kind)) {
fn_ptr = ngc_ft1_ctx->cb_recv_data.at(transfer.file_kind);
}
void* ud_ptr = nullptr;
if (ngc_ft1_ctx->ud_recv_data.count(transfer.file_kind)) {
ud_ptr = ngc_ft1_ctx->ud_recv_data.at(transfer.file_kind);
}
if (!fn_ptr) {
fprintf(stderr, "FT: missing cb for recv_data\n");
return;
}
// loop for chunks without holes
while (transfer.rsb.canPop()) {
auto data = transfer.rsb.pop();
fn_ptr(tox, group_number, peer_number, transfer_id, transfer.file_size_current, data.data(), data.size(), ud_ptr);
transfer.file_size_current += data.size();
}
// send acks
std::vector<uint16_t> ack_seq_ids(transfer.rsb.ack_seq_ids.cbegin(), transfer.rsb.ack_seq_ids.cend());
if (!ack_seq_ids.empty()) {
_send_pkg_FT1_DATA_ACK(tox, group_number, peer_number, transfer_id, ack_seq_ids.data(), ack_seq_ids.size());
}
}
static void _handle_FT1_DATA_ACK(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
const uint8_t *data,
size_t length,
void* user_data
) {
NGC_FT1* ngc_ft1_ctx = static_cast<NGC_FT1*>(user_data);
size_t curser = 0;
// - 1 byte (transfer_id)
uint8_t transfer_id;
_DATA_HAVE(sizeof(transfer_id), fprintf(stderr, "FT: packet too small, missing transfer_id\n"); return)
transfer_id = data[curser++];
auto& groups = ngc_ft1_ctx->groups;
if (!groups.count(group_number)) {
fprintf(stderr, "FT: data_ack for unknown group\n");
return;
}
NGC_FT1::Group::Peer& peer = groups[group_number].peers[peer_number];
if (!peer.send_transfers[transfer_id].has_value()) {
fprintf(stderr, "FT: data_ack for unknown transfer\n");
return;
}
NGC_FT1::Group::Peer::SendTransfer& transfer = peer.send_transfers[transfer_id].value();
using State = NGC_FT1::Group::Peer::SendTransfer::State;
if (transfer.state != State::SENDING) {
fprintf(stderr, "FT: data_ack but not in SENDING state\n");
return;
}
_DATA_HAVE(sizeof(uint16_t), fprintf(stderr, "FT: packet too small, atleast 1 seq_id\n"); return)
if ((length - curser) % sizeof(uint16_t) != 0) {
fprintf(stderr, "FT: data_ack with misaligned data\n");
return;
}
while (curser < length) {
uint16_t seq_id = data[curser++];
seq_id |= data[curser++] << (1*8);
transfer.ssb.erase(seq_id);
}
if (transfer.file_size == transfer.file_size_current) {
fprintf(stderr, "FT: %d done\n", transfer_id);
peer.send_transfers[transfer_id] = std::nullopt;
}
}

109
ngc_ft1.h
View File

@ -5,7 +5,7 @@
#include <tox/tox.h>
#include "ngc_ext_common.h"
#include "ngc_ext.h"
#ifdef __cplusplus
extern "C" {
@ -37,80 +37,123 @@ typedef enum NGC_FT1_file_kind /*: uint8_t*/ {
// id: infohash
TORRENT_V1_METAINFO = 8u,
// id: sha1
TORRENT_V1_CHUNK,
TORRENT_V1_CHUNK, // alias with SHA1_CHUNK?
// id: infohash
TORRENT_V2_METAINFO,
TORRENT_V2_METAINFO, // meta info is kind of more complicated than that <.<
// id: sha256
TORRENT_V2_CHUNK,
} NGC_FT1_file_kind;
// ========== init / kill ==========
// (see tox api)
bool NGC_FT1_init(NGC_EXT_CTX* ngc_ext_ctx, const struct NGC_FT1_options* options);
void NGC_FT1_kill(NGC_EXT_CTX* ngc_ext_ctx);
NGC_FT1* NGC_FT1_new(const struct NGC_FT1_options* options);
bool NGC_FT1_register_ext(NGC_FT1* ngc_ft1_ctx, NGC_EXT_CTX* ngc_ext_ctx);
//bool NGC_FT1_init(NGC_EXT_CTX* ngc_ext_ctx, const struct NGC_FT1_options* options);
void NGC_FT1_kill(NGC_FT1* ngc_ft1_ctx);
//void NGC_FT1_kill(NGC_EXT_CTX* ngc_ext_ctx);
// ========== iterate ==========
void NGC_FT1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/);
void NGC_FT1_iterate(Tox *tox, NGC_FT1* ngc_ft1_ctx);
//void NGC_FT1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/);
// TODO: announce
// ========== request ==========
// TODO: remove?
void NGC_FT1_request(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
NGC_FT1_file_kind file_kind,
const uint8_t* file_id, size_t file_id_size
);
// TODO: public variant?
void NGC_FT1_send_request_private(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox, NGC_FT1* ngc_ft1_ctx,
uint32_t group_number, uint32_t peer_number,
NGC_FT1_file_kind file_kind,
const uint8_t* file_id, size_t file_id_size
);
typedef void NGC_FT1_recv_request_cb(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t* file_id, size_t file_id_size);
typedef void NGC_FT1_recv_request_cb(
Tox *tox,
uint32_t group_number, uint32_t peer_number,
const uint8_t* file_id, size_t file_id_size,
void* user_data
);
void NGC_FT1_register_callback_recv_request(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_request_cb* callback);
void NGC_FT1_register_callback_recv_request(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_recv_request_cb* callback,
void* user_data
);
// ========== send/accept ==========
// public does not make sense here
bool NGC_FT1_send_init_private(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox, NGC_FT1* ngc_ft1_ctx,
uint32_t group_number, uint32_t peer_number,
NGC_FT1_file_kind file_kind,
const uint8_t* file_id, size_t file_id_size,
size_t file_size
size_t file_size,
uint8_t* transfer_id
);
// return true to accept, false to deny
typedef bool NGC_FT1_recv_init_cb(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, const uint8_t* file_id, size_t file_id_size, const uint8_t transfer_id, const size_t file_size);
typedef bool NGC_FT1_recv_init_cb(
Tox *tox,
uint32_t group_number, uint32_t peer_number,
const uint8_t* file_id, size_t file_id_size,
const uint8_t transfer_id,
const size_t file_size,
void* user_data
);
void NGC_FT1_register_callback_recv_init(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_init_cb* callback);
void NGC_FT1_register_callback_recv_init(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_recv_init_cb* callback,
void* user_data
);
// ========== data ==========
typedef void NGC_FT1_recv_data_cb(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, size_t data_offset, const uint8_t* data, size_t data_size);
typedef void NGC_FT1_recv_data_cb(
Tox *tox,
void NGC_FT1_register_callback_recv_data(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_recv_data_cb* callback);
uint32_t group_number,
uint32_t peer_number,
uint8_t transfer_id,
typedef void NGC_FT1_send_data_cb(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, uint8_t transfer_id, size_t data_offset, uint8_t** data, size_t* data_size);
size_t data_offset, const uint8_t* data, size_t data_size,
void* user_data
);
void NGC_FT1_register_callback_send_data(NGC_EXT_CTX* ngc_ext_ctx, NGC_FT1_file_kind file_kind, NGC_FT1_send_data_cb* callback);
void NGC_FT1_register_callback_recv_data(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_recv_data_cb* callback,
void* user_data
);
// request to fill data_size bytes into data
typedef void NGC_FT1_send_data_cb(
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
uint8_t transfer_id,
size_t data_offset, uint8_t* data, size_t data_size,
void* user_data
);
void NGC_FT1_register_callback_send_data(
NGC_FT1* ngc_ft1_ctx,
NGC_FT1_file_kind file_kind,
NGC_FT1_send_data_cb* callback,
void* user_data
);
// ========== peer online/offline ==========
//void NGC_FT1_peer_online(Tox* tox, NGC_FT1* ngc_hs1_ctx, uint32_t group_number, uint32_t peer_number, bool online);
// "callback"
void NGC_FT1_handle_group_custom_packet(
Tox* tox, NGC_FT1* ngc_hs1_ctx,
uint32_t group_number, uint32_t peer_number,
const uint8_t *data, size_t length
//void *user_data
);
#ifdef __cplusplus
}
#endif

360
ngc_hs1.cpp
View File

@ -1,6 +1,5 @@
#include "./ngc_hs1.hpp"
#include "ngc_ext_common.hpp"
#include "ngc_ft1.h"
#include <cstdint>
@ -26,7 +25,7 @@ void NGC_HS1::Peer::append(uint32_t msg_id, Tox_Message_Type type, const std::st
heard_of.erase(msg_id);
}
fprintf(stderr, "######## last msgs ########\n");
fprintf(stderr, "HS: ######## last msgs ########\n");
auto rit = order.crbegin();
for (size_t i = 0; i < 10 && rit != order.crend(); i++, rit++) {
fprintf(stderr, " %08X - %s\n", *rit, dict.at(*rit).text.c_str());
@ -49,84 +48,86 @@ bool NGC_HS1::Peer::hear(uint32_t msg_id, uint32_t peer_number) {
return true;
}
void _handle_HS1_REQUEST_LAST_IDS(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
const uint8_t *data,
size_t length
);
void _handle_HS1_RESPONSE_LAST_IDS(
Tox* tox,
NGC_EXT_CTX* ngc_ext_ctx,
uint32_t group_number,
uint32_t peer_number,
const uint8_t *data,
size_t length
);
void _handle_HS1_ft_recv_request(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
const uint8_t* file_id, size_t file_id_size
const uint8_t* file_id, size_t file_id_size,
void* user_data
);
bool _handle_HS1_ft_recv_init(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
const uint8_t* file_id, size_t file_id_size,
const uint8_t transfer_id,
const size_t file_size
const size_t file_size,
void* user_data
);
void _handle_HS1_ft_recv_data(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
uint8_t transfer_id,
size_t data_offset,
const uint8_t* data, size_t data_size
const uint8_t* data, size_t data_size,
void* user_data
);
bool NGC_HS1_init(NGC_EXT_CTX* ngc_ext_ctx, const struct NGC_HS1_options* options) {
ngc_ext_ctx->ngc_hs1_ctx = new NGC_HS1;
ngc_ext_ctx->ngc_hs1_ctx->options = *options;
void _handle_HS1_ft_send_data(
Tox *tox,
ngc_ext_ctx->callbacks[HS1_REQUEST_LAST_IDS] = _handle_HS1_REQUEST_LAST_IDS;
ngc_ext_ctx->callbacks[HS1_RESPONSE_LAST_IDS] = _handle_HS1_RESPONSE_LAST_IDS;
uint32_t group_number,
uint32_t peer_number,
uint8_t transfer_id,
NGC_FT1_register_callback_recv_request(ngc_ext_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_recv_request);
NGC_FT1_register_callback_recv_init(ngc_ext_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_recv_init);
NGC_FT1_register_callback_recv_data(ngc_ext_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_recv_data);
//NGC_FT1_register_callback_send_data(ngc_ext_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_init_message);
size_t data_offset, uint8_t* data, size_t data_size,
void* user_data
);
NGC_HS1* NGC_HS1_new(const struct NGC_HS1_options* options) {
auto* ngc_hs1_ctx = new NGC_HS1;
ngc_hs1_ctx->options = *options;
return ngc_hs1_ctx;
}
bool NGC_HS1_register_ext(NGC_HS1* ngc_hs1_ctx, NGC_EXT_CTX* ngc_ext_ctx) {
ngc_ext_ctx->callbacks[NGC_EXT::HS1_REQUEST_LAST_IDS] = _handle_HS1_REQUEST_LAST_IDS;
ngc_ext_ctx->callbacks[NGC_EXT::HS1_RESPONSE_LAST_IDS] = _handle_HS1_RESPONSE_LAST_IDS;
ngc_ext_ctx->user_data[NGC_EXT::HS1_REQUEST_LAST_IDS] = ngc_hs1_ctx;
ngc_ext_ctx->user_data[NGC_EXT::HS1_RESPONSE_LAST_IDS] = ngc_hs1_ctx;
return true;
}
void NGC_HS1_kill(NGC_EXT_CTX* ngc_ext_ctx) {
delete ngc_ext_ctx->ngc_hs1_ctx;
ngc_ext_ctx->ngc_hs1_ctx = nullptr;
bool NGC_HS1_register_ft1(NGC_HS1* ngc_hs1_ctx, NGC_FT1* ngc_ft1_ctx) {
ngc_hs1_ctx->ngc_ft1_ctx = ngc_ft1_ctx;
NGC_FT1_register_callback_recv_request(ngc_ft1_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_recv_request, ngc_hs1_ctx);
NGC_FT1_register_callback_recv_init(ngc_ft1_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_recv_init, ngc_hs1_ctx);
NGC_FT1_register_callback_recv_data(ngc_ft1_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_recv_data, ngc_hs1_ctx);
NGC_FT1_register_callback_send_data(ngc_ft1_ctx, NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID, _handle_HS1_ft_send_data, ngc_hs1_ctx);
return true;
}
static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, float time_delta) {
NGC_HS1* ngc_hs1_ctx = ngc_ext_ctx->ngc_hs1_ctx;
void NGC_HS1_kill(NGC_HS1* ngc_hs1_ctx) {
delete ngc_hs1_ctx;
}
static void _iterate_group(Tox *tox, NGC_HS1* ngc_hs1_ctx, uint32_t group_number, float time_delta) {
//fprintf(stderr, "g:%u\n", g_i);
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
if (ngc_hs1_ctx->history.count(g_id) == 0) {
fprintf(stderr, "adding new group: %u %X%X%X%X\n",
fprintf(stderr, "HS: adding new group: %u %X%X%X%X\n",
group_number,
g_id.data.data()[0],
g_id.data.data()[1],
@ -137,6 +138,18 @@ static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_nu
} else {
auto& group = ngc_hs1_ctx->history[g_id];
// check if transfers have timed out
for (auto it = group.transfers.begin(); it != group.transfers.end();) {
it->second.time_since_ft_activity += time_delta;
if (it->second.time_since_ft_activity >= ngc_hs1_ctx->options.ft_activity_timeout) {
// timed out
fprintf(stderr, "HS: !!! ft timed out (%08X)\n", it->first.first);
it = group.transfers.erase(it);
} else {
it++;
}
}
// for each peer
for (auto& [peer_key, peer] : group.peers) {
//fprintf(stderr, " p: %X%X%X%X\n", key.data.data()[0], key.data.data()[1], key.data.data()[2], key.data.data()[3]);
@ -144,7 +157,7 @@ static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_nu
if (peer.time_since_last_request_sent > ngc_hs1_ctx->options.query_interval_per_peer) {
peer.time_since_last_request_sent = 0.f;
fprintf(stderr, "requesting ids for %X%X%X%X\n", peer_key.data.data()[0], peer_key.data.data()[1], peer_key.data.data()[2], peer_key.data.data()[3]);
//fprintf(stderr, "HS: requesting ids for %X%X%X%X\n", peer_key.data.data()[0], peer_key.data.data()[1], peer_key.data.data()[2], peer_key.data.data()[3]);
// TODO: other way around?
// ask everyone if they have newer stuff for this peer
@ -153,7 +166,7 @@ static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_nu
// - peer_key bytes (peer key we want to know ids for)
// - 1 byte (uint8_t count ids, atleast 1)
std::array<uint8_t, 1+TOX_GROUP_PEER_PUBLIC_KEY_SIZE+1> pkg;
pkg[0] = HS1_REQUEST_LAST_IDS;
pkg[0] = NGC_EXT::HS1_REQUEST_LAST_IDS;
std::copy(peer_key.data.begin(), peer_key.data.end(), pkg.begin()+1);
pkg[1+TOX_GROUP_PEER_PUBLIC_KEY_SIZE] = ngc_hs1_ctx->options.last_msg_ids_count; // request last (up to) 5 msg_ids
@ -165,7 +178,7 @@ static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_nu
it->second.time_since_ft_activity += time_delta;
if (it->second.time_since_ft_activity >= ngc_hs1_ctx->options.ft_activity_timeout) {
// timed out
fprintf(stderr, "!!! pending ft request timed out (%08X)\n", it->first);
fprintf(stderr, "HS: !!! pending ft request timed out (%08X)\n", it->first);
it = peer.pending.erase(it);
} else {
it++;
@ -185,7 +198,7 @@ static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_nu
}
if (remote_peer_numbers.empty()) {
fprintf(stderr, "!!! msg_id we heard of, but no remote peer !!!\n");
fprintf(stderr, "HS: !!! msg_id we heard of, but no remote peer !!!\n");
continue;
}
@ -203,7 +216,7 @@ static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_nu
// send request
NGC_FT1_send_request_private(
tox, ngc_ext_ctx,
tox, ngc_hs1_ctx->ngc_ft1_ctx,
group_number, remote_peer_number,
NGC_FT1_file_kind::NGC_HS1_MESSAGE_BY_ID,
file_id.data(), file_id.size()
@ -220,9 +233,9 @@ static void _iterate_group(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_nu
assert(ngc_hs1_ctx->history.count(g_id));
}
void NGC_HS1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/) {
assert(ngc_ext_ctx);
assert(ngc_ext_ctx->ngc_hs1_ctx);
void NGC_HS1_iterate(Tox *tox, NGC_HS1* ngc_hs1_ctx) {
//void NGC_HS1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/) {
assert(ngc_hs1_ctx);
//fprintf(stderr, "groups: %u\n", ngc_hs1_ctx->history.size());
@ -233,7 +246,7 @@ void NGC_HS1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/) {
if (tox_group_is_connected(tox, g_i, &g_err)) {
// valid and connected here
// TODO: delta time, or other timers
_iterate_group(tox, ngc_ext_ctx, g_i, 0.02f);
_iterate_group(tox, ngc_hs1_ctx, g_i, 0.02f);
g_c_done++;
} else if (g_err != TOX_ERR_GROUP_IS_CONNECTED_GROUP_NOT_FOUND) {
g_c_done++;
@ -241,16 +254,15 @@ void NGC_HS1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/) {
// safety
if (g_i > group_count + 1000) {
fprintf(stderr, "WAY PAST GOUPS in iterate\n");
fprintf(stderr, "HS: WAY PAST GOUPS in iterate\n");
break;
}
}
}
void NGC_HS1_peer_online(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, bool online) {
NGC_HS1* ngc_hs1_ctx = ngc_ext_ctx->ngc_hs1_ctx;
void NGC_HS1_peer_online(Tox* tox, NGC_HS1* ngc_hs1_ctx, uint32_t group_number, uint32_t peer_number, bool online) {
// get group id
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
@ -259,7 +271,7 @@ void NGC_HS1_peer_online(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_numb
if (online) {
// get peer id
_PeerKey p_id{};
NGC_EXT::PeerKey p_id{};
{ // TODO: error
tox_group_peer_get_public_key(tox, group_number, peer_number, p_id.data.data(), nullptr);
}
@ -279,7 +291,7 @@ void NGC_HS1_peer_online(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_numb
bool NGC_HS1_shim_group_send_message(
const Tox *tox,
NGC_EXT_CTX* ngc_ext_ctx,
NGC_HS1* ngc_hs1_ctx,
uint32_t group_number,
@ -296,31 +308,29 @@ bool NGC_HS1_shim_group_send_message(
bool ret = tox_group_send_message(tox, group_number, type, message, length, msg_id_ptr, error);
NGC_HS1_record_own_message(tox, ngc_ext_ctx, group_number, type, message, length, *msg_id_ptr);
NGC_HS1_record_own_message(tox, ngc_hs1_ctx, group_number, type, message, length, *msg_id_ptr);
return ret;
}
// record own msg
void NGC_HS1_record_own_message(
const Tox *tox,
NGC_EXT_CTX* ngc_ext_ctx,
NGC_HS1* ngc_hs1_ctx,
uint32_t group_number,
Tox_Message_Type type, const uint8_t *message, size_t length, uint32_t message_id
) {
NGC_HS1* ngc_hs1_ctx = ngc_ext_ctx->ngc_hs1_ctx;
fprintf(stderr, "record_own_message %08X\n", message_id);
fprintf(stderr, "HS: record_own_message %08X\n", message_id);
// get group id
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
// get peer id
_PeerKey p_id{};
NGC_EXT::PeerKey p_id{};
{ // TODO: error
tox_group_self_get_public_key(tox, group_number, p_id.data.data(), nullptr);
}
@ -330,30 +340,35 @@ void NGC_HS1_record_own_message(
assert(ngc_hs1_ctx->history.count(g_id));
}
void NGC_HS1_register_callback_group_message(NGC_HS1* ngc_hs1_ctx, NGC_HS1_group_message_cb* callback) {
assert(ngc_hs1_ctx);
ngc_hs1_ctx->cb_group_message = callback;
}
// record others msg
void NGC_HS1_record_message(
const Tox *tox,
NGC_EXT_CTX* ngc_ext_ctx,
NGC_HS1* ngc_hs1_ctx,
uint32_t group_number,
uint32_t peer_number,
Tox_Message_Type type, const uint8_t *message, size_t length, uint32_t message_id
) {
NGC_HS1* ngc_hs1_ctx = ngc_ext_ctx->ngc_hs1_ctx;
if (!ngc_hs1_ctx->options.record_others) {
return;
}
fprintf(stderr, "record_message %08X\n", message_id);
fprintf(stderr, "HS: record_message %08X\n", message_id);
// get group id
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
// get peer id
_PeerKey p_id{};
NGC_EXT::PeerKey p_id{};
{ // TODO: error
tox_group_peer_get_public_key(tox, group_number, peer_number, p_id.data.data(), nullptr);
}
@ -362,15 +377,18 @@ void NGC_HS1_record_message(
}
void _handle_HS1_ft_recv_request(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
const uint8_t* file_id, size_t file_id_size
const uint8_t* file_id, size_t file_id_size,
void* user_data
) {
assert(user_data);
NGC_HS1* ngc_hs1_ctx = static_cast<NGC_HS1*>(user_data);
assert(file_id_size == TOX_GROUP_PEER_PUBLIC_KEY_SIZE+sizeof(uint32_t));
// get peer_key from file_id
_PeerKey peer_key;
NGC_EXT::PeerKey peer_key;
std::copy(file_id, file_id+peer_key.size(), peer_key.data.begin());
// get msg_id from file_id
@ -379,26 +397,26 @@ void _handle_HS1_ft_recv_request(
uint8_t* tmp_ptr = reinterpret_cast<uint8_t*>(&msg_id);
std::copy(file_id+TOX_GROUP_PEER_PUBLIC_KEY_SIZE, file_id+TOX_GROUP_PEER_PUBLIC_KEY_SIZE+sizeof(uint32_t), tmp_ptr);
fprintf(stderr, "got a ft request for xxx msg_id %08X\n", msg_id);
fprintf(stderr, "HS: got a ft request for xxx msg_id %08X\n", msg_id);
// get group id
_GroupKey group_id{};
NGC_EXT::GroupKey group_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, group_id.data.data(), nullptr);
}
const auto& peers = ngc_ext_ctx->ngc_hs1_ctx->history[group_id].peers;
const auto& peers = ngc_hs1_ctx->history[group_id].peers;
// do we have that message
if (!peers.count(peer_key)) {
fprintf(stderr, "got ft request for unknown peer\n");
fprintf(stderr, "HS: got ft request for unknown peer\n");
return;
}
const auto& peer = peers.at(peer_key);
if (!peer.dict.count(msg_id)) {
fprintf(stderr, "got ft request for unknown message_id %08X\n", msg_id);
fprintf(stderr, "HS: got ft request for unknown message_id %08X\n", msg_id);
return;
}
@ -413,31 +431,41 @@ void _handle_HS1_ft_recv_request(
const auto& msg = peer.dict.at(msg_id);
size_t file_size = 1 + msg.text.size();
uint8_t transfer_id {0};
NGC_FT1_send_init_private(
tox, ngc_ext_ctx,
tox, ngc_hs1_ctx->ngc_ft1_ctx,
group_number, peer_number,
NGC_HS1_MESSAGE_BY_ID,
file_id, file_id_size,
file_size
file_size,
&transfer_id
);
//TODO: can fail
ngc_hs1_ctx->history[group_id].sending[std::make_pair(peer_number, transfer_id)] = {peer_key, msg_id};
}
bool _handle_HS1_ft_recv_init(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
const uint8_t* file_id, size_t file_id_size,
const uint8_t transfer_id,
const size_t file_size
const size_t file_size,
void* user_data
) {
fprintf(stderr, "-------hs handle ft init\n");
assert(user_data);
NGC_HS1* ngc_hs1_ctx = static_cast<NGC_HS1*>(user_data);
//fprintf(stderr, "HS: -------hs handle ft init\n");
// peer id and msg id from file id
// TODO: replace, remote crash
assert(file_id_size == TOX_GROUP_PEER_PUBLIC_KEY_SIZE+sizeof(uint32_t));
// get peer_key from file_id
_PeerKey peer_key;
NGC_EXT::PeerKey peer_key;
std::copy(file_id, file_id+peer_key.size(), peer_key.data.begin());
// get msg_id from file_id
@ -449,68 +477,162 @@ bool _handle_HS1_ft_recv_init(
// did we ask for this?
// get group id
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
auto& group = ngc_ext_ctx->ngc_hs1_ctx->history[g_id];
auto& group = ngc_hs1_ctx->history[g_id];
auto& pending = group.peers[peer_key].pending;
if (!pending.count(msg_id)) {
// we did not ask for this
// TODO: accept?
fprintf(stderr, "ft init from peer we did not ask\n");
fprintf(stderr, "HS: ft init from peer we did not ask\n");
return false; // deny
}
if (pending.at(msg_id).peer_number != peer_number) {
// wrong peer ?
fprintf(stderr, "ft init from peer we did not ask while asking someone else\n");
fprintf(stderr, "HS: ft init from peer we did not ask while asking someone else\n");
return false; // deny
}
// TODO: if allready acked but got init again, they did not get the ack
// TODO: more?
// move from pending to transfers
group.transfers[std::make_pair(peer_number, transfer_id)] = {
peer_key,
msg_id,
0.f,
{}, // empty buffer
file_size,
};
pending.at(msg_id).time_since_ft_activity = 0.f;
//pending.at(msg_id).transfer_acked;
group.transfers
// TODO: keep the pending until later?
//pending.erase(msg_id);
return true; // accept
}
void _handle_HS1_ft_recv_data(
Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
uint8_t transfer_id,
size_t data_offset,
const uint8_t* data, size_t data_size
const uint8_t* data, size_t data_size,
void* user_data
) {
assert(user_data);
NGC_HS1* ngc_hs1_ctx = static_cast<NGC_HS1*>(user_data);
// get group id
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
auto& group = ngc_ext_ctx->ngc_hs1_ctx->history[g_id];
auto& group = ngc_hs1_ctx->history[g_id];
//auto& pending = group.peers[peer_key].pending;
// get based on transfer_id
if (!group.transfers.count(std::make_pair(peer_number, transfer_id))) {
if (data_offset != 0) {
fprintf(stderr, "!! got stray tf data from %d tid:%d\n", peer_number, transfer_id);
fprintf(stderr, "HS: !! got stray tf data from %d tid:%d\n", peer_number, transfer_id);
return;
}
// new transfer?
fprintf(stderr, "!! got transfer from %d tid:%d\n", peer_number, transfer_id);
fprintf(stderr, "HS: !! got new transfer from %d tid:%d\n", peer_number, transfer_id);
}
fprintf(stderr, "HS: recv_data from %d tid:%d\n", peer_number, transfer_id);
auto& transfer = group.transfers.at(std::make_pair(peer_number, transfer_id));
transfer.time_since_ft_activity = 0.f;
// TODO: also timer for pending?
// TODO: optimize
for (size_t i = 0; i < data_size; i++) {
transfer.recv_buffer.push_back(data[i]);
}
// add data to tmp buffer
// TODO: data done?
if (data_offset + data_size == transfer.file_size) {
fprintf(stderr, "HS: transfer done %d:%d\n", peer_number, transfer_id);
transfer.recv_buffer.push_back('\0');
fprintf(stderr, " message was %s\n", transfer.recv_buffer.data()+1);
auto& peer = group.peers[transfer.msg_peer];
peer.pending.erase(transfer.msg_id);
peer.append(transfer.msg_id, static_cast<Tox_Message_Type>(transfer.recv_buffer.front()), std::string(reinterpret_cast<const char*>(transfer.recv_buffer.data()+1)));
assert(ngc_hs1_ctx->cb_group_message);
// we dont notify if we dont know the peer id. this kinda breaks some stuff
if (peer.id.has_value()) {
ngc_hs1_ctx->cb_group_message(
tox,
group_number, peer.id.value(),
static_cast<Tox_Message_Type>(transfer.recv_buffer.front()),
transfer.recv_buffer.data()+1,
transfer.recv_buffer.size()-2,
transfer.msg_id
);
}
group.transfers.erase(std::make_pair(peer_number, transfer_id));
}
}
void _handle_HS1_ft_send_data(
Tox *tox,
uint32_t group_number,
uint32_t peer_number,
uint8_t transfer_id,
size_t data_offset, uint8_t* data, size_t data_size,
void* user_data
) {
assert(user_data);
NGC_HS1* ngc_hs1_ctx = static_cast<NGC_HS1*>(user_data);
// get group id
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
auto& group = ngc_hs1_ctx->history[g_id];
if (!group.sending.count(std::make_pair(peer_number, transfer_id))) {
fprintf(stderr, "HS: error, unknown sending transfer %d:%d\n", peer_number, transfer_id);
return;
}
// map peer_number and transfer_id to peer_key and message_id
const auto& [msg_peer, msg_id] = group.sending.at(std::make_pair(peer_number, transfer_id));
// get msg
const auto& message = group.peers.at(msg_peer).dict.at(msg_id);
size_t data_i = 0;
if (data_offset == 0) {
// serl type
data[data_i++] = message.type;
data_offset += 1;
}
for (size_t i = 0; data_i < data_size; i++, data_i++) {
data[data_i] = message.text.at(data_offset+i-1);
}
if (data_offset + data_size == 1 + message.text.size()) {
// done
fprintf(stderr, "HS: done %d:%d\n", peer_number, transfer_id);
group.sending.erase(std::make_pair(peer_number, transfer_id));
}
}
#define _HS1_HAVE(x, error) if ((length - curser) < (x)) { error; }
@ -523,24 +645,26 @@ void _handle_HS1_REQUEST_LAST_IDS(
uint32_t peer_number,
const uint8_t *data,
size_t length
size_t length,
void* user_data
) {
NGC_HS1* ngc_hs1_ctx = ngc_ext_ctx->ngc_hs1_ctx;
assert(user_data);
NGC_HS1* ngc_hs1_ctx = static_cast<NGC_HS1*>(user_data);
size_t curser = 0;
_PeerKey p_key;
_HS1_HAVE(p_key.data.size(), fprintf(stderr, "packet too small, missing pkey\n"); return)
NGC_EXT::PeerKey p_key;
_HS1_HAVE(p_key.data.size(), fprintf(stderr, "HS: packet too small, missing pkey\n"); return)
std::copy(data+curser, data+curser+p_key.data.size(), p_key.data.begin());
curser += p_key.data.size();
_HS1_HAVE(1, fprintf(stderr, "packet too small, missing count\n"); return)
_HS1_HAVE(1, fprintf(stderr, "HS: packet too small, missing count\n"); return)
uint8_t last_msg_id_count = data[curser++];
fprintf(stderr, "got request for last %u ids\n", last_msg_id_count);
//fprintf(stderr, "HS: got request for last %u ids\n", last_msg_id_count);
// get group id
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}
@ -570,7 +694,7 @@ void _handle_HS1_REQUEST_LAST_IDS(
size_t packing_curser = 0;
pkg[packing_curser++] = HS1_RESPONSE_LAST_IDS;
pkg[packing_curser++] = NGC_EXT::HS1_RESPONSE_LAST_IDS;
std::copy(p_key.data.begin(), p_key.data.end(), pkg.begin()+packing_curser);
packing_curser += p_key.data.size();
@ -596,30 +720,32 @@ void _handle_HS1_RESPONSE_LAST_IDS(
uint32_t peer_number,
const uint8_t *data,
size_t length
size_t length,
void* user_data
) {
NGC_HS1* ngc_hs1_ctx = ngc_ext_ctx->ngc_hs1_ctx;
assert(user_data);
NGC_HS1* ngc_hs1_ctx = static_cast<NGC_HS1*>(user_data);
size_t curser = 0;
_PeerKey p_key;
_HS1_HAVE(p_key.data.size(), fprintf(stderr, "packet too small, missing pkey\n"); return)
NGC_EXT::PeerKey p_key;
_HS1_HAVE(p_key.data.size(), fprintf(stderr, "HS: packet too small, missing pkey\n"); return)
std::copy(data+curser, data+curser+p_key.data.size(), p_key.data.begin());
curser += p_key.data.size();
// TODO: did we ask?
_HS1_HAVE(1, fprintf(stderr, "packet too small, missing count\n"); return)
_HS1_HAVE(1, fprintf(stderr, "HS: packet too small, missing count\n"); return)
uint8_t last_msg_id_count = data[curser++];
fprintf(stderr, "got response with last %u ids:\n", last_msg_id_count);
fprintf(stderr, "HS: got response with last %u ids:\n", last_msg_id_count);
if (last_msg_id_count == 0) {
return;
}
// get group id
_GroupKey g_id{};
NGC_EXT::GroupKey g_id{};
{ // TODO: error
tox_group_get_chat_id(tox, group_number, g_id.data.data(), nullptr);
}

41
ngc_hs1.h
View File

@ -9,7 +9,8 @@
#include <tox/tox.h>
#include "ngc_ext_common.h"
#include "ngc_ext.h"
#include "ngc_ft1.h"
#ifdef __cplusplus
extern "C" {
@ -39,17 +40,20 @@ struct NGC_HS1_options {
// ========== init / kill ==========
// (see tox api)
//NGC_HS1* NGC_HS1_new(const struct NGC_HS1_options* options);
bool NGC_HS1_init(NGC_EXT_CTX* ngc_ext_ctx, const struct NGC_HS1_options* options);
//void NGC_HS1_kill(NGC_HS1* ngc_hs1_ctx);
void NGC_HS1_kill(NGC_EXT_CTX* ngc_ext_ctx);
NGC_HS1* NGC_HS1_new(const struct NGC_HS1_options* options);
bool NGC_HS1_register_ext(NGC_HS1* ngc_hs1_ctx, NGC_EXT_CTX* ngc_ext_ctx);
bool NGC_HS1_register_ft1(NGC_HS1* ngc_hs1_ctx, NGC_FT1* ngc_ft1_ctx);
//bool NGC_HS1_init(NGC_EXT_CTX* ngc_ext_ctx, const struct NGC_HS1_options* options);
void NGC_HS1_kill(NGC_HS1* ngc_hs1_ctx);
//void NGC_HS1_kill(NGC_EXT_CTX* ngc_ext_ctx);
// ========== iterate ==========
void NGC_HS1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/);
void NGC_HS1_iterate(Tox *tox, NGC_HS1* ngc_hs1_ctx);
//void NGC_HS1_iterate(Tox *tox, NGC_EXT_CTX* ngc_ext_ctx/*, void *user_data*/);
// ========== peer online/offline ==========
void NGC_HS1_peer_online(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_number, uint32_t peer_number, bool online);
void NGC_HS1_peer_online(Tox* tox, NGC_HS1* ngc_hs1_ctx, uint32_t group_number, uint32_t peer_number, bool online);
// ========== send ==========
@ -57,7 +61,7 @@ void NGC_HS1_peer_online(Tox* tox, NGC_EXT_CTX* ngc_ext_ctx, uint32_t group_numb
// NGC_HS1_record_own_message()
bool NGC_HS1_shim_group_send_message(
const Tox *tox,
NGC_EXT_CTX* ngc_ext_ctx,
NGC_HS1* ngc_hs1_ctx,
uint32_t group_number,
@ -71,7 +75,7 @@ bool NGC_HS1_shim_group_send_message(
// record own msg
void NGC_HS1_record_own_message(
const Tox *tox,
NGC_EXT_CTX* ngc_ext_ctx,
NGC_HS1* ngc_hs1_ctx,
uint32_t group_number,
@ -80,16 +84,23 @@ void NGC_HS1_record_own_message(
// ========== receive message ==========
// !!! no shim, whould require global state !!!
// shim (same interface)
//typedef void tox_group_message_cb(Tox *tox, uint32_t group_number, uint32_t peer_id, Tox_Message_Type type,
//const uint8_t *message, size_t length, uint32_t message_id, void *user_data);
//void NGC_HS1_callback_group_message(Tox *tox, NGC_HS1* ngc_hs1_ctx, tox_group_message_cb *callback);
typedef void NGC_HS1_group_message_cb(
Tox *tox,
uint32_t group_number,
uint32_t peer_id,
Tox_Message_Type type,
const uint8_t *message,
size_t length,
uint32_t message_id
);
// callback for when history sync has a new message
void NGC_HS1_register_callback_group_message(NGC_HS1* ngc_hs1_ctx, NGC_HS1_group_message_cb* callback); // TODO: userdata
// record others msg
void NGC_HS1_record_message(
const Tox *tox,
NGC_EXT_CTX* ngc_ext_ctx,
NGC_HS1* ngc_hs1_ctx,
uint32_t group_number,
uint32_t peer_number,

29
ngc_hs1.hpp
View File

@ -2,21 +2,23 @@
#include "./ngc_hs1.h"
#include "ngc_ext_common.hpp"
#include "../tox_ngc_ext/ngc_ext.hpp"
#include "ngc_ft1.h"
#include <cstdint>
#include <map>
#include <list>
#include <set>
#include <vector>
#include <optional>
struct NGC_HS1 {
NGC_HS1_options options;
// callbacks
//tox_group_message_cb* client_tox_msg_callback;
NGC_FT1* ngc_ft1_ctx {nullptr};
// callbacks
NGC_HS1_group_message_cb* cb_group_message {nullptr};
// key - key - key - value store
// group pubkey - peer pubkey - msg_id - message(type + text)
@ -50,21 +52,26 @@ struct NGC_HS1 {
};
struct Group {
std::map<_PeerKey, Peer> peers;
std::map<NGC_EXT::PeerKey, Peer> peers;
struct FileTransfers {
//uint32_t peer_number; // the peer we requested the message from
float time_since_ft_activity {0.f};
_PeerKey msg_peer;
NGC_EXT::PeerKey msg_peer;
uint32_t msg_id;
float time_since_ft_activity {0.f};
std::vector<uint8_t> recv_buffer; // message gets dumped into here
size_t file_size {0};
};
// key: peer_number + transfer_id
std::map<std::pair<uint32_t, uint8_t>, FileTransfers> transfers;
struct Sending {
NGC_EXT::PeerKey msg_peer;
uint32_t msg_id;
};
std::map<std::pair<uint32_t, uint8_t>, Sending> sending;
};
std::map<_GroupKey, Group> history;
std::map<NGC_EXT::GroupKey, Group> history;
};
void _handle_HS1_REQUEST_LAST_IDS(
@ -75,7 +82,8 @@ void _handle_HS1_REQUEST_LAST_IDS(
uint32_t peer_number,
const uint8_t *data,
size_t length
size_t length,
void* user_data
);
void _handle_HS1_RESPONSE_LAST_IDS(
@ -86,7 +94,8 @@ void _handle_HS1_RESPONSE_LAST_IDS(
uint32_t peer_number,
const uint8_t *data,
size_t length
size_t length,
void* user_data
);
void _handle_HS1_ft_request_message(