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

Update DNS resolver in liteclient and tonlib

Browse source
This commit is contained in:
SpyCheese 2022-06-29 12:30:19 +03:00 • committed by EmelyanenkoK
parent 7e3df93ca2
commit 7e207dc78f
14 changed files with 278 additions and 237 deletions
Download patch file Download diff file Expand all files Collapse all files

12
tonlib/test/online.cpp
View file

@ -594,7 +594,8 @@ void dns_resolve(Client& client, const Wallet& dns, std::string name) {
using namespace ton::tonlib_api;
auto address = dns.get_address();
auto resolved =
sync_send(client, make_object<::ton::tonlib_api::dns_resolve>(std::move(address), name, 1, 4)).move_as_ok();
sync_send(client, make_object<::ton::tonlib_api::dns_resolve>(
std::move(address), name, td::sha256_bits256(td::Slice("cat", 3)), 4)).move_as_ok();
CHECK(resolved->entries_.size() == 1);
LOG(INFO) << to_string(resolved);
LOG(INFO) << "OK";
@ -747,13 +748,16 @@ void test_dns(Client& client, const Wallet& giver_wallet) {
std::vector<object_ptr<dns_Action>> actions;
actions.push_back(make_object<dns_actionSet>(
make_object<dns_entry>("A", -1, make_object<dns_entryDataNextResolver>(A_B.get_address()))));
make_object<dns_entry>("A", ton::DNS_NEXT_RESOLVER_CATEGORY,
make_object<dns_entryDataNextResolver>(A_B.get_address()))));
auto init_A = create_update_dns_query(client, A, std::move(actions)).move_as_ok();
actions.push_back(make_object<dns_actionSet>(
make_object<dns_entry>("B", -1, make_object<dns_entryDataNextResolver>(A_B_C.get_address()))));
make_object<dns_entry>("B", ton::DNS_NEXT_RESOLVER_CATEGORY,
make_object<dns_entryDataNextResolver>(A_B_C.get_address()))));
auto init_A_B = create_update_dns_query(client, A_B, std::move(actions)).move_as_ok();
actions.push_back(
make_object<dns_actionSet>(make_object<dns_entry>("C", 1, make_object<dns_entryDataText>("Hello dns"))));
make_object<dns_actionSet>(make_object<dns_entry>("C", td::sha256_bits256(td::Slice("cat", 3)),
make_object<dns_entryDataText>("Hello dns"))));
auto init_A_B_C = create_update_dns_query(client, A_B_C, std::move(actions)).move_as_ok();
LOG(INFO) << "Send dns init queries";

46
tonlib/tonlib/TonlibClient.cpp
View file

