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

Revert "Process adnl query errors"

Browse source 
This reverts commit 1869a25062.
This commit is contained in:
SpyCheese 2024-03-15 14:13:07 +03:00
parent e216651112
commit fc6e2ead29
10 changed files with 1 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

3
adnl/adnl-message.cpp
View file

@ -46,9 +46,6 @@ AdnlMessage::AdnlMessage(tl_object_ptr<ton_api::adnl_Message> message) {
[&](ton_api::adnl_message_part &msg) {
message_ = adnlmessage::AdnlMessagePart{msg.hash_, static_cast<td::uint32>(msg.total_size_),
static_cast<td::uint32>(msg.offset_), std::move(msg.data_)};
},
[&](ton_api::adnl_message_queryError &msg) {
message_ = adnlmessage::AdnlMessageQueryError{msg.query_id_};
}));
}

21
adnl/adnl-message.h
View file

@ -170,24 +170,6 @@ class AdnlMessageAnswer {
td::BufferSlice data_;
};
class AdnlMessageQueryError {
public:
explicit AdnlMessageQueryError(AdnlQueryId query_id) : query_id_(query_id) {
}
const auto &query_id() const {
return query_id_;
}
td::uint32 size() const {
return 36;
}
tl_object_ptr<ton_api::adnl_Message> tl() const {
return create_tl_object<ton_api::adnl_message_queryError>(query_id_);
}
private:
AdnlQueryId query_id_;
};
class AdnlMessagePart {
public:
AdnlMessagePart(td::Bits256 hash, td::uint32 total_size, td::uint32 offset, td::BufferSlice data)
@ -238,8 +220,7 @@ class AdnlMessage {
private:
td::Variant<Empty, adnlmessage::AdnlMessageCreateChannel, adnlmessage::AdnlMessageConfirmChannel,
adnlmessage::AdnlMessageCustom, adnlmessage::AdnlMessageNop, adnlmessage::AdnlMessageReinit,
adnlmessage::AdnlMessageQuery, adnlmessage::AdnlMessageAnswer, adnlmessage::AdnlMessagePart,
adnlmessage::AdnlMessageQueryError>
adnlmessage::AdnlMessageQuery, adnlmessage::AdnlMessageAnswer, adnlmessage::AdnlMessagePart>
message_{Empty{}};
public:

16
adnl/adnl-peer.cpp
View file

@ -536,14 +536,10 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &mess
flags = static_cast<td::uint32>(0)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
LOG(WARNING) << "failed to answer query: " << R.move_as_error();
td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_message,
OutboundAdnlMessage{adnlmessage::AdnlMessageQueryError{query_id}, flags});
} else {
auto data = R.move_as_ok();
if (data.size() > Adnl::huge_packet_max_size()) {
LOG(WARNING) << "dropping too big answer query: size=" << data.size();
td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_message,
OutboundAdnlMessage{adnlmessage::AdnlMessageQueryError{query_id}, flags});
} else {
td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_message,
OutboundAdnlMessage{adnlmessage::AdnlMessageAnswer{query_id, std::move(data)}, flags});
@ -625,18 +621,6 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessagePart &messa
}
}
void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQueryError &message) {
auto Q = out_queries_.find(message.query_id());
if (Q == out_queries_.end()) {
VLOG(ADNL_NOTICE) << this << ": dropping IN query error: unknown query id " << message.query_id();
return;
}
td::actor::send_closure_later(Q->second, &AdnlQuery::set_error, td::Status::Error("adnl query rejected"));
out_queries_.erase(Q);
}
void AdnlPeerPairImpl::delete_query(AdnlQueryId id) {
auto Q = out_queries_.find(id);

1
adnl/adnl-peer.hpp
View file

@ -104,7 +104,6 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
void process_message(const adnlmessage::AdnlMessageQuery &message);
void process_message(const adnlmessage::AdnlMessageAnswer &message);
void process_message(const adnlmessage::AdnlMessagePart &message);
void process_message(const adnlmessage::AdnlMessageQueryError &message);
void process_message(const AdnlMessage::Empty &message) {
UNREACHABLE();
}

4
rldp/rldp-in.hpp
View file

@ -78,8 +78,6 @@ class RldpIn : public RldpImpl {
td::uint64 max_answer_size) override;
void answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
adnl::AdnlQueryId query_id, TransferId transfer_id, td::BufferSlice data);
void reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
adnl::AdnlQueryId query_id, TransferId transfer_id);
void alarm_query(adnl::AdnlQueryId query_id, TransferId transfer_id);
@ -95,8 +93,6 @@ class RldpIn : public RldpImpl {
ton_api::rldp_query &message);
void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
ton_api::rldp_answer &message);
void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
ton_api::rldp_queryError &message);
void receive_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
td::BufferSlice data);

22
rldp/rldp.cpp
View file

