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

Add dummy td_api::getCurrentState.

Browse Source 
GitOrigin-RevId: 31ea0cfdc0c715fec52ef27340bed7358b13e042
This commit is contained in:
levlam 2018-09-20 19:33:41 +03:00
parent 2c5ce9591d
commit db14b2da4e
7 changed files with 91 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
td/generate/scheme/td_api.tl
View File

@ -2310,6 +2310,10 @@ updateNewCustomEvent event:string = Update;
updateNewCustomQuery id:int64 data:string timeout:int32 = Update;
//@description Contains a list of updated @updates List of updates
updates updates:vector<Update> = Updates;
//@description A simple object containing a number; for testing only @value Number
testInt value:int32 = TestInt;
//@description A simple object containing a string; for testing only @value String
@ -2370,6 +2374,10 @@ close = Ok;
destroy = Ok;
//@description Returns all updates needed to restore current TDLib state, i.e. all actual UpdateAuthorizationState/UpdateUser/UpdateNewChat and others. This is especially usefull if TDLib is run in a separate process
getCurrentState = Updates;
//@description Changes the database encryption key. Usually the encryption key is never changed and is stored in some OS keychain @new_encryption_key New encryption key
setDatabaseEncryptionKey new_encryption_key:bytes = Ok;

BIN
td/generate/scheme/td_api.tlo
View File

Binary file not shown.

8
td/telegram/AuthManager.cpp
View File

