updated vm

- updated func/fift - additional checks in block validator - docs - tunnel prototype in ADNL
Ricchkdbanks · Mar 11, 2020 · 54c7a4d · 54c7a4d
1 parent ba76f14
commit 54c7a4d
Show file tree

Hide file tree

Showing 50 changed files with 961 additions and 289 deletions.
diff --git a/adnl/adnl-address-list.cpp b/adnl/adnl-address-list.cpp
@@ -21,6 +21,7 @@
 #include "auto/tl/ton_api.hpp"
 #include "td/utils/overloaded.h"
 #include "td/net/UdpServer.h"
+#include "keys/encryptor.h"
 
 namespace ton {
 
@@ -50,6 +51,59 @@ class AdnlNetworkConnectionUdp : public AdnlNetworkConnection {
   std::unique_ptr<AdnlNetworkConnection::Callback> callback_;
 };
 
+class AdnlNetworkConnectionTunnel : public AdnlNetworkConnection {
+ public:
+  void send(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::uint32 priority, td::BufferSlice message) override {
+    if (!encryptor_) {
+      VLOG(ADNL_INFO) << "tunnel: message [" << src << "->" << dst << "to bad tunnel. dropping";
+      return;
+    }
+    auto dataR = encryptor_->encrypt(message.as_slice());
+    if (dataR.is_error()) {
+      VLOG(ADNL_INFO) << "tunnel: message [" << src << "->" << dst << ": failed to encrypt: " << dataR.move_as_error();
+      return;
+    }
+    auto data = dataR.move_as_ok();
+    td::BufferSlice enc_message{data.size() + 32};
+    auto S = enc_message.as_slice();
+    S.copy_from(pub_key_hash_.as_slice());
+    S.remove_prefix(32);
+    S.copy_from(data.as_slice());
+    td::actor::send_closure(adnl_, &Adnl::send_message_ex, src, adnl_id_, std::move(enc_message),
+                            Adnl::SendFlags::direct_only);
+  }
+  bool is_alive() const override {
+    return ready_.load(std::memory_order_consume);
+  }
+  bool is_active() const override {
+    return ready_.load(std::memory_order_consume);
+  }
+  void start_up() override {
+    auto R = pub_key_.create_encryptor();
+    if (R.is_error()) {
+      VLOG(ADNL_INFO) << "tunnel: bad public key: " << R.move_as_error();
+      return;
+    }
+    encryptor_ = R.move_as_ok();
+    pub_key_hash_ = pub_key_.compute_short_id();
+    //ready_.store(true, std::memory_order_release);
+  }
+
+  AdnlNetworkConnectionTunnel(td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
+                              adnl::AdnlNodeIdShort adnl_id, PublicKey pubkey,
+                              std::unique_ptr<AdnlNetworkConnection::Callback> callback);
+
+ private:
+  td::actor::ActorId<AdnlNetworkManager> network_manager_;
+  td::actor::ActorId<Adnl> adnl_;
+  AdnlNodeIdShort adnl_id_;
+  PublicKey pub_key_;
+  PublicKeyHash pub_key_hash_;
+  std::unique_ptr<Encryptor> encryptor_;
+  std::atomic<bool> ready_{false};
+  std::unique_ptr<AdnlNetworkConnection::Callback> callback_;
+};
+
 void AdnlNetworkConnectionUdp::send(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::uint32 priority,
                                     td::BufferSlice message) {
   LOG_CHECK(message.size() <= AdnlNetworkManager::get_mtu()) << "dst=" << addr_ << " size=" << message.size();
@@ -71,12 +125,23 @@ AdnlNetworkConnectionUdp::AdnlNetworkConnectionUdp(td::actor::ActorId<AdnlNetwor
   addr_.init_host_port(td::IPAddress::ipv6_to_str(ip.as_slice()), port).ensure();
 }
 
+AdnlNetworkConnectionTunnel::AdnlNetworkConnectionTunnel(td::actor::ActorId<AdnlNetworkManager> network_manager,
+                                                         td::actor::ActorId<Adnl> adnl, adnl::AdnlNodeIdShort adnl_id,
+                                                         PublicKey pubkey,
+                                                         std::unique_ptr<AdnlNetworkConnection::Callback> callback)
+    : network_manager_(std::move(network_manager))
+    , adnl_(std::move(adnl))
+    , adnl_id_(adnl_id)
+    , pub_key_(std::move(pubkey))
+    , callback_(std::move(callback)) {
+}
+
 AdnlAddressImpl::Hash AdnlAddressImpl::get_hash() const {
   return get_tl_object_sha_bits256(tl());
 }
 
 td::actor::ActorOwn<AdnlNetworkConnection> AdnlAddressUdp::create_connection(
-    td::actor::ActorId<AdnlNetworkManager> network_manager,
+    td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
     std::unique_ptr<AdnlNetworkConnection::Callback> callback) const {
   return td::actor::create_actor<AdnlNetworkConnectionUdp>("udpconn", network_manager, ip_, port_, std::move(callback));
 }
@@ -87,7 +152,7 @@ AdnlAddressUdp::AdnlAddressUdp(const ton_api::adnl_address_udp &obj) {
 }
 
 td::actor::ActorOwn<AdnlNetworkConnection> AdnlAddressUdp6::create_connection(
-    td::actor::ActorId<AdnlNetworkManager> network_manager,
+    td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
     std::unique_ptr<AdnlNetworkConnection::Callback> callback) const {
   return td::actor::create_actor<AdnlNetworkConnectionUdp>("udpconn", network_manager, ip_, port_, std::move(callback));
 }
@@ -97,16 +162,24 @@ AdnlAddressUdp6::AdnlAddressUdp6(const ton_api::adnl_address_udp6 &obj) {
   port_ = static_cast<td::uint16>(obj.port_);
 }
 
+td::actor::ActorOwn<AdnlNetworkConnection> AdnlAddressTunnel::create_connection(
+    td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
+    std::unique_ptr<AdnlNetworkConnection::Callback> callback) const {
+  return td::actor::create_actor<AdnlNetworkConnectionTunnel>("tunnelconn", network_manager, adnl, adnl_id_, pub_key_,
+                                                              std::move(callback));
+}
+AdnlAddressTunnel::AdnlAddressTunnel(const ton_api::adnl_address_tunnel &obj) {
+  adnl_id_ = AdnlNodeIdShort{obj.to_};
+  pub_key_ = ton::PublicKey{obj.pubkey_};
+}
+
 td::Ref<AdnlAddressImpl> AdnlAddressImpl::create(const tl_object_ptr<ton_api::adnl_Address> &addr) {
   td::Ref<AdnlAddressImpl> res = td::Ref<AdnlAddressImpl>{};
-  ton_api::downcast_call(*const_cast<ton_api::adnl_Address *>(addr.get()),
-                         td::overloaded(
-                             [&](const ton_api::adnl_address_udp &obj) {
-                               res = td::Ref<AdnlAddressUdp>{true, obj};
-                             },
-                             [&](const ton_api::adnl_address_udp6 &obj) {
-                               res = td::Ref<AdnlAddressUdp6>{true, obj};
-                             }));
+  ton_api::downcast_call(
+      *const_cast<ton_api::adnl_Address *>(addr.get()),
+      td::overloaded([&](const ton_api::adnl_address_udp &obj) { res = td::make_ref<AdnlAddressUdp>(obj); },
+                     [&](const ton_api::adnl_address_udp6 &obj) { res = td::make_ref<AdnlAddressUdp6>(obj); },
+                     [&](const ton_api::adnl_address_tunnel &obj) { res = td::make_ref<AdnlAddressTunnel>(obj); }));
   return res;
 }
 

diff --git a/adnl/adnl-address-list.h b/adnl/adnl-address-list.h
@@ -25,6 +25,8 @@ namespace ton {
 
 namespace adnl {
 
+class Adnl;
+
 class AdnlAddressImpl : public td::CntObject {
  public:
   using Hash = td::Bits256;
@@ -35,7 +37,7 @@ class AdnlAddressImpl : public td::CntObject {
   virtual td::uint32 serialized_size() const = 0;
   virtual tl_object_ptr<ton_api::adnl_Address> tl() const = 0;
   virtual td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
-      td::actor::ActorId<AdnlNetworkManager> network_manager,
+      td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
       std::unique_ptr<AdnlNetworkConnection::Callback> callback) const = 0;
 
   static td::Ref<AdnlAddressImpl> create(const tl_object_ptr<ton_api::adnl_Address> &addr);

diff --git a/adnl/adnl-address-list.hpp b/adnl/adnl-address-list.hpp
@@ -51,7 +51,7 @@ class AdnlAddressUdp : public AdnlAddressImpl {
     return create_tl_object<ton_api::adnl_address_udp>(ip_, port_);
   }
   td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
-      td::actor::ActorId<AdnlNetworkManager> network_manager,
+      td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
       std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override;
 };
 
@@ -81,7 +81,38 @@ class AdnlAddressUdp6 : public AdnlAddressImpl {
     return create_tl_object<ton_api::adnl_address_udp6>(ip_, port_);
   }
   td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
-      td::actor::ActorId<AdnlNetworkManager> network_manager,
+      td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
+      std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override;
+};
+
+class AdnlAddressTunnel : public AdnlAddressImpl {
+ private:
+  AdnlNodeIdShort adnl_id_;
+  PublicKey pub_key_;
+
+ public:
+  explicit AdnlAddressTunnel(const ton_api::adnl_address_tunnel &obj);
+
+  AdnlAddressTunnel(AdnlNodeIdShort adnl_id, PublicKey pub_key)
+      : adnl_id_(std::move(adnl_id)), pub_key_(std::move(pub_key)) {
+  }
+
+  AdnlAddressTunnel *make_copy() const override {
+    return new AdnlAddressTunnel{*this};
+  }
+
+  bool is_public() const override {
+    return false;
+  }
+  td::uint32 serialized_size() const override {
+    return 4 + 32 + pub_key_.serialized_size();
+  }
+
+  tl_object_ptr<ton_api::adnl_Address> tl() const override {
+    return create_tl_object<ton_api::adnl_address_tunnel>(adnl_id_.bits256_value(), pub_key_.tl());
+  }
+  td::actor::ActorOwn<AdnlNetworkConnection> create_connection(
+      td::actor::ActorId<AdnlNetworkManager> network_manager, td::actor::ActorId<Adnl> adnl,
       std::unique_ptr<AdnlNetworkConnection::Callback> callback) const override;
 };
 

diff --git a/adnl/adnl-message.h b/adnl/adnl-message.h
@@ -249,6 +249,40 @@ class AdnlMessage {
   }
 };
 
+class OutboundAdnlMessage {
+ public:
+  template <class T>
+  OutboundAdnlMessage(T m, td::uint32 flags) : message_{std::move(m)}, flags_(flags) {
+  }
+  td::uint32 flags() const {
+    return flags_;
+  }
+  void set_flags(td::uint32 f) {
+    flags_ = f;
+  }
+  tl_object_ptr<ton_api::adnl_Message> tl() const {
+    return message_.tl();
+  }
+  td::uint32 size() const {
+    return message_.size();
+  }
+  template <class F>
+  void visit(F &&f) {
+    message_.visit(std::move(f));
+  }
+  template <class F>
+  void visit(F &&f) const {
+    message_.visit(std::move(f));
+  }
+  AdnlMessage release() {
+    return std::move(message_);
+  }
+
+ private:
+  AdnlMessage message_;
+  td::uint32 flags_;
+};
+
 class AdnlMessageList {
  public:
   AdnlMessageList() {
@@ -291,6 +325,48 @@ class AdnlMessageList {
   std::vector<AdnlMessage> messages_;
 };
 
+class OutboundAdnlMessageList {
+ public:
+  OutboundAdnlMessageList() {
+  }
+  OutboundAdnlMessageList(tl_object_ptr<ton_api::adnl_Message> message, td::uint32 flags) {
+    auto msg = OutboundAdnlMessage{std::move(message), flags};
+    messages_.emplace_back(std::move(msg));
+  }
+  OutboundAdnlMessageList(std::vector<tl_object_ptr<ton_api::adnl_Message>> messages, td::uint32 flags) {
+    for (auto &message : messages) {
+      messages_.push_back(OutboundAdnlMessage{std::move(message), flags});
+    }
+  }
+  void push_back(OutboundAdnlMessage message) {
+    messages_.push_back(std::move(message));
+  }
+
+  td::uint32 size() const {
+    return static_cast<td::uint32>(messages_.size());
+  }
+  tl_object_ptr<ton_api::adnl_Message> one_message() const {
+    CHECK(size() == 1);
+    return messages_[0].tl();
+  }
+  std::vector<tl_object_ptr<ton_api::adnl_Message>> mult_messages() const {
+    std::vector<tl_object_ptr<ton_api::adnl_Message>> vec;
+    for (auto &m : messages_) {
+      vec.emplace_back(m.tl());
+    }
+    return vec;
+  }
+  static std::vector<tl_object_ptr<ton_api::adnl_Message>> empty_vector() {
+    return std::vector<tl_object_ptr<ton_api::adnl_Message>>{};
+  }
+  auto &vector() {
+    return messages_;
+  }
+
+ private:
+  std::vector<OutboundAdnlMessage> messages_;
+};
+
 }  // namespace adnl
 
 }  // namespace ton
diff --git a/adnl/adnl-peer-table.cpp b/adnl/adnl-peer-table.cpp
@@ -138,7 +138,8 @@ void AdnlPeerTableImpl::add_static_nodes_from_config(AdnlNodesList nodes) {
   }
 }
 
-void AdnlPeerTableImpl::send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message) {
+void AdnlPeerTableImpl::send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message,
+                                        td::uint32 flags) {
   auto it = peers_.find(dst);
 
   if (it == peers_.end()) {
@@ -152,7 +153,7 @@ void AdnlPeerTableImpl::send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst
   }
 
   td::actor::send_closure(it->second, &AdnlPeer::send_one_message, src, it2->second.second, it2->second.first.get(),
-                          std::move(message));
+                          OutboundAdnlMessage{std::move(message), flags});
 }
 
 void AdnlPeerTableImpl::answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlQueryId query_id,