@ -87,13 +87,6 @@ void RldpIn::answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst,
transfer(src, dst, timeout, std::move(B), transfer_id);
}
void RldpIn::reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
adnl::AdnlQueryId query_id, TransferId transfer_id) {
auto B = serialize_tl_object(create_tl_object<ton_api::rldp_queryError>(query_id), true);
transfer(src, dst, timeout, std::move(B), transfer_id);
}
void RldpIn::alarm_query(adnl::AdnlQueryId query_id, TransferId transfer_id) {
queries_.erase(query_id);
max_size_.erase(transfer_id);
@ -206,16 +199,12 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
auto data = R.move_as_ok();
if (data.size() > max_answer_size) {
VLOG(RLDP_NOTICE) << "rldp query failed: answer too big";
td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
transfer_id ^ TransferId::ones());
} else {
td::actor::send_closure(SelfId, &RldpIn::answer_query, local_id, source, timeout, query_id,
transfer_id ^ TransferId::ones(), std::move(data));
}
} else {
VLOG(RLDP_NOTICE) << "rldp query failed: " << R.move_as_error();
td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
transfer_id ^ TransferId::ones());
}
});
VLOG(RLDP_DEBUG) << "delivering rldp query";
@ -234,17 +223,6 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
}
}
void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
ton_api::rldp_queryError &message) {
auto it = queries_.find(message.query_id_);
if (it != queries_.end()) {
td::actor::send_closure(it->second, &adnl::AdnlQuery::set_error, td::Status::Error("adnl query rejected"));
queries_.erase(it);
} else {
VLOG(RLDP_INFO) << "received reject to unknown query " << message.query_id_;
}
}
void RldpIn::transfer_completed(TransferId transfer_id) {
senders_.erase(transfer_id);
VLOG(RLDP_DEBUG) << "rldp: completed transfer " << transfer_id << "; " << senders_.size() << " out transfer pending ";

4
rldp2/rldp-in.hpp
View file

@ -76,8 +76,6 @@ class RldpIn : public RldpImpl {
td::uint64 max_answer_size) override;
void answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
adnl::AdnlQueryId query_id, TransferId transfer_id, td::BufferSlice data);
void reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
adnl::AdnlQueryId query_id, TransferId transfer_id);
void receive_message_part(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, td::BufferSlice data);
@ -87,8 +85,6 @@ class RldpIn : public RldpImpl {
ton_api::rldp_query &message);
void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
ton_api::rldp_answer &message);
void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
ton_api::rldp_queryError &message);
void receive_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
td::Result<td::BufferSlice> data);

22
rldp2/rldp.cpp
View file

@ -121,13 +121,6 @@ void RldpIn::answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst,
send_closure(create_connection(src, dst), &RldpConnectionActor::send, transfer_id, std::move(B), timeout);
}
void RldpIn::reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
adnl::AdnlQueryId query_id, TransferId transfer_id) {
auto B = serialize_tl_object(create_tl_object<ton_api::rldp_queryError>(query_id), true);
send_closure(create_connection(src, dst), &RldpConnectionActor::send, transfer_id, std::move(B), timeout);
}
void RldpIn::receive_message_part(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, td::BufferSlice data) {
send_closure(create_connection(local_id, source), &RldpConnectionActor::receive_raw, std::move(data));
}
@ -187,16 +180,12 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
auto data = R.move_as_ok();
if (data.size() > max_answer_size) {
VLOG(RLDP_NOTICE) << "rldp query failed: answer too big";
td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
transfer_id ^ TransferId::ones());
} else {
td::actor::send_closure(SelfId, &RldpIn::answer_query, local_id, source, timeout, query_id,
transfer_id ^ TransferId::ones(), std::move(data));
}
} else {
VLOG(RLDP_NOTICE) << "rldp query failed: " << R.move_as_error();
td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
transfer_id ^ TransferId::ones());
}
});
VLOG(RLDP_DEBUG) << "delivering rldp query";
@ -215,17 +204,6 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
}
}
void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
ton_api::rldp_queryError &message) {
auto it = queries_.find(transfer_id);
if (it != queries_.end()) {
it->second.set_error(td::Status::Error("rejected"));
queries_.erase(it);
} else {
VLOG(RLDP_INFO) << "received reject to unknown query " << message.query_id_;
}
}
void RldpIn::on_sent(TransferId transfer_id, td::Result<td::Unit> state) {
//TODO: completed transfer
}

2
tl/generate/scheme/ton_api.tl
View file

@ -137,7 +137,6 @@ adnl.message.reinit date:int = adnl.Message;
adnl.message.query query_id:int256 query:bytes = adnl.Message;
adnl.message.answer query_id:int256 answer:bytes = adnl.Message;
adnl.message.queryError query_id:int256 = adnl.Message;
adnl.message.part hash:int256 total_size:int offset:int data:bytes = adnl.Message;
@ -163,7 +162,6 @@ rldp.complete transfer_id:int256 part:int = rldp.MessagePart;
rldp.message id:int256 data:bytes = rldp.Message;
rldp.query query_id:int256 max_answer_size:long timeout:int data:bytes = rldp.Message;
rldp.answer query_id:int256 data:bytes = rldp.Message;
rldp.queryError query_id:int256 = rldp.Message;
---functions---

BIN
tl/generate/scheme/ton_api.tlo
View file

Binary file not shown.