Skip to content

Commit 54c7a4d

Browse files
author
ton
committed
updated vm
- updated func/fift - additional checks in block validator - docs - tunnel prototype in ADNL
1 parent ba76f14 commit 54c7a4d

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

50 files changed

+961
-289
lines changed

‎adnl/adnl-address-list.cpp‎

Lines changed: 83 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121
#include "auto/tl/ton_api.hpp"
2222
#include "td/utils/overloaded.h"
2323
#include "td/net/UdpServer.h"
24+
#include "keys/encryptor.h"
2425

2526
namespace ton {
2627

@@ -50,6 +51,59 @@ class AdnlNetworkConnectionUdp : public AdnlNetworkConnection {
5051
std::unique_ptr<AdnlNetworkConnection::Callback> callback_;
5152
};
5253

54+
class AdnlNetworkConnectionTunnel : public AdnlNetworkConnection {
55+
public:
56+
void send(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::uint32 priority, td::BufferSlice message) override {
57+
if (!encryptor_) {
58+
VLOG(ADNL_INFO) << "tunnel: message [" << src << "->" << dst << "to bad tunnel. dropping";
59+
return;
60+
}
61+
auto dataR = encryptor_->encrypt(message.as_slice());
62+
if (dataR.is_error()) {
63+
VLOG(ADNL_INFO) << "tunnel: message [" << src << "->" << dst << ": failed to encrypt: " << dataR.move_as_error();
64+
return;
65+
}
66+
auto data = dataR.move_as_ok();
67+
td::BufferSlice enc_message{data.size() + 32};
68+
auto S = enc_message.as_slice();
69+
S.copy_from(pub_key_hash_.as_slice());
70+
S.remove_prefix(32);
71+
S.copy_from(data.as_slice());
72+
td::actor::send_closure(adnl_, &Adnl::send_message_ex, src, adnl_id_, std::move(enc_message),
73+
Adnl::SendFlags::direct_only);
74+
}
75+
bool is_alive() const override {
76+
return ready_.load(std::memory_order_consume);
77+
}
78+
bool is_active() const override {
79+
return ready_.load(std::memory_order_consume);
80+
}
81+
void start_up() override {
82+
auto R = pub_key_.create_encryptor();
83+
if (R.is_error()) {
84+
VLOG(ADNL_INFO) << "tunnel: bad public key: " << R.move_as_error();
85+
return;
86+
}
87+
encryptor_ = R.move_as_ok();
88+
pub_key_hash_ = pub_key_.compute_short_id();
89+
//ready_.store(true, std::memory_order_release);
90+
}
91+
92+
AdnlNetworkConnectionTunnel(td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
93+
adnl::AdnlNodeIdShort adnl_id, PublicKey pubkey,
94+
std::unique_ptr<AdnlNetworkConnection::Callback> callback);
95+
96+
private:
97+
td::actor::ActorId<AdnlNetworkManager> network_manager_;
98+
td::actor::ActorId<Adnl> adnl_;
99+
AdnlNodeIdShort adnl_id_;
100+
PublicKey pub_key_;
101+
PublicKeyHash pub_key_hash_;
102+
std::unique_ptr<Encryptor> encryptor_;
103+
std::atomic<bool> ready_{false};
104+
std::unique_ptr<AdnlNetworkConnection::Callback> callback_;
105+
};
106+
53107
void AdnlNetworkConnectionUdp::send(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::uint32 priority,
54108
td::BufferSlice message) {
55109
LOG_CHECK(message.size() <= AdnlNetworkManager::get_mtu()) << "dst=" << addr_ << " size=" << message.size();
@@ -71,12 +125,23 @@ AdnlNetworkConnectionUdp::AdnlNetworkConnectionUdp(td::actor::ActorId<AdnlNetwor
71125
addr_.init_host_port(td::IPAddress::ipv6_to_str(ip.as_slice()), port).ensure();
72126
}
73127

128+
AdnlNetworkConnectionTunnel::AdnlNetworkConnectionTunnel(td::actor::ActorId<AdnlNetworkManager> network_manager,
129+
td::actor::ActorId<Adnl> adnl, adnl::AdnlNodeIdShort adnl_id,
130+
PublicKey pubkey,
131+
std::unique_ptr<AdnlNetworkConnection::Callback> callback)
132+
: network_manager_(std::move(network_manager))
133+
, adnl_(std::move(adnl))
134+
, adnl_id_(adnl_id)
135+
, pub_key_(std::move(pubkey))
136+
, callback_(std::move(callback)) {
137+
}
138+
74139
AdnlAddressImpl::Hash AdnlAddressImpl::get_hash() const {
75140
return get_tl_object_sha_bits256(tl());
76141
}
77142

78143
td::actor::ActorOwn<AdnlNetworkConnection> AdnlAddressUdp::create_connection(
79-
td::actor::ActorId<AdnlNetworkManager> network_manager,
144+
td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
80145
std::unique_ptr<AdnlNetworkConnection::Callback> callback) const {
81146
return td::actor::create_actor<AdnlNetworkConnectionUdp>("udpconn", network_manager, ip_, port_, std::move(callback));
82147
}
@@ -87,7 +152,7 @@ AdnlAddressUdp::AdnlAddressUdp(const ton_api::adnl_address_udp &obj) {
87152
}
88153

89154
td::actor::ActorOwn<AdnlNetworkConnection> AdnlAddressUdp6::create_connection(
90-
td::actor::ActorId<AdnlNetworkManager> network_manager,
155+
td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
91156
std::unique_ptr<AdnlNetworkConnection::Callback> callback) const {
92157
return td::actor::create_actor<AdnlNetworkConnectionUdp>("udpconn", network_manager, ip_, port_, std::move(callback));
93158
}
@@ -97,16 +162,24 @@ AdnlAddressUdp6::AdnlAddressUdp6(const ton_api::adnl_address_udp6 &obj) {
97162
port_ = static_cast<td::uint16>(obj.port_);
98163
}
99164

165+
td::actor::ActorOwn<AdnlNetworkConnection> AdnlAddressTunnel::create_connection(
166+
td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
167+
std::unique_ptr<AdnlNetworkConnection::Callback> callback) const {
168+
return td::actor::create_actor<AdnlNetworkConnectionTunnel>("tunnelconn", network_manager, adnl, adnl_id_, pub_key_,
169+
std::move(callback));
170+
}
171+
AdnlAddressTunnel::AdnlAddressTunnel(const ton_api::adnl_address_tunnel &obj) {
172+
adnl_id_ = AdnlNodeIdShort{obj.to_};
173+
pub_key_ = ton::PublicKey{obj.pubkey_};
174+
}
175+
100176
td::Ref<AdnlAddressImpl> AdnlAddressImpl::create(const tl_object_ptr<ton_api::adnl_Address> &addr) {
101177
td::Ref<AdnlAddressImpl> res = td::Ref<AdnlAddressImpl>{};
102-
ton_api::downcast_call(*const_cast<ton_api::adnl_Address *>(addr.get()),
103-
td::overloaded(
104-
[&](const ton_api::adnl_address_udp &obj) {
105-
res = td::Ref<AdnlAddressUdp>{true, obj};
106-
},
107-
[&](const ton_api::adnl_address_udp6 &obj) {
108-
res = td::Ref<AdnlAddressUdp6>{true, obj};
109-
}));
178+
ton_api::downcast_call(
179+
*const_cast<ton_api::adnl_Address *>(addr.get()),
180+
td::overloaded([&](const ton_api::adnl_address_udp &obj) { res = td::make_ref<AdnlAddressUdp>(obj); },
181+
[&](const ton_api::adnl_address_udp6 &obj) { res = td::make_ref<AdnlAddressUdp6>(obj); },
182+
[&](const ton_api::adnl_address_tunnel &obj) { res = td::make_ref<AdnlAddressTunnel>(obj); }));
110183
return res;
111184
}
112185

‎adnl/adnl-address-list.h‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,8 @@ namespace ton {
2525

2626
namespace adnl {
2727

28+
class Adnl;
29+
2830
class AdnlAddressImpl : public td::CntObject {
2931
public:
3032
using Hash = td::Bits256;
@@ -35,7 +37,7 @@ class AdnlAddressImpl : public td::CntObject {
3537
virtual td::uint32 serialized_size() const = 0;
3638
virtual tl_object_ptr<ton_api::adnl_Address> tl() const = 0;
3739
virtual td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
38-
td::actor::ActorId<AdnlNetworkManager> network_manager,
40+
td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
3941
std::unique_ptr<AdnlNetworkConnection::Callback> callback) const = 0;
4042

4143
static td::Ref<AdnlAddressImpl> create(const tl_object_ptr<ton_api::adnl_Address> &addr);

‎adnl/adnl-address-list.hpp‎

Lines changed: 33 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ class AdnlAddressUdp : public AdnlAddressImpl {
5151
return create_tl_object<ton_api::adnl_address_udp>(ip_, port_);
5252
}
5353
td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
54-
td::actor::ActorId<AdnlNetworkManager> network_manager,
54+
td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
5555
std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override;
5656
};
5757

@@ -81,7 +81,38 @@ class AdnlAddressUdp6 : public AdnlAddressImpl {
8181
return create_tl_object<ton_api::adnl_address_udp6>(ip_, port_);
8282
}
8383
td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
84-
td::actor::ActorId<AdnlNetworkManager> network_manager,
84+
td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
85+
std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override;
86+
};
87+
88+
class AdnlAddressTunnel : public AdnlAddressImpl {
89+
private:
90+
AdnlNodeIdShort adnl_id_;
91+
PublicKey pub_key_;
92+
93+
public:
94+
explicit AdnlAddressTunnel(const ton_api::adnl_address_tunnel &obj);
95+
96+
AdnlAddressTunnel(AdnlNodeIdShort adnl_id, PublicKey pub_key)
97+
: adnl_id_(std::move(adnl_id)), pub_key_(std::move(pub_key)) {
98+
}
99+
100+
AdnlAddressTunnel *make_copy() const override {
101+
return new AdnlAddressTunnel{*this};
102+
}
103+
104+
bool is_public() const override {
105+
return false;
106+
}
107+
td::uint32 serialized_size() const override {
108+
return 4 + 32 + pub_key_.serialized_size();
109+
}
110+
111+
tl_object_ptr<ton_api::adnl_Address> tl() const override {
112+
return create_tl_object<ton_api::adnl_address_tunnel>(adnl_id_.bits256_value(), pub_key_.tl());
113+
}
114+
td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
115+
td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
85116
std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override;
86117
};
87118

‎adnl/adnl-message.h‎

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -249,6 +249,40 @@ class AdnlMessage {
249249
}
250250
};
251251

252+
class OutboundAdnlMessage {
253+
public:
254+
template <class T>
255+
OutboundAdnlMessage(T m, td::uint32 flags) : message_{std::move(m)}, flags_(flags) {
256+
}
257+
td::uint32 flags() const {
258+
return flags_;
259+
}
260+
void set_flags(td::uint32 f) {
261+
flags_ = f;
262+
}
263+
tl_object_ptr<ton_api::adnl_Message> tl() const {
264+
return message_.tl();
265+
}
266+
td::uint32 size() const {
267+
return message_.size();
268+
}
269+
template <class F>
270+
void visit(F &&f) {
271+
message_.visit(std::move(f));
272+
}
273+
template <class F>
274+
void visit(F &&f) const {
275+
message_.visit(std::move(f));
276+
}
277+
AdnlMessage release() {
278+
return std::move(message_);
279+
}
280+
281+
private:
282+
AdnlMessage message_;
283+
td::uint32 flags_;
284+
};
285+
252286
class AdnlMessageList {
253287
public:
254288
AdnlMessageList() {
@@ -291,6 +325,48 @@ class AdnlMessageList {
291325
std::vector<AdnlMessage> messages_;
292326
};
293327

328+
class OutboundAdnlMessageList {
329+
public:
330+
OutboundAdnlMessageList() {
331+
}
332+
OutboundAdnlMessageList(tl_object_ptr<ton_api::adnl_Message> message, td::uint32 flags) {
333+
auto msg = OutboundAdnlMessage{std::move(message), flags};
334+
messages_.emplace_back(std::move(msg));
335+
}
336+
OutboundAdnlMessageList(std::vector<tl_object_ptr<ton_api::adnl_Message>> messages, td::uint32 flags) {
337+
for (auto &message : messages) {
338+
messages_.push_back(OutboundAdnlMessage{std::move(message), flags});
339+
}
340+
}
341+
void push_back(OutboundAdnlMessage message) {
342+
messages_.push_back(std::move(message));
343+
}
344+
345+
td::uint32 size() const {
346+
return static_cast<td::uint32>(messages_.size());
347+
}
348+
tl_object_ptr<ton_api::adnl_Message> one_message() const {
349+
CHECK(size() == 1);
350+
return messages_[0].tl();
351+
}
352+
std::vector<tl_object_ptr<ton_api::adnl_Message>> mult_messages() const {
353+
std::vector<tl_object_ptr<ton_api::adnl_Message>> vec;
354+
for (auto &m : messages_) {
355+
vec.emplace_back(m.tl());
356+
}
357+
return vec;
358+
}
359+
static std::vector<tl_object_ptr<ton_api::adnl_Message>> empty_vector() {
360+
return std::vector<tl_object_ptr<ton_api::adnl_Message>>{};
361+
}
362+
auto &vector() {
363+
return messages_;
364+
}
365+
366+
private:
367+
std::vector<OutboundAdnlMessage> messages_;
368+
};
369+
294370
} // namespace adnl
295371

296372
} // namespace ton

‎adnl/adnl-peer-table.cpp‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,8 @@ void AdnlPeerTableImpl::add_static_nodes_from_config(AdnlNodesList nodes) {
138138
}
139139
}
140140

141-
void AdnlPeerTableImpl::send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message) {
141+
void AdnlPeerTableImpl::send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message,
142+
td::uint32 flags) {
142143
auto it = peers_.find(dst);
143144

144145
if (it == peers_.end()) {
@@ -152,7 +153,7 @@ void AdnlPeerTableImpl::send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst
152153
}
153154

154155
td::actor::send_closure(it->second, &AdnlPeer::send_one_message, src, it2->second.second, it2->second.first.get(),
155-
std::move(message));
156+
OutboundAdnlMessage{std::move(message), flags});
156157
}
157158