@@ -162,7 +163,7 @@ void AdnlPeerTableImpl::answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, A
                << "]: message too big: size=" << data.size();
     return;
   }
-  send_message_in(src, dst, adnlmessage::AdnlMessageAnswer{query_id, std::move(data)});
+  send_message_in(src, dst, adnlmessage::AdnlMessageAnswer{query_id, std::move(data)}, 0);
 }
 
 void AdnlPeerTableImpl::send_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, std::string name,
@@ -185,7 +186,7 @@ void AdnlPeerTableImpl::send_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, std
   }
 
   td::actor::send_closure(it->second, &AdnlPeer::send_query, src, it2->second.second, it2->second.first.get(), name,
-                          std::move(promise), timeout, std::move(data));
+                          std::move(promise), timeout, std::move(data), 0);
 }
 
 void AdnlPeerTableImpl::add_id_ex(AdnlNodeIdFull id, AdnlAddressList addr_list, td::uint32 mode) {

diff --git a/adnl/adnl-peer-table.h b/adnl/adnl-peer-table.h
@@ -91,7 +91,7 @@ class AdnlPeerTable : public Adnl {
 
   virtual void receive_packet(td::IPAddress addr, td::BufferSlice data) = 0;
   virtual void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket packet) = 0;
-  virtual void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message) = 0;
+  virtual void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message, td::uint32 flags) = 0;
 
   virtual void register_channel(AdnlChannelIdShort id, td::actor::ActorId<AdnlChannel> channel) = 0;
   virtual void unregister_channel(AdnlChannelIdShort id) = 0;

