init ft (no ack or data yet)

ngc_ft1.cpp

@@ -3,11 +3,58 @@
 #include "ngc_ext_common.hpp"
 
 #include <vector>
+#include <unordered_map>
+#include <map>
+#include <optional>
 #include <cassert>
 
 struct NGC_FT1 {
 	NGC_FT1_options options;
 
+	std::unordered_map<NGC_FT1_file_kind, NGC_FT1_recv_request_cb*> cb_request;
+	std::unordered_map<NGC_FT1_file_kind, NGC_FT1_recv_init_cb*> cb_init;
+
+	struct Group {
+		struct Peer {
+			struct RecvTransfer {
+				std::vector<uint8_t> file_id;
+
+				//enum class State {
+					//INIT_SENT,
+					//SENDING,
+				//} state;
+
+				// float time_since_last_activity ?
+				size_t file_size {0};
+				size_t file_size_current {0};
+
+				// sequenz array
+				// list of last x received seq_ids
+			};
+			std::array<std::optional<RecvTransfer>, 256> recv_transfers;
+			size_t next_recv_transfer_idx {0}; // next id will be 0
+
+			struct SendTransfer {
+				std::vector<uint8_t> file_id;
+
+				enum class State {
+					INIT_SENT,
+					SENDING,
+				} state;
+
+				// float time_since_last_activity ?
+				size_t file_size {0};
+				size_t file_size_current {0};
+
+				// sequenz array
+				// list of sent but not acked seq_ids
+			};
+			std::array<std::optional<SendTransfer>, 256> send_transfers;
+			size_t next_send_transfer_idx {0}; // next id will be 0
+		};
+		std::map<uint32_t, Peer> peers;
+	};
+	std::map<uint32_t, Group> groups;
 };
 
 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);
@@ -42,7 +89,7 @@ void NGC_FT1_kill(NGC_EXT_CTX* ngc_ext_ctx) {
 
 // iterate
 
-void NGC_FT1_request(
+void NGC_FT1_send_request(
 	Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
 
 	uint32_t group_number,
@@ -55,12 +102,12 @@ void NGC_FT1_request(
 	// just call private for every peer in group?
 	for (;;) {
 		uint32_t peer_number = 0;
-		NGC_FT1_request_private(tox, ngc_ext_ctx, group_number, peer_number, file_kind, file_id, file_id_size);
+		NGC_FT1_send_request_private(tox, ngc_ext_ctx, group_number, peer_number, file_kind, file_id, file_id_size);
 		assert(false && "not implemented");
 	}
 }
 
-void NGC_FT1_request_private(
+void NGC_FT1_send_request_private(
 	Tox *tox, NGC_EXT_CTX* ngc_ext_ctx,
 
 	uint32_t group_number,
@@ -91,6 +138,90 @@ void NGC_FT1_request_private(
 	tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
 }
 
+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);
+
+	ngc_ext_ctx->ngc_ft1_ctx->cb_request[file_kind] = callback;
+}
+
+bool NGC_FT1_send_init_private(
+	Tox *tox, NGC_EXT_CTX* ngc_ext_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
+) {
+	//fprintf(stderr, "TODO: init ft for %08X\n", msg_id);
+	fprintf(stderr, "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");
+		return false;
+	}
+
+	auto& peer = ngc_ext_ctx->ngc_ft1_ctx->groups[group_number].peers[peer_number];
+
+	// allocate transfer_id
+	size_t idx = peer.next_send_transfer_idx;
+	peer.next_send_transfer_idx = (peer.next_send_transfer_idx + 1) % 256;
+	{ // TODO: extract
+		size_t i = idx;
+		bool found = false;
+		do {
+			if (!peer.send_transfers[i].has_value()) {
+				// free slot
+				idx = i;
+				found = true;
+				break;
+			}
+
+			i = (i + 1) % 256;
+		} while (i != idx);
+
+		if (!found) {
+			fprintf(stderr, "error: cant init ft, no free transfer slot\n");
+			return false;
+		}
+	}
+
+	// - 1 byte packet id
+	// - 1 byte (file_kind)
+	// - 8 bytes (data size) // TODO: do all file kinds have a size at init?
+	// - 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)
+
+	std::vector<uint8_t> pkg;
+	pkg.push_back(FT1_INIT);
+	pkg.push_back(file_kind);
+	for (size_t i = 0; i < sizeof(file_size); i++) {
+		pkg.push_back((file_size>>i) & 0xff);
+	}
+	pkg.push_back(idx);
+	for (size_t i = 0; i < file_id_size; i++) {
+		pkg.push_back(file_id[i]);
+	}
+
+	// lossless
+	tox_group_send_custom_private_packet(tox, group_number, peer_number, true, pkg.data(), pkg.size(), nullptr);
+
+	peer.send_transfers[idx] = NGC_FT1::Group::Peer::SendTransfer{
+		std::vector(file_id, file_id+file_id_size),
+		NGC_FT1::Group::Peer::SendTransfer::State::INIT_SENT,
+		file_size,
+		0,
+	};
+
+	return true;
+}
+
+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);
+
+	ngc_ext_ctx->ngc_ft1_ctx->cb_init[file_kind] = callback;
+}
+
 #define _DATA_HAVE(x, error) if ((length - curser) < (x)) { error; }
 
 static void _handle_FT1_REQUEST(
@@ -106,15 +237,26 @@ static void _handle_FT1_REQUEST(
 	size_t curser = 0;
 
 	// TODO: might be uint16_t or even larger
-	uint8_t file_kind;
-	_DATA_HAVE(sizeof(file_kind), fprintf(stderr, "packet too small, missing file_kind\n"); return)
-	file_kind = data[curser++];
+	uint8_t file_kind_u8;
+	_DATA_HAVE(sizeof(file_kind_u8), fprintf(stderr, "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);
-	for (; curser < length; curser++) {
-		fprintf(stderr, "%02X", data[curser]);
+	fprintf(stderr, "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_request.count(file_kind)) {
+		fn_ptr = ngc_ext_ctx->ngc_ft1_ctx->cb_request.at(file_kind);
+	}
+	if (fn_ptr) {
+		fn_ptr(tox, ngc_ext_ctx, group_number, peer_number, data+curser, length-curser);
+	} else {
+		fprintf(stderr, "missing cb for requests\n");
+	}
 }
 
 #undef _DATA_HAVE