158159
void AdnlPeerTableImpl::answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlQueryId query_id,
@@ -162,7 +163,7 @@ void AdnlPeerTableImpl::answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, A
162163
<< "]: message too big: size=" << data.size();
163164
return;
164165
}
165-
send_message_in(src, dst, adnlmessage::AdnlMessageAnswer{query_id, std::move(data)});
166+
send_message_in(src, dst, adnlmessage::AdnlMessageAnswer{query_id, std::move(data)}, 0);
166167
}
167168

168169
void AdnlPeerTableImpl::send_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, std::string name,
@@ -185,7 +186,7 @@ void AdnlPeerTableImpl::send_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, std
185186
}
186187

187188
td::actor::send_closure(it->second, &AdnlPeer::send_query, src, it2->second.second, it2->second.first.get(), name,
188-
std::move(promise), timeout, std::move(data));
189+
std::move(promise), timeout, std::move(data), 0);
189190
}
190191

191192
void AdnlPeerTableImpl::add_id_ex(AdnlNodeIdFull id, AdnlAddressList addr_list, td::uint32 mode) {

‎adnl/adnl-peer-table.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ class AdnlPeerTable : public Adnl {
9191

9292
virtual void receive_packet(td::IPAddress addr, td::BufferSlice data) = 0;
9393
virtual void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket packet) = 0;
94-
virtual void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message) = 0;
94+
virtual void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message, td::uint32 flags) = 0;
9595