@ -485,6 +485,14 @@ tl_object_ptr<td_api::AuthorizationState> AuthManager::get_authorization_state_o
}
}
tl_object_ptr<td_api::AuthorizationState> AuthManager::get_current_authorization_state_object() const {
if (state_ == State::None) {
return nullptr;
} else {
return get_authorization_state_object(state_);
}
}
void AuthManager::get_state(uint64 query_id) {
if (state_ == State::None) {
pending_get_authorization_state_requests_.push_back(query_id);

3
td/telegram/AuthManager.h
View File

@ -168,6 +168,9 @@ class AuthManager : public NetActor {
void on_closing();
// can return nullptr if state isn't initialized yet
tl_object_ptr<td_api::AuthorizationState> get_current_authorization_state_object() const;
private:
static constexpr size_t MAX_NAME_LENGTH = 64; // server side limit

100
td/telegram/Td.cpp
View File

@ -3243,6 +3243,7 @@ bool Td::is_synchronous_request(int32 id) {
bool Td::is_preinitialization_request(int32 id) {
switch (id) {
case td_api::getCurrentState::ID:
case td_api::setAlarm::ID:
case td_api::testUseUpdate::ID:
case td_api::testUseError::ID:
@ -3293,6 +3294,27 @@ bool Td::is_preauthentication_request(int32 id) {
}
}
td_api::object_ptr<td_api::AuthorizationState> Td::get_fake_authorization_state_object() const {
switch (state_) {
case State::WaitParameters:
return td_api::make_object<td_api::authorizationStateWaitTdlibParameters>();
case State::Decrypt:
return td_api::make_object<td_api::authorizationStateWaitEncryptionKey>(encryption_info_.is_encrypted);
case State::Run:
UNREACHABLE();
return nullptr;
case State::Close:
if (close_flag_ == 5) {
return td_api::make_object<td_api::authorizationStateClosed>();
} else {
return td_api::make_object<td_api::authorizationStateClosing>();
}
default:
UNREACHABLE();
return nullptr;
}
}
void Td::request(uint64 id, tl_object_ptr<td_api::Function> function) {
if (id == 0) {
LOG(ERROR) << "Ignore request with id == 0: " << to_string(function);
@ -3307,21 +3329,37 @@ void Td::request(uint64 id, tl_object_ptr<td_api::Function> function) {
VLOG(td_requests) << "Receive request " << id << ": " << to_string(function);
int32 function_id = function->get_id();
if (is_synchronous_request(function_id)) {
// send response synchronously
return send_result(id, static_request(std::move(function)));
}
if (state_ != State::Run) {
switch (function_id) {
case td_api::getAuthorizationState::ID:
// send response synchronously to prevent "Request aborted"
return send_result(id, get_fake_authorization_state_object());
case td_api::getCurrentState::ID: {
vector<td_api::object_ptr<td_api::Update>> updates;
updates.push_back(td_api::make_object<td_api::updateAuthorizationState>(get_fake_authorization_state_object()));
// send response synchronously to prevent "Request aborted"
return send_result(id, td_api::make_object<td_api::updates>(std::move(updates)));
}
case td_api::close::ID:
// need to send response synchronously before actual closing
send_result(id, td_api::make_object<td_api::ok>());
return close();
default:
break;
}
}
switch (state_) {
case State::WaitParameters: {
switch (function_id) {
case td_api::getAuthorizationState::ID:
return send_closure(actor_id(this), &Td::send_result, id,
td_api::make_object<td_api::authorizationStateWaitTdlibParameters>());
case td_api::setTdlibParameters::ID:
return answer_ok_query(
id, set_parameters(std::move(move_tl_object_as<td_api::setTdlibParameters>(function)->parameters_)));
case td_api::close::ID:
return close();
case td_api::destroy::ID:
return destroy();
default:
if (is_synchronous_request(function_id) || is_preinitialization_request(function_id)) {
if (is_preinitialization_request(function_id)) {
break;
}
if (is_preauthentication_request(function_id)) {
@ -3335,10 +3373,6 @@ void Td::request(uint64 id, tl_object_ptr<td_api::Function> function) {
case State::Decrypt: {
string encryption_key;
switch (function_id) {
case td_api::getAuthorizationState::ID:
return send_closure(
actor_id(this), &Td::send_result, id,
td_api::make_object<td_api::authorizationStateWaitEncryptionKey>(encryption_info_.is_encrypted));
case td_api::checkDatabaseEncryptionKey::ID: {
auto check_key = move_tl_object_as<td_api::checkDatabaseEncryptionKey>(function);
encryption_key = std::move(check_key->encryption_key_);
@ -3349,12 +3383,12 @@ void Td::request(uint64 id, tl_object_ptr<td_api::Function> function) {
encryption_key = std::move(set_key->new_encryption_key_);
break;
}
case td_api::close::ID:
return close();
case td_api::destroy::ID:
// need to send response synchronously before actual destroying
send_result(id, td_api::make_object<td_api::ok>());
return destroy();
default:
if (is_synchronous_request(function_id) || is_preinitialization_request(function_id)) {
if (is_preinitialization_request(function_id)) {
break;
}
if (is_preauthentication_request(function_id)) {
@ -3365,28 +3399,14 @@ void Td::request(uint64 id, tl_object_ptr<td_api::Function> function) {
}
return answer_ok_query(id, init(as_db_key(encryption_key)));
}
case State::Close: {
if (function_id == td_api::getAuthorizationState::ID) {
if (close_flag_ == 5) {
return send_closure(actor_id(this), &Td::send_result, id,
td_api::make_object<td_api::authorizationStateClosed>());
} else {
return send_closure(actor_id(this), &Td::send_result, id,
td_api::make_object<td_api::authorizationStateClosing>());
}
}
if (is_synchronous_request(function_id)) {
break;
}
case State::Close:
return send_error_raw(id, 401, "Unauthorized");
}
case State::Run:
break;
}
if ((auth_manager_ == nullptr || !auth_manager_->is_authorized()) && !is_preauthentication_request(function_id) &&
!is_preinitialization_request(function_id) && !is_synchronous_request(function_id) &&
!is_authentication_request(function_id)) {
!is_preinitialization_request(function_id) && !is_authentication_request(function_id)) {
return send_error_raw(id, 401, "Unauthorized");
}
downcast_call(*function, [this, id](auto &request) { this->on_request(id, request); });
@ -3721,6 +3741,7 @@ void Td::on_closed() {
void Td::dec_stop_cnt() {
stop_cnt_--;
if (stop_cnt_ == 0) {
LOG(WARNING) << "Stop Td";
stop();
}
}
@ -3864,6 +3885,7 @@ void Td::close_impl(bool destroy_flag) {
}
if (state_ == State::WaitParameters) {
clear_requests();
state_ = State::Close;
return on_closed();
}
if (state_ == State::Decrypt) {
@ -4545,6 +4567,10 @@ void Td::on_request(uint64 id, td_api::checkAuthenticationBotToken &request) {
send_closure(auth_manager_actor_, &AuthManager::check_bot_token, id, std::move(request.token_));
}
void Td::on_request(uint64 id, const td_api::getCurrentState &request) {
return send_error_raw(id, 500, "Unimplemented");
}
void Td::on_request(uint64 id, td_api::getPasswordState &request) {
CHECK_IS_USER();
CREATE_REQUEST_PROMISE();
@ -6728,27 +6754,27 @@ void Td::on_request(uint64 id, const td_api::pingProxy &request) {
}
void Td::on_request(uint64 id, const td_api::getTextEntities &request) {
send_closure(actor_id(this), &Td::send_result, id, do_static_request(request));
UNREACHABLE();
}
void Td::on_request(uint64 id, td_api::parseTextEntities &request) {
send_closure(actor_id(this), &Td::send_result, id, do_static_request(request));
UNREACHABLE();
}
void Td::on_request(uint64 id, const td_api::getFileMimeType &request) {
send_closure(actor_id(this), &Td::send_result, id, do_static_request(request));
UNREACHABLE();
}
void Td::on_request(uint64 id, const td_api::getFileExtension &request) {
send_closure(actor_id(this), &Td::send_result, id, do_static_request(request));
UNREACHABLE();
}
void Td::on_request(uint64 id, const td_api::cleanFileName &request) {
send_closure(actor_id(this), &Td::send_result, id, do_static_request(request));
UNREACHABLE();
}
void Td::on_request(uint64 id, const td_api::getLanguagePackString &request) {
send_closure(actor_id(this), &Td::send_result, id, do_static_request(request));
UNREACHABLE();
}
template <class T>

4
td/telegram/Td.h
View File

@ -260,6 +260,8 @@ class Td final : public NetQueryCallback {
template <class T>
void complete_pending_preauthentication_requests(const T &func);
td_api::object_ptr<td_api::AuthorizationState> get_fake_authorization_state_object() const;
static void on_alarm_timeout_callback(void *td_ptr, int64 alarm_id);
void on_alarm_timeout(int64 alarm_id);
@ -341,6 +343,8 @@ class Td final : public NetQueryCallback {
void on_request(uint64 id, td_api::checkAuthenticationBotToken &request);
void on_request(uint64 id, const td_api::getCurrentState &request);
void on_request(uint64 id, td_api::getPasswordState &request);
void on_request(uint64 id, td_api::setPassword &request);

6
td/telegram/cli.cpp
View File

@ -417,7 +417,6 @@ class CliClient final : public Actor {
break;
case td_api::authorizationStateClosed::ID:
LOG(WARNING) << "TD closed";
// TODO only if count of created matches count of closed
td_.reset();
if (!close_flag_) {
create_td("ClientActor3");
@ -1193,6 +1192,8 @@ class CliClient final : public Actor {
send_request(make_tl_object<td_api::checkAuthenticationPassword>(args));
} else if (op == "cab" || op == "cabt") {
send_request(make_tl_object<td_api::checkAuthenticationBotToken>(args));
} else if (op == "gcs") {
send_request(make_tl_object<td_api::getCurrentState>());
} else if (op == "rapr") {
send_request(make_tl_object<td_api::requestAuthenticationPasswordRecovery>());
} else if (op == "rap") {
@ -1204,7 +1205,10 @@ class CliClient final : public Actor {
} else if (op == "reset") {
init_td();
} else if (op == "close_td") {
// send_request(make_tl_object<td_api::getCurrentState>());
send_request(make_tl_object<td_api::close>());
// send_request(make_tl_object<td_api::getCurrentState>());
// send_request(make_tl_object<td_api::close>());
} else if (op == "DeleteAccountYesIReallyWantToDeleteMyAccount") {
send_request(make_tl_object<td_api::deleteAccount>(args));
} else if (op == "gps" || op == "GetPasswordState") {