external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
Code Issues Releases Wiki Activity

Tunnel reinit support + Fixed packets recv through tunnel

Browse source
This commit is contained in:
Oleg Baranov 2025-02-25 16:04:32 +04:00
parent d287bafa15
commit 374e75932f
11 changed files with 177 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

43
adnl/adnl-network-manager.cpp
View file

@ -76,32 +76,43 @@ size_t AdnlNetworkManagerImpl::add_listening_udp_port(td::uint16 port) {
return idx;
}
size_t AdnlNetworkManagerImpl::add_tunnel_udp_port(td::uint16 port, td::Promise<td::IPAddress> on_ready) {
auto it = port_2_socket_.find(port);
#define TUNNEL_FAKE_PORT 1
size_t AdnlNetworkManagerImpl::add_tunnel_udp_port(std::string global_config, std::string tunnel_config, td::Promise<td::IPAddress> on_ready,
td::actor::Scheduler *scheduler) {
auto it = port_2_socket_.find(TUNNEL_FAKE_PORT);
if (it != port_2_socket_.end()) {
return it->second;
}
class Callback : public td::UdpServer::Callback {
class Callback : public td::UdpServer::TunnelCallback {
public:
Callback(td::actor::ActorShared<AdnlNetworkManagerImpl> manager, size_t idx)
: manager_(std::move(manager)), idx_(idx) {
Callback(td::actor::ActorShared<AdnlNetworkManagerImpl> manager, size_t idx, td::actor::Scheduler *scheduler, TunnelEventsHandler* tunnel_events_handler)
: manager_(std::move(manager)), idx_(idx), scheduler_(scheduler), tunnel_events_handler_(tunnel_events_handler) {
}
private:
TunnelEventsHandler* tunnel_events_handler_;
td::actor::ActorShared<AdnlNetworkManagerImpl> manager_;
size_t idx_;
td::actor::Scheduler *scheduler_;
void on_udp_message(td::UdpMessage udp_message) override {
td::actor::send_closure_later(manager_, &AdnlNetworkManagerImpl::receive_udp_message, std::move(udp_message),
idx_);
scheduler_->run_in_context_external([&] {
td::actor::send_closure_later(manager_, &AdnlNetworkManagerImpl::receive_udp_message, std::move(udp_message),
idx_);
});
}
void on_in_addr_update(const td::IPAddress ip) override {
tunnel_events_handler_->on_in_addr_update(ip);
}
};
auto idx = udp_sockets_.size();
auto X = td::UdpServer::create_via_tunnel("udp tunnel server", port,
std::make_unique<Callback>(actor_shared(this), idx), std::move(on_ready));
auto X = td::UdpServer::create_via_tunnel("udp tunnel server", global_config, tunnel_config,
std::make_unique<Callback>(actor_shared(this), idx, scheduler, tunnel_events_handler_.get()),
std::move(on_ready));
X.ensure();
port_2_socket_[port] = idx;
udp_sockets_.push_back(UdpSocketDesc{port, X.move_as_ok()});
port_2_socket_[TUNNEL_FAKE_PORT] = idx;
udp_sockets_.push_back(UdpSocketDesc{TUNNEL_FAKE_PORT, X.move_as_ok()});
return idx;
}
@ -121,12 +132,12 @@ void AdnlNetworkManagerImpl::add_self_addr(td::IPAddress addr, AdnlCategoryMask
out_desc_[priority].push_back(std::move(d));
}
void AdnlNetworkManagerImpl::add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
td::Promise<td::IPAddress> on_ready) {
size_t idx = add_tunnel_udp_port(port, std::move(on_ready));
void AdnlNetworkManagerImpl::add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority,
td::Promise<td::IPAddress> on_ready, td::actor::Scheduler *scheduler) {
size_t idx = add_tunnel_udp_port(global_config, tunnel_config, std::move(on_ready), scheduler);
add_in_addr(InDesc{port, nullptr, cat_mask}, idx);
auto d = OutDesc{port, td::IPAddress{}, nullptr, idx};
add_in_addr(InDesc{TUNNEL_FAKE_PORT, nullptr, cat_mask}, idx);
auto d = OutDesc{TUNNEL_FAKE_PORT, td::IPAddress{}, nullptr, idx};
for (auto &it : out_desc_[priority]) {
if (it == d) {
it.cat_mask |= cat_mask;

12
adnl/adnl-network-manager.h
View file

@ -59,19 +59,25 @@ class AdnlNetworkManager : public td::actor::Actor {
public:
//using ConnHandle = td::uint64;
class Callback {
public:
public:
virtual ~Callback() = default;
//virtual void receive_packet(td::IPAddress addr, ConnHandle conn_handle, td::BufferSlice data) = 0;
virtual void receive_packet(td::IPAddress addr, AdnlCategoryMask cat_mask, td::BufferSlice data) = 0;
};
class TunnelEventsHandler {
public:
virtual ~TunnelEventsHandler() = default;
virtual void on_in_addr_update(td::IPAddress ip) = 0;
};
static td::actor::ActorOwn<AdnlNetworkManager> create(td::uint16 out_port);
virtual ~AdnlNetworkManager() = default;
virtual void install_callback(std::unique_ptr<Callback> callback) = 0;
virtual void install_tunnel_events_handler(std::unique_ptr<TunnelEventsHandler> handler) = 0;
virtual void add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
td::Promise<td::IPAddress> on_ready) = 0;
virtual void add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority,
td::Promise<td::IPAddress> on_ready, td::actor::Scheduler *scheduler) = 0;
virtual void add_self_addr(td::IPAddress addr, AdnlCategoryMask cat_mask, td::uint32 priority) = 0;
virtual void add_proxy_addr(td::IPAddress addr, td::uint16 local_port, std::shared_ptr<AdnlProxy> proxy,
AdnlCategoryMask cat_mask, td::uint32 priority) = 0;

11
adnl/adnl-network-manager.hpp
View file

@ -109,6 +109,10 @@ class AdnlNetworkManagerImpl : public AdnlNetworkManager {
callback_ = std::move(callback);
}
void install_tunnel_events_handler(std::unique_ptr<TunnelEventsHandler> handler) override {
tunnel_events_handler_ = std::move(handler);
}
void alarm() override;
void start_up() override {
alarm_timestamp() = td::Timestamp::in(60.0);
@ -131,8 +135,8 @@ class AdnlNetworkManagerImpl : public AdnlNetworkManager {
in_desc_.push_back(std::move(desc));
}
void add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
td::Promise<td::IPAddress> on_ready) override;
void add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority, td::Promise<td::IPAddress> on_ready,
td::actor::Scheduler *scheduler) override;
void add_self_addr(td::IPAddress addr, AdnlCategoryMask cat_mask, td::uint32 priority) override;
void add_proxy_addr(td::IPAddress addr, td::uint16 local_port, std::shared_ptr<AdnlProxy> proxy,
AdnlCategoryMask cat_mask, td::uint32 priority) override;
@ -147,13 +151,14 @@ class AdnlNetworkManagerImpl : public AdnlNetworkManager {
}
}
size_t add_tunnel_udp_port(td::uint16 port, td::Promise<td::IPAddress> on_ready);
size_t add_tunnel_udp_port(std::string global_config, std::string tunnel_config, td::Promise<td::IPAddress> on_ready, td::actor::Scheduler *scheduler);
size_t add_listening_udp_port(td::uint16 port);
void receive_udp_message(td::UdpMessage message, size_t idx);
void proxy_register(OutDesc &desc);
private:
std::unique_ptr<Callback> callback_;
std::unique_ptr<TunnelEventsHandler> tunnel_events_handler_;
std::map<td::uint32, std::vector<OutDesc>> out_desc_;
std::vector<InDesc> in_desc_;

6
adnl/adnl-test-loopback-implementation.h
View file

@ -34,13 +34,15 @@ class TestLoopbackNetworkManager : public ton::adnl::AdnlNetworkManager {
callback_ = std::move(callback);
}
void install_tunnel_events_handler(std::unique_ptr<TunnelEventsHandler> handler) override {};
void add_self_addr(td::IPAddress addr, AdnlCategoryMask cat_mask, td::uint32 priority) override {
}
void add_proxy_addr(td::IPAddress addr, td::uint16 local_port, std::shared_ptr<AdnlProxy> proxy,
AdnlCategoryMask cat_mask, td::uint32 priority) override {
}
void add_tunnel(td::uint16 port, AdnlCategoryMask cat_mask, td::uint32 priority,
td::Promise<td::IPAddress> on_ready) override {
void add_tunnel(std::string global_config, std::string tunnel_config, AdnlCategoryMask cat_mask, td::uint32 priority, td::Promise<td::IPAddress> on_ready,
td::actor::Scheduler* scheduler) override {
}
void send_udp_packet(ton::adnl::AdnlNodeIdShort src_id, ton::adnl::AdnlNodeIdShort dst_id, td::IPAddress dst_addr,
td::uint32 priority, td::BufferSlice data) override {