diff --git a/adnl/adnl-peer-table.hpp b/adnl/adnl-peer-table.hpp
@@ -45,14 +45,17 @@ class AdnlPeerTableImpl : public AdnlPeerTable {
 
   void receive_packet(td::IPAddress addr, td::BufferSlice data) override;
   void receive_decrypted_packet(AdnlNodeIdShort dst, AdnlPacket data) override;
-  void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message) override;
+  void send_message_in(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlMessage message, td::uint32 flags) override;
   void send_message(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data) override {
+    send_message_ex(src, dst, std::move(data), 0);
+  }
+  void send_message_ex(AdnlNodeIdShort src, AdnlNodeIdShort dst, td::BufferSlice data, td::uint32 flags) override {
     if (data.size() > huge_packet_max_size()) {
       VLOG(ADNL_WARNING) << "dropping too big packet [" << src << "->" << dst << "]: size=" << data.size();
       VLOG(ADNL_WARNING) << "DUMP: " << td::buffer_to_hex(data.as_slice().truncate(128));
       return;
     }
-    send_message_in(src, dst, AdnlMessage{adnlmessage::AdnlMessageCustom{std::move(data)}});
+    send_message_in(src, dst, AdnlMessage{adnlmessage::AdnlMessageCustom{std::move(data)}}, flags);
   }
   void answer_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, AdnlQueryId query_id, td::BufferSlice data) override;
   void send_query(AdnlNodeIdShort src, AdnlNodeIdShort dst, std::string name, td::Promise<td::BufferSlice> promise,