tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add NetQueryCreator::create_unauth.

Browse Source 
GitOrigin-RevId: 79043a3662b0353f000f388b3ee2763abf49fe2d
This commit is contained in:
levlam 2020-03-15 04:51:14 +03:00
parent c4c9e51157
commit 8d01251f8b
10 changed files with 56 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
td/telegram/AuthManager.cpp
View File

@ -175,9 +175,8 @@ void AuthManager::check_bot_token(uint64 query_id, string bot_token) {
bot_token_ = bot_token; bot_token_ = bot_token;
was_check_bot_token_ = true; was_check_bot_token_ = true;
start_net_query(NetQueryType::BotAuthentication, start_net_query(NetQueryType::BotAuthentication,
G()->net_query_creator().create( G()->net_query_creator().create_unauth(
create_storer(telegram_api::auth_importBotAuthorization(0, api_id_, api_hash_, bot_token_)), create_storer(telegram_api::auth_importBotAuthorization(0, api_id_, api_hash_, bot_token_))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::request_qr_code_authentication(uint64 query_id, vector<int32> other_user_ids) { void AuthManager::request_qr_code_authentication(uint64 query_id, vector<int32> other_user_ids) {
@ -215,9 +214,8 @@ void AuthManager::request_qr_code_authentication(uint64 query_id, vector<int32>
void AuthManager::send_export_login_token_query() { void AuthManager::send_export_login_token_query() {
poll_export_login_code_timeout_.cancel_timeout(); poll_export_login_code_timeout_.cancel_timeout();
start_net_query(NetQueryType::RequestQrCode, start_net_query(NetQueryType::RequestQrCode,
G()->net_query_creator().create(create_storer(telegram_api::auth_exportLoginToken( G()->net_query_creator().create_unauth(create_storer(
api_id_, api_hash_, vector<int32>(other_user_ids_))), telegram_api::auth_exportLoginToken(api_id_, api_hash_, vector<int32>(other_user_ids_)))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::set_login_token_expires_at(double login_token_expires_at) { void AuthManager::set_login_token_expires_at(double login_token_expires_at) {
@ -272,9 +270,8 @@ void AuthManager::set_phone_number(uint64 query_id, string phone_number,
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SendCode, start_net_query(NetQueryType::SendCode,
G()->net_query_creator().create( G()->net_query_creator().create_unauth(
create_storer(send_code_helper_.send_code(phone_number, settings, api_id_, api_hash_)), create_storer(send_code_helper_.send_code(phone_number, settings, api_id_, api_hash_))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::resend_authentication_code(uint64 query_id) { void AuthManager::resend_authentication_code(uint64 query_id) {
@ -290,8 +287,7 @@ void AuthManager::resend_authentication_code(uint64 query_id) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SendCode, start_net_query(NetQueryType::SendCode,
G()->net_query_creator().create(create_storer(r_resend_code.move_as_ok()), DcId::main(), G()->net_query_creator().create_unauth(create_storer(r_resend_code.move_as_ok())));
NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::check_code(uint64 query_id, string code) { void AuthManager::check_code(uint64 query_id, string code) {
@ -302,10 +298,8 @@ void AuthManager::check_code(uint64 query_id, string code) {
code_ = std::move(code); code_ = std::move(code);
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SignIn, start_net_query(NetQueryType::SignIn,
G()->net_query_creator().create( G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_signIn(
create_storer(telegram_api::auth_signIn(send_code_helper_.phone_number().str(), send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), code_))));
send_code_helper_.phone_code_hash().str(), code_)),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::register_user(uint64 query_id, string first_name, string last_name) { void AuthManager::register_user(uint64 query_id, string first_name, string last_name) {
@ -322,10 +316,8 @@ void AuthManager::register_user(uint64 query_id, string first_name, string last_
last_name = clean_name(last_name, MAX_NAME_LENGTH); last_name = clean_name(last_name, MAX_NAME_LENGTH);
start_net_query( start_net_query(
NetQueryType::SignUp, NetQueryType::SignUp,
G()->net_query_creator().create( G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_signUp(
create_storer(telegram_api::auth_signUp(send_code_helper_.phone_number().str(), send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), first_name, last_name))));
send_code_helper_.phone_code_hash().str(), first_name, last_name)),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::check_password(uint64 query_id, string password) { void AuthManager::check_password(uint64 query_id, string password) {
@ -337,8 +329,7 @@ void AuthManager::check_password(uint64 query_id, string password) {
on_new_query(query_id); on_new_query(query_id);
password_ = std::move(password); password_ = std::move(password);
start_net_query(NetQueryType::GetPassword, start_net_query(NetQueryType::GetPassword,
G()->net_query_creator().create(create_storer(telegram_api::account_getPassword()), DcId::main(), G()->net_query_creator().create_unauth(create_storer(telegram_api::account_getPassword())));
NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::request_password_recovery(uint64 query_id) { void AuthManager::request_password_recovery(uint64 query_id) {
@ -348,8 +339,7 @@ void AuthManager::request_password_recovery(uint64 query_id) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::RequestPasswordRecovery, start_net_query(NetQueryType::RequestPasswordRecovery,
G()->net_query_creator().create(create_storer(telegram_api::auth_requestPasswordRecovery()), G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_requestPasswordRecovery())));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::recover_password(uint64 query_id, string code) { void AuthManager::recover_password(uint64 query_id, string code) {
@ -359,8 +349,7 @@ void AuthManager::recover_password(uint64 query_id, string code) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::RecoverPassword, start_net_query(NetQueryType::RecoverPassword,
G()->net_query_creator().create(create_storer(telegram_api::auth_recoverPassword(code)), DcId::main(), G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_recoverPassword(code))));
NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::logout(uint64 query_id) { void AuthManager::logout(uint64 query_id) {
@ -391,8 +380,7 @@ void AuthManager::delete_account(uint64 query_id, const string &reason) {
on_new_query(query_id); on_new_query(query_id);
LOG(INFO) << "Deleting account"; LOG(INFO) << "Deleting account";
start_net_query(NetQueryType::DeleteAccount, start_net_query(NetQueryType::DeleteAccount,
G()->net_query_creator().create(create_storer(telegram_api::account_deleteAccount(reason)), G()->net_query_creator().create_unauth(create_storer(telegram_api::account_deleteAccount(reason))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void AuthManager::on_closing(bool destroy_flag) { void AuthManager::on_closing(bool destroy_flag) {
@ -525,9 +513,9 @@ void AuthManager::on_get_login_token(tl_object_ptr<telegram_api::auth_LoginToken
imported_dc_id_ = token->dc_id_; imported_dc_id_ = token->dc_id_;
start_net_query(NetQueryType::ImportQrCode, start_net_query(NetQueryType::ImportQrCode,
G()->net_query_creator().create( G()->net_query_creator().create_unauth(
create_storer(telegram_api::auth_importLoginToken(std::move(token->token_))), create_storer(telegram_api::auth_importLoginToken(std::move(token->token_))),
DcId::internal(token->dc_id_), NetQuery::Type::Common, NetQuery::AuthFlag::Off)); DcId::internal(token->dc_id_)));
break; break;
} }
case telegram_api::auth_loginTokenSuccess::ID: { case telegram_api::auth_loginTokenSuccess::ID: {
@ -582,10 +570,8 @@ void AuthManager::on_get_password_result(NetQueryPtr &result) {
return; return;
} else { } else {
start_net_query(NetQueryType::SignIn, start_net_query(NetQueryType::SignIn,
G()->net_query_creator().create( G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_signIn(
create_storer(telegram_api::auth_signIn(send_code_helper_.phone_number().str(), send_code_helper_.phone_number().str(), send_code_helper_.phone_code_hash().str(), code_))));
send_code_helper_.phone_code_hash().str(), code_)),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
return; return;
} }
@ -601,9 +587,8 @@ void AuthManager::on_get_password_result(NetQueryPtr &result) {
wait_password_state_.srp_g_, wait_password_state_.srp_p_, wait_password_state_.srp_g_, wait_password_state_.srp_p_,
wait_password_state_.srp_B_, wait_password_state_.srp_id_); wait_password_state_.srp_B_, wait_password_state_.srp_id_);
start_net_query(NetQueryType::CheckPassword, start_net_query(NetQueryType::CheckPassword, G()->net_query_creator().create_unauth(
G()->net_query_creator().create(create_storer(telegram_api::auth_checkPassword(std::move(hash))), create_storer(telegram_api::auth_checkPassword(std::move(hash)))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} else { } else {
update_state(State::WaitPassword); update_state(State::WaitPassword);
if (query_id_ != 0) { if (query_id_ != 0) {
@ -778,9 +763,8 @@ void AuthManager::on_result(NetQueryPtr result) {
CHECK(DcId::is_valid(imported_dc_id_)); CHECK(DcId::is_valid(imported_dc_id_));
dc_id = DcId::internal(imported_dc_id_); dc_id = DcId::internal(imported_dc_id_);
} }
start_net_query(NetQueryType::GetPassword, start_net_query(NetQueryType::GetPassword, G()->net_query_creator().create_unauth(
G()->net_query_creator().create(create_storer(telegram_api::account_getPassword()), dc_id, create_storer(telegram_api::account_getPassword()), dc_id));
NetQuery::Type::Common, NetQuery::AuthFlag::Off));
return; return;
} }
if (result->error().message() == CSlice("PHONE_NUMBER_BANNED")) { if (result->error().message() == CSlice("PHONE_NUMBER_BANNED")) {

9
td/telegram/ConfigManager.cpp
View File

@ -504,8 +504,7 @@ ActorOwn<> get_full_config(DcOption option, Promise<FullConfig> promise, ActorSh
int_dc_id, false /*is_main*/, true /*use_pfs*/, false /*is_cdn*/, int_dc_id, false /*is_main*/, true /*use_pfs*/, false /*is_cdn*/,
false /*need_destroy_auth_key*/, mtproto::AuthKey(), false /*need_destroy_auth_key*/, mtproto::AuthKey(),
std::vector<mtproto::ServerSalt>()); std::vector<mtproto::ServerSalt>());
auto query = G()->net_query_creator().create(create_storer(telegram_api::help_getConfig()), DcId::empty(), auto query = G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getConfig()), DcId::empty());
NetQuery::Type::Common, NetQuery::AuthFlag::Off);
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
query->set_callback(actor_shared(this)); query->set_callback(actor_shared(this));
query->dispatch_ttl = 0; query->dispatch_ttl = 0;
@ -932,8 +931,7 @@ void ConfigManager::get_app_config(Promise<td_api::object_ptr<td_api::JsonValue>
get_app_config_queries_.push_back(std::move(promise)); get_app_config_queries_.push_back(std::move(promise));
if (get_app_config_queries_.size() == 1) { if (get_app_config_queries_.size() == 1) {
auto query = G()->net_query_creator().create(create_storer(telegram_api::help_getAppConfig()), DcId::main(), auto query = G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getAppConfig()));
NetQuery::Type::Common, NetQuery::AuthFlag::Off);
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 1)); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 1));
} }
@ -991,8 +989,7 @@ void ConfigManager::on_dc_options_update(DcOptions dc_options) {
void ConfigManager::request_config_from_dc_impl(DcId dc_id) { void ConfigManager::request_config_from_dc_impl(DcId dc_id) {
config_sent_cnt_++; config_sent_cnt_++;
auto query = G()->net_query_creator().create(create_storer(telegram_api::help_getConfig()), dc_id, auto query = G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getConfig()), dc_id);
NetQuery::Type::Common, NetQuery::AuthFlag::Off);
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 0)); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, 0));
} }

28
td/telegram/LanguagePackManager.cpp
View File

@ -383,9 +383,8 @@ void LanguagePackManager::send_language_get_difference_query(Language *language,
std::move(language_code), result->version_, true, vector<string>(), std::move(result->strings_), std::move(language_code), result->version_, true, vector<string>(), std::move(result->strings_),
Promise<td_api::object_ptr<td_api::languagePackStrings>>()); Promise<td_api::object_ptr<td_api::languagePackStrings>>());
}); });
send_with_promise(G()->net_query_creator().create( send_with_promise(G()->net_query_creator().create_unauth(
create_storer(telegram_api::langpack_getDifference(language_pack_, language_code, version)), create_storer(telegram_api::langpack_getDifference(language_pack_, language_code, version))),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off),
std::move(request_promise)); std::move(request_promise));
} }
@ -798,9 +797,9 @@ void LanguagePackManager::get_languages(bool only_local,
send_closure(actor_id, &LanguagePackManager::on_get_languages, r_result.move_as_ok(), std::move(language_pack), send_closure(actor_id, &LanguagePackManager::on_get_languages, r_result.move_as_ok(), std::move(language_pack),
false, std::move(promise)); false, std::move(promise));
}); });
send_with_promise(G()->net_query_creator().create(create_storer(telegram_api::langpack_getLanguages(language_pack_)), send_with_promise(
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off), G()->net_query_creator().create_unauth(create_storer(telegram_api::langpack_getLanguages(language_pack_))),
std::move(request_promise)); std::move(request_promise));
} }
void LanguagePackManager::search_language_info(string language_code, void LanguagePackManager::search_language_info(string language_code,
@ -820,10 +819,9 @@ void LanguagePackManager::search_language_info(string language_code,
send_closure(actor_id, &LanguagePackManager::on_get_language, r_result.move_as_ok(), std::move(language_pack), send_closure(actor_id, &LanguagePackManager::on_get_language, r_result.move_as_ok(), std::move(language_pack),
std::move(language_code), std::move(promise)); std::move(language_code), std::move(promise));
}); });
send_with_promise( send_with_promise(G()->net_query_creator().create_unauth(
G()->net_query_creator().create(create_storer(telegram_api::langpack_getLanguage(language_pack_, language_code)), create_storer(telegram_api::langpack_getLanguage(language_pack_, language_code))),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off), std::move(request_promise));
std::move(request_promise));
} }
void LanguagePackManager::repair_chosen_language_info() { void LanguagePackManager::repair_chosen_language_info() {
@ -1082,9 +1080,8 @@ void LanguagePackManager::get_language_pack_strings(string language_code, vector
std::move(language_code), result->version_, false, vector<string>(), std::move(result->strings_), std::move(language_code), result->version_, false, vector<string>(), std::move(result->strings_),
std::move(promise)); std::move(promise));
}); });
send_with_promise(G()->net_query_creator().create( send_with_promise(G()->net_query_creator().create_unauth(
create_storer(telegram_api::langpack_getLangPack(language_pack_, language_code)), create_storer(telegram_api::langpack_getLangPack(language_pack_, language_code))),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off),
std::move(request_promise)); std::move(request_promise));
} else { } else {
auto request_promise = auto request_promise =
@ -1098,9 +1095,8 @@ void LanguagePackManager::get_language_pack_strings(string language_code, vector
send_closure(actor_id, &LanguagePackManager::on_get_language_pack_strings, std::move(language_pack), send_closure(actor_id, &LanguagePackManager::on_get_language_pack_strings, std::move(language_pack),
std::move(language_code), -1, false, std::move(keys), r_result.move_as_ok(), std::move(promise)); std::move(language_code), -1, false, std::move(keys), r_result.move_as_ok(), std::move(promise));
}); });
send_with_promise(G()->net_query_creator().create(create_storer(telegram_api::langpack_getStrings( send_with_promise(G()->net_query_creator().create_unauth(create_storer(
language_pack_, language_code, std::move(keys))), telegram_api::langpack_getStrings(language_pack_, language_code, std::move(keys)))),
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off),
std::move(request_promise)); std::move(request_promise));
} }
} }

3
td/telegram/Payments.cpp
View File

@ -527,8 +527,7 @@ class SendLiteRequestQuery : public Td::ResultHandler {
} }
void send(BufferSlice request) { void send(BufferSlice request) {
send_query(G()->net_query_creator().create(create_storer(telegram_api::wallet_sendLiteRequest(std::move(request))), send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::wallet_sendLiteRequest(std::move(request)))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {

3
td/telegram/PhoneNumberManager.cpp
View File

@ -91,8 +91,7 @@ void PhoneNumberManager::resend_authentication_code(uint64 query_id) {
on_new_query(query_id); on_new_query(query_id);
start_net_query(NetQueryType::SendCode, start_net_query(NetQueryType::SendCode,
G()->net_query_creator().create(create_storer(r_resend_code.move_as_ok()), DcId::main(), G()->net_query_creator().create_unauth(create_storer(r_resend_code.move_as_ok())));
NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
template <class T> template <class T>

14
td/telegram/Td.cpp
View File

@ -157,8 +157,7 @@ class GetNearestDcQuery : public Td::ResultHandler {
} }
void send() { void send() {
send_query(G()->net_query_creator().create(create_storer(telegram_api::help_getNearestDc()), DcId::main(), send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getNearestDc())));
NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {
@ -432,8 +431,7 @@ class GetDeepLinkInfoQuery : public Td::ResultHandler {
pos++; pos++;
} }
link.truncate(pos); link.truncate(pos);
send_query(G()->net_query_creator().create(create_storer(telegram_api::help_getDeepLinkInfo(link.str())), send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getDeepLinkInfo(link.str()))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {
@ -485,9 +483,8 @@ class SaveAppLogQuery : public Td::ResultHandler {
vector<telegram_api::object_ptr<telegram_api::inputAppEvent>> input_app_events; vector<telegram_api::object_ptr<telegram_api::inputAppEvent>> input_app_events;
input_app_events.push_back( input_app_events.push_back(
make_tl_object<telegram_api::inputAppEvent>(G()->server_time_cached(), type, peer_id, std::move(data))); make_tl_object<telegram_api::inputAppEvent>(G()->server_time_cached(), type, peer_id, std::move(data)));
send_query( send_query(G()->net_query_creator().create_unauth(
G()->net_query_creator().create(create_storer(telegram_api::help_saveAppLog(std::move(input_app_events))), create_storer(telegram_api::help_saveAppLog(std::move(input_app_events)))));
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {
@ -514,8 +511,7 @@ class TestQuery : public Td::ResultHandler {
} }
void send() { void send() {
send_query(G()->net_query_creator().create(create_storer(telegram_api::help_getConfig()), DcId::main(), send_query(G()->net_query_creator().create_unauth(create_storer(telegram_api::help_getConfig())));
NetQuery::Type::Common, NetQuery::AuthFlag::Off));
} }
void on_result(uint64 id, BufferSlice packet) override { void on_result(uint64 id, BufferSlice packet) override {

3
td/telegram/files/FileDownloader.cpp
View File

@ -466,8 +466,7 @@ Result<FileLoader::CheckInfo> FileDownloader::check_loop(int64 checked_prefix_si
auto query = auto query =
telegram_api::upload_getFileHashes(remote_.as_input_file_location(), narrow_cast<int32>(checked_prefix_size)); telegram_api::upload_getFileHashes(remote_.as_input_file_location(), narrow_cast<int32>(checked_prefix_size));
auto net_query_type = is_small_ ? NetQuery::Type::DownloadSmall : NetQuery::Type::Download; auto net_query_type = is_small_ ? NetQuery::Type::DownloadSmall : NetQuery::Type::Download;
auto net_query = G()->net_query_creator().create(create_storer(query), remote_.get_dc_id(), net_query_type, auto net_query = G()->net_query_creator().create(create_storer(query), remote_.get_dc_id(), net_query_type);
NetQuery::AuthFlag::On);
info.queries.push_back(std::move(net_query)); info.queries.push_back(std::move(net_query));
break; break;
} }

4
td/telegram/net/DcAuthManager.cpp
View File

@ -189,8 +189,8 @@ void DcAuthManager::dc_loop(DcInfo &dc) {
uint64 id = UniqueId::next(); uint64 id = UniqueId::next();
VLOG(dc) << "Send importAuthorization to " << dc.dc_id; VLOG(dc) << "Send importAuthorization to " << dc.dc_id;
auto query = G()->net_query_creator().create( auto query = G()->net_query_creator().create(
id, create_storer(telegram_api::auth_importAuthorization(dc.export_id, std::move(dc.export_bytes))), dc.dc_id, id, create_storer(telegram_api::auth_importAuthorization(dc.export_id, std::move(dc.export_bytes))),
NetQuery::Type::Common, NetQuery::AuthFlag::Off); dc.dc_id, NetQuery::Type::Common, NetQuery::AuthFlag::Off);
query->total_timeout_limit = 60 * 60 * 24; query->total_timeout_limit = 60 * 60 * 24;
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, dc.dc_id.get_raw_id())); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, dc.dc_id.get_raw_id()));
dc.wait_id = id; dc.wait_id = id;

9
td/telegram/net/NetQueryCreator.h
View File

@ -34,9 +34,12 @@ class NetQueryCreator {
NetQuery::Type::Common, NetQuery::AuthFlag::On, NetQuery::GzipFlag::Off, 0); NetQuery::Type::Common, NetQuery::AuthFlag::On, NetQuery::GzipFlag::Off, 0);
} }
Ptr create(const Storer &storer, DcId dc_id = DcId::main(), NetQuery::Type type = NetQuery::Type::Common, Ptr create(const Storer &storer, DcId dc_id = DcId::main(), NetQuery::Type type = NetQuery::Type::Common) {
NetQuery::AuthFlag auth_flag = NetQuery::AuthFlag::On) { return create(UniqueId::next(), storer, dc_id, type, NetQuery::AuthFlag::On);
return create(UniqueId::next(), storer, dc_id, type, auth_flag); }
Ptr create_unauth(const Storer &storer, DcId dc_id = DcId::main()) {
return create(UniqueId::next(), storer, dc_id, NetQuery::Type::Common, NetQuery::AuthFlag::Off);
} }
Ptr create(uint64 id, const Storer &storer, DcId dc_id, NetQuery::Type type, NetQuery::AuthFlag auth_flag); Ptr create(uint64 id, const Storer &storer, DcId dc_id, NetQuery::Type type, NetQuery::AuthFlag auth_flag);

4
td/telegram/net/TempAuthKeyWatchdog.h
View File

@ -111,8 +111,8 @@ class TempAuthKeyWatchdog : public NetQueryCallback {
return; return;
} }
LOG(WARNING) << "Start auth_dropTempAuthKeys except keys " << format::as_array(ids); LOG(WARNING) << "Start auth_dropTempAuthKeys except keys " << format::as_array(ids);
auto query = G()->net_query_creator().create(create_storer(telegram_api::auth_dropTempAuthKeys(std::move(ids))), auto query =
DcId::main(), NetQuery::Type::Common, NetQuery::AuthFlag::Off); G()->net_query_creator().create_unauth(create_storer(telegram_api::auth_dropTempAuthKeys(std::move(ids))));
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this)); G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this));
} }