@ -2623,11 +2623,10 @@ class GenericCreateSendGrams : public TonlibQueryActor {
return downcast_call2<R>(action,
td::overloaded(
[&](tonlib_api::dns_actionDeleteAll& del_all) -> R {
return ton::ManualDns::Action{"", 0, {}};
return ton::ManualDns::Action{"", td::Bits256::zero(), {}};
},
[&](tonlib_api::dns_actionDelete& del) -> R {
TRY_RESULT(category, td::narrow_cast_safe<td::int16>(del.category_));
return ton::ManualDns::Action{del.name_, category, {}};
return ton::ManualDns::Action{del.name_, del.category_, {}};
},
[&](tonlib_api::dns_actionSet& set) -> R {
if (!set.entry_) {
@ -2636,10 +2635,10 @@ class GenericCreateSendGrams : public TonlibQueryActor {
if (!set.entry_->entry_) {
return TonlibError::EmptyField("entry.entry");
}
TRY_RESULT(category, td::narrow_cast_safe<td::int16>(set.entry_->category_));
TRY_RESULT(entry_data, to_dns_entry_data(*set.entry_->entry_));
TRY_RESULT(data_cell, entry_data.as_cell());
return ton::ManualDns::Action{set.entry_->name_, category, std::move(data_cell)};
return ton::ManualDns::Action{set.entry_->name_, set.entry_->category_,
std::move(data_cell)};
}));
}
@ -3629,30 +3628,30 @@ td::Result<tonlib_api::object_ptr<tonlib_api::dns_EntryData>> to_tonlib_api(
return res;
}
void TonlibClient::finish_dns_resolve(std::string name, td::int32 category, td::int32 ttl,
td::optional<ton::BlockIdExt> block_id, DnsFinishData dns_finish_data,
void TonlibClient::finish_dns_resolve(std::string name, td::Bits256 category, td::int32 ttl,
td::optional<ton::BlockIdExt> block_id, block::StdAddress address,
DnsFinishData dns_finish_data,
td::Promise<object_ptr<tonlib_api::dns_resolved>>&& promise) {
block_id = dns_finish_data.block_id;
// TODO: check if the smartcontract supports Dns interface
// TODO: should we use some DnsInterface instead of ManualDns?
auto dns = ton::ManualDns::create(dns_finish_data.smc_state);
auto dns = ton::ManualDns::create(dns_finish_data.smc_state, std::move(address));
TRY_RESULT_PROMISE(promise, entries, dns->resolve(name, category));
if (entries.size() == 1 && entries[0].category == -1 && entries[0].name != name && ttl > 0 &&
entries[0].data.type == ton::ManualDns::EntryData::Type::NextResolver) {
if (entries.size() == 1 && entries[0].partially_resolved && ttl > 0) {
td::Slice got_name = entries[0].name;
if (got_name.size() >= name.size()) {
if (got_name.size() > name.size()) {
TRY_STATUS_PROMISE(promise, TonlibError::Internal("domain is too long"));
}
auto dot_position = name.size() - got_name.size() - 1;
auto suffix = name.substr(dot_position + 1);
auto prefix = name.substr(0, dot_position);
if (name[dot_position] != '.') {
TRY_STATUS_PROMISE(promise, td::Status::Error("next resolver error: domain split not at a component boundary "));
}
auto suffix_start = name.size() - got_name.size();
auto suffix = name.substr(suffix_start);
if (suffix != got_name) {
TRY_STATUS_PROMISE(promise, TonlibError::Internal("domain is not a suffix of the query"));
}
auto prefix = name.substr(0, suffix_start);
if (!prefix.empty() && prefix.back() != '.' && suffix[0] != '.') {
TRY_STATUS_PROMISE(promise, td::Status::Error("next resolver error: domain split not at a component boundary "));
}
auto address = entries[0].data.data.get<ton::ManualDns::EntryDataNextResolver>().resolver;
return do_dns_request(prefix, category, ttl - 1, std::move(block_id), address, std::move(promise));
@ -3667,12 +3666,13 @@ void TonlibClient::finish_dns_resolve(std::string name, td::int32 category, td::
promise.set_value(tonlib_api::make_object<tonlib_api::dns_resolved>(std::move(api_entries)));
}
void TonlibClient::do_dns_request(std::string name, td::int32 category, td::int32 ttl,
void TonlibClient::do_dns_request(std::string name, td::Bits256 category, td::int32 ttl,
td::optional<ton::BlockIdExt> block_id, block::StdAddress address,
td::Promise<object_ptr<tonlib_api::dns_resolved>>&& promise) {
auto block_id_copy = block_id.copy();
td::Promise<DnsFinishData> new_promise =
promise.send_closure(actor_id(this), &TonlibClient::finish_dns_resolve, name, category, ttl, std::move(block_id));
promise.send_closure(actor_id(this), &TonlibClient::finish_dns_resolve, name, category, ttl, std::move(block_id),
address);
if (0) {
make_request(int_api::GetAccountState{address, std::move(block_id_copy), {}},
@ -3683,7 +3683,7 @@ void TonlibClient::do_dns_request(std::string name, td::int32 category, td::int3
return;
}
TRY_RESULT_PROMISE(promise, args, ton::DnsInterface::resolve_args(name, category));
TRY_RESULT_PROMISE(promise, args, ton::DnsInterface::resolve_args(name, category, address));
int_api::RemoteRunSmcMethod query;
query.address = std::move(address);
query.args = std::move(args);
@ -3705,8 +3705,12 @@ td::Status TonlibClient::do_request(const tonlib_api::dns_resolve& request,
request.ttl_, std::move(block_id)));
return td::Status::OK();
}
std::string name = request.name_;
if (name.empty() || name.back() != '.') {
name += '.';
}
TRY_RESULT(account_address, get_account_address(request.account_address_->account_address_));
do_dns_request(request.name_, request.category_, request.ttl_, std::move(block_id), account_address,
do_dns_request(name, request.category_, request.ttl_, std::move(block_id), account_address,
std::move(promise));
return td::Status::OK();
}

7
tonlib/tonlib/TonlibClient.h
View file

@ -325,14 +325,15 @@ class TonlibClient : public td::actor::Actor {
void perform_smc_execution(td::Ref<ton::SmartContract> smc, ton::SmartContract::Args args,
td::Promise<object_ptr<tonlib_api::smc_runResult>>&& promise);
void do_dns_request(std::string name, td::int32 category, td::int32 ttl, td::optional<ton::BlockIdExt> block_id,
void do_dns_request(std::string name, td::Bits256 category, td::int32 ttl, td::optional<ton::BlockIdExt> block_id,
block::StdAddress address, td::Promise<object_ptr<tonlib_api::dns_resolved>>&& promise);
struct DnsFinishData {
ton::BlockIdExt block_id;
ton::SmartContract::State smc_state;
};
void finish_dns_resolve(std::string name, td::int32 category, td::int32 ttl, td::optional<ton::BlockIdExt> block_id,
DnsFinishData dns_finish_data, td::Promise<object_ptr<tonlib_api::dns_resolved>>&& promise);
void finish_dns_resolve(std::string name, td::Bits256 category, td::int32 ttl, td::optional<ton::BlockIdExt> block_id,
block::StdAddress address, DnsFinishData dns_finish_data,
td::Promise<object_ptr<tonlib_api::dns_resolved>>&& promise);
td::Status do_request(int_api::GetAccountState request, td::Promise<td::unique_ptr<AccountState>>&&);
td::Status do_request(int_api::GetPrivateKey request, td::Promise<KeyStorage::PrivateKey>&&);

15
tonlib/tonlib/tonlib-cli.cpp
View file

@ -1162,7 +1162,7 @@ class TonlibCli : public td::actor::Actor {
promise.set_error(td::Status::Error("Unknown command"));
}
void do_dns_resolve(std::string name, td::int16 category, td::int32 ttl,
void do_dns_resolve(std::string name, td::Bits256 category, td::int32 ttl,
tonlib_api::object_ptr<tonlib_api::dns_resolved> resolved, td::Promise<td::Unit> promise) {
if (resolved->entries_.empty()) {
td::TerminalIO::out() << "No dns entries found\n";
@ -1192,11 +1192,12 @@ class TonlibCli : public td::actor::Actor {
TRY_RESULT_PROMISE(promise, address, to_account_address(key_id, false));
auto name = parser.read_word();
auto category_str = parser.read_word();
TRY_RESULT_PROMISE(promise, category, td::to_integer_safe<td::int16>(category_str));
td::Bits256 category = category_str.empty() ? td::Bits256::zero() : td::sha256_bits256(td::as_slice(category_str));
std::vector<tonlib_api::object_ptr<tonlib_api::dns_entry>> entries;
entries.push_back(make_object<tonlib_api::dns_entry>(
"", -1, make_object<tonlib_api::dns_entryDataNextResolver>(std::move(address.address))));
"", ton::DNS_NEXT_RESOLVER_CATEGORY,
make_object<tonlib_api::dns_entryDataNextResolver>(std::move(address.address))));
do_dns_resolve(name.str(), category, 10, make_object<tonlib_api::dns_resolved>(std::move(entries)),
std::move(promise));
}
@ -1217,8 +1218,8 @@ class TonlibCli : public td::actor::Actor {
if (action.name.empty()) {
actions.push_back(make_object<tonlib_api::dns_actionDeleteAll>());
td::TerminalIO::out() << "Delete all dns entries\n";
} else if (action.category == 0) {
actions.push_back(make_object<tonlib_api::dns_actionDelete>(action.name, 0));
} else if (action.category.is_zero()) {
actions.push_back(make_object<tonlib_api::dns_actionDelete>(action.name, td::Bits256::zero()));
td::TerminalIO::out() << "Delete all dns enties with name: " << action.name << "\n";
} else if (!action.data) {
actions.push_back(make_object<tonlib_api::dns_actionDelete>(action.name, action.category));
@ -1234,8 +1235,8 @@ class TonlibCli : public td::actor::Actor {
TRY_RESULT_PROMISE(promise, data, tonlib::to_tonlib_api(action.data.value()));
sb << action.data.value();
TRY_STATUS_PROMISE(promise, std::move(error));
td::TerminalIO::out() << "Set dns entry: " << action.name << ":" << action.category << " " << sb.as_cslice()
<< "\n";
td::TerminalIO::out() << "Set dns entry: " << action.name << ":" << action.category << " "
<< sb.as_cslice() << "\n";
actions.push_back(make_object<tonlib_api::dns_actionSet>(
make_object<tonlib_api::dns_entry>(action.name, action.category, std::move(data))));
}