9696
virtual void register_channel(AdnlChannelIdShort id, td::actor::ActorId<AdnlChannel> channel) = 0;
9797
virtual void unregister_channel(AdnlChannelIdShort id) = 0;

‎adnl/adnl-peer-table.hpp‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -45,14 +45,17 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
4545

4646
void receive_packet(td::IPAddress addr, td::BufferSlice data) override;
4747
void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket data) override;
48-
void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message) override;
48+
void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message, td::uint32 flags) override;
4949
void send_message(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data) override {
50+
send_message_ex(src, dst, std::move(data), 0);
51+
}
52+
void send_message_ex(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data, td::uint32 flags) override {
5053
if (data.size() > huge_packet_max_size()) {
5154
VLOG(ADNL_WARNING) << "dropping too big packet [" << src << "->" << dst << "]: size=" << data.size();
5255
VLOG(ADNL_WARNING) << "DUMP: " << td::buffer_to_hex(data.as_slice().truncate(128));
5356
return;
5457
}
55-
send_message_in(src, dst, AdnlMessage{adnlmessage::AdnlMessageCustom{std::move(data)}});
58+
send_message_in(src, dst, AdnlMessage{adnlmessage::AdnlMessageCustom{std::move(data)}}, flags);
5659
}
5760
void answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlQueryId query_id, td::BufferSlice data) override;
5861
void send_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, std::string name, td::Promise<td::BufferSlice> promise,

0 commit comments

Comments
 (0)