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

Use p_q_inner_data_dc.

Browse Source 
GitOrigin-RevId: f1e57b83d850ac4233bf9508b6585aaf0efe1423
This commit is contained in:
levlam 2018-05-23 19:49:05 +03:00
parent d763c755e1
commit db6777c7f2
9 changed files with 45 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
td/generate/scheme/mtproto_api.tl
View File

@ -12,8 +12,8 @@ int256 8*[ int ] = Int256;
resPQ#05162463 nonce:int128 server_nonce:int128 pq:string server_public_key_fingerprints:Vector<long> = ResPQ; resPQ#05162463 nonce:int128 server_nonce:int128 pq:string server_public_key_fingerprints:Vector<long> = ResPQ;
p_q_inner_data#83c95aec pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 = P_Q_inner_data; p_q_inner_data_dc#a9f55f95 pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 dc:int = P_Q_inner_data;
p_q_inner_data_temp#3c6a84d4 pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 expires_in:int = P_Q_inner_data; p_q_inner_data_temp_dc#56fddf88 pq:string p:string q:string nonce:int128 server_nonce:int128 new_nonce:int256 dc:int expires_in:int = P_Q_inner_data;
server_DH_params_fail#79cb045d nonce:int128 server_nonce:int128 new_nonce_hash:int128 = Server_DH_Params; server_DH_params_fail#79cb045d nonce:int128 server_nonce:int128 new_nonce_hash:int128 = Server_DH_Params;
server_DH_params_ok#d0e8075c nonce:int128 server_nonce:int128 encrypted_answer:string = Server_DH_Params; server_DH_params_ok#d0e8075c nonce:int128 server_nonce:int128 encrypted_answer:string = Server_DH_Params;

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

Binary file not shown.

6
td/mtproto/Handshake.cpp
View File

@ -82,13 +82,13 @@ Status AuthKeyHandshake::on_res_pq(Slice message, Callback *connection, PublicRs
Result<size_t> r_data_size = 0; Result<size_t> r_data_size = 0;
switch (mode_) { switch (mode_) {
case Mode::Main: case Mode::Main:
r_data_size = fill_data_with_hash(data_with_hash, r_data_size = fill_data_with_hash(
mtproto_api::p_q_inner_data(res_pq->pq_, p, q, nonce, server_nonce, new_nonce)); data_with_hash, mtproto_api::p_q_inner_data_dc(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, dc_id_));
break; break;
case Mode::Temp: case Mode::Temp:
r_data_size = fill_data_with_hash( r_data_size = fill_data_with_hash(
data_with_hash, data_with_hash,
mtproto_api::p_q_inner_data_temp(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, expire_in_)); mtproto_api::p_q_inner_data_temp_dc(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, dc_id_, expire_in_));
expire_at_ = Time::now() + expire_in_; expire_at_ = Time::now() + expire_in_;
break; break;
case Mode::Unknown: case Mode::Unknown:

4
td/mtproto/Handshake.h
View File

@ -48,7 +48,8 @@ class AuthKeyHandshake {
bool is_ready_for_finish(); bool is_ready_for_finish();
void on_finish(); void on_finish();
explicit AuthKeyHandshake(int32 expire_in = 0) { AuthKeyHandshake(int32 dc_id, int32 expire_in) {
dc_id_ = dc_id;
if (expire_in == 0) { if (expire_in == 0) {
mode_ = Mode::Main; mode_ = Mode::Main;
} else { } else {
@ -76,6 +77,7 @@ class AuthKeyHandshake {
using State = enum { Start, ResPQ, ServerDHParams, DHGenResponse, Finish }; using State = enum { Start, ResPQ, ServerDHParams, DHGenResponse, Finish };
State state_ = Start; State state_ = Start;
Mode mode_ = Mode::Unknown; Mode mode_ = Mode::Unknown;
int32 dc_id_;
int32 expire_in_; int32 expire_in_;
double expire_at_ = 0; double expire_at_ = 0;

6
td/telegram/ConfigManager.cpp
View File

@ -293,7 +293,11 @@ ActorOwn<> get_full_config(DcId dc_id, IPAddress ip_address, Promise<FullConfig>
auto session_callback = std::make_unique<SessionCallback>(actor_shared(this, 1), std::move(ip_address_)); auto session_callback = std::make_unique<SessionCallback>(actor_shared(this, 1), std::move(ip_address_));
auto auth_data = std::make_shared<SimpleAuthData>(dc_id_); auto auth_data = std::make_shared<SimpleAuthData>(dc_id_);
session_ = create_actor<Session>("ConfigSession", std::move(session_callback), std::move(auth_data), int32 int_dc_id = dc_id_.get_raw_id();
if (G()->is_test_dc()) {
int_dc_id += 10000;
}
session_ = create_actor<Session>("ConfigSession", std::move(session_callback), std::move(auth_data), int_dc_id,
false /*is_main*/, true /*use_pfs*/, false /*is_cdn*/, mtproto::AuthKey()); false /*is_main*/, true /*use_pfs*/, false /*is_cdn*/, mtproto::AuthKey());
auto query = G()->net_query_creator().create(create_storer(telegram_api::help_getConfig()), DcId::empty(), auto query = G()->net_query_creator().create(create_storer(telegram_api::help_getConfig()), DcId::empty(),
NetQuery::Type::Common, NetQuery::AuthFlag::Off, NetQuery::Type::Common, NetQuery::AuthFlag::Off,

15
td/telegram/net/Session.cpp
View File

@ -96,8 +96,9 @@ class GenAuthKeyActor : public Actor {
} // namespace detail } // namespace detail
Session::Session(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared> shared_auth_data, bool is_main, Session::Session(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared> shared_auth_data, int32 dc_id,
bool use_pfs, bool is_cdn, const mtproto::AuthKey &tmp_auth_key) { bool is_main, bool use_pfs, bool is_cdn, const mtproto::AuthKey &tmp_auth_key)
: dc_id_(dc_id), is_main_(is_main), is_cdn_(is_cdn) {
VLOG(dc) << "Start connection"; VLOG(dc) << "Start connection";
shared_auth_data_ = std::move(shared_auth_data); shared_auth_data_ = std::move(shared_auth_data);
@ -118,8 +119,6 @@ Session::Session(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared>
main_connection_.connection_id = 0; main_connection_.connection_id = 0;
long_poll_connection_.connection_id = 1; long_poll_connection_.connection_id = 1;
is_main_ = is_main;
is_cdn_ = is_cdn;
if (is_cdn) { if (is_cdn) {
auth_data_.set_header(G()->mtproto_header().get_anonymous_header().str()); auth_data_.set_header(G()->mtproto_header().get_anonymous_header().str());
} else { } else {
@ -331,11 +330,11 @@ Status Session::on_pong() {
constexpr int MAX_QUERY_TIMEOUT = 60; constexpr int MAX_QUERY_TIMEOUT = 60;
constexpr int MIN_CONNECTION_ACTIVE = 60; constexpr int MIN_CONNECTION_ACTIVE = 60;
if (current_info_ == &main_connection_ && if (current_info_ == &main_connection_ &&
Timestamp::at(current_info_->created_at_ + MIN_CONNECTION_ACTIVE).is_in_past()) { Timestamp::at(current_info_->created_at + MIN_CONNECTION_ACTIVE).is_in_past()) {
Status status; Status status;
if (!unknown_queries_.empty()) { if (!unknown_queries_.empty()) {
status = Status::Error(PSLICE() << "No state info for " << unknown_queries_.size() << " queries for " status = Status::Error(PSLICE() << "No state info for " << unknown_queries_.size() << " queries for "
<< format::as_time(Time::now_cached() - current_info_->created_at_)); << format::as_time(Time::now_cached() - current_info_->created_at));
} }
if (!sent_queries_list_.empty()) { if (!sent_queries_list_.empty()) {
for (auto it = sent_queries_list_.prev; it != &sent_queries_list_; it = it->prev) { for (auto it = sent_queries_list_.prev; it != &sent_queries_list_; it = it->prev) {
@ -940,7 +939,7 @@ void Session::connection_open_finish(ConnectionInfo *info,
subscribe(info->connection->get_pollable()); subscribe(info->connection->get_pollable());
info->mode = mode_; info->mode = mode_;
info->state = ConnectionInfo::State::Ready; info->state = ConnectionInfo::State::Ready;
info->created_at_ = Time::now_cached(); info->created_at = Time::now_cached();
info->wakeup_at = Time::now_cached() + 10; info->wakeup_at = Time::now_cached() + 10;
if (unknown_queries_.size() > 1024) { if (unknown_queries_.size() > 1024) {
on_session_failed(Status::Error("Too much queries with unknown state")); on_session_failed(Status::Error("Too much queries with unknown state"));
@ -1060,7 +1059,7 @@ void Session::create_gen_auth_key_actor(HandshakeId handshake_id) {
info.flag_ = true; info.flag_ = true;
bool is_main = handshake_id == MainAuthKeyHandshake; bool is_main = handshake_id == MainAuthKeyHandshake;
if (!info.handshake_) { if (!info.handshake_) {
info.handshake_ = std::make_unique<mtproto::AuthKeyHandshake>(is_main && !is_cdn_ ? 0 : 24 * 60 * 60); info.handshake_ = std::make_unique<mtproto::AuthKeyHandshake>(dc_id_, is_main && !is_cdn_ ? 0 : 24 * 60 * 60);
} }
class AuthKeyHandshakeContext : public mtproto::AuthKeyHandshakeContext { class AuthKeyHandshakeContext : public mtproto::AuthKeyHandshakeContext {
public: public:

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

@ -59,8 +59,8 @@ class Session final
// one still have to call close after on_closed // one still have to call close after on_closed
}; };
Session(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared> shared_auth_data, bool is_main, bool use_pfs, Session(unique_ptr<Callback> callback, std::shared_ptr<AuthDataShared> shared_auth_data, int32 dc_id, bool is_main,
bool is_cdn, const mtproto::AuthKey &tmp_auth_key); bool use_pfs, bool is_cdn, const mtproto::AuthKey &tmp_auth_key);
void send(NetQueryPtr &&query); void send(NetQueryPtr &&query);
void on_network(bool network_flag, uint32 network_generation); void on_network(bool network_flag, uint32 network_generation);
void on_online(bool online_flag); void on_online(bool online_flag);
@ -94,6 +94,7 @@ class Session final
// Just re-ask answer_id each time we get information about it. // Just re-ask answer_id each time we get information about it.
// Thought mtproto::Connection must ensure delivery of such query // Thought mtproto::Connection must ensure delivery of such query
int32 dc_id_;
enum class Mode : int8 { Tcp, Http } mode_ = Mode::Tcp; enum class Mode : int8 { Tcp, Http } mode_ = Mode::Tcp;
bool is_main_; bool is_main_;
bool is_cdn_; bool is_cdn_;
@ -121,12 +122,10 @@ class Session final
int8 connection_id; int8 connection_id;
Mode mode; Mode mode;
enum class State : int8 { Empty, Connecting, Ready } state = State::Empty; enum class State : int8 { Empty, Connecting, Ready } state = State::Empty;
mtproto::AuthKeyHandshake handshake;
mtproto::AuthKeyHandshake tmp_handshake;
unique_ptr<mtproto::SessionConnection> connection; unique_ptr<mtproto::SessionConnection> connection;
bool ask_info; bool ask_info;
double wakeup_at = 0; double wakeup_at = 0;
double created_at_ = 0; double created_at = 0;
}; };
ConnectionInfo *current_info_; ConnectionInfo *current_info_;

19
td/telegram/net/SessionProxy.cpp
View File

@ -140,14 +140,21 @@ void SessionProxy::open_session(bool force) {
return; return;
} }
CHECK(session_.empty()); CHECK(session_.empty());
auto dc_id = auth_data_->dc_id();
string name = PSTRING() << "Session" << get_name().substr(Slice("SessionProxy").size()); string name = PSTRING() << "Session" << get_name().substr(Slice("SessionProxy").size());
string hash_string = PSTRING() << name << " " << auth_data_->dc_id().get_raw_id() << " " << allow_media_only_; string hash_string = PSTRING() << name << " " << dc_id.get_raw_id() << " " << allow_media_only_;
auto hash = std::hash<std::string>()(hash_string); auto hash = std::hash<std::string>()(hash_string);
session_ = int32 int_dc_id = dc_id.get_raw_id();
create_actor<Session>(name, if (G()->is_test_dc()) {
make_unique<SessionCallback>(actor_shared(this, session_generation_), auth_data_->dc_id(), int_dc_id += 10000;
allow_media_only_, is_media_, hash), }
auth_data_, is_main_, use_pfs_, is_cdn_, tmp_auth_key_); if (is_media_) {
int_dc_id = -int_dc_id;
}
session_ = create_actor<Session>(
name,
make_unique<SessionCallback>(actor_shared(this, session_generation_), dc_id, allow_media_only_, is_media_, hash),
auth_data_, int_dc_id, is_main_, use_pfs_, is_cdn_, tmp_auth_key_);
} }
void SessionProxy::update_auth_state() { void SessionProxy::update_auth_state() {

13
test/mtproto.cpp
View File

@ -144,6 +144,10 @@ static IPAddress get_default_ip_address() {
return ip_address; return ip_address;
} }
static int32 get_default_dc_id() {
return 10002;
}
class Mtproto_ping : public td::Test { class Mtproto_ping : public td::Test {
public: public:
using Test::Test; using Test::Test;
@ -163,7 +167,6 @@ class Mtproto_ping : public td::Test {
if (result_.is_error()) { if (result_.is_error()) {
LOG(ERROR) << result_; LOG(ERROR) << result_;
} }
ASSERT_TRUE(result_.is_ok());
return false; return false;
} }
@ -189,7 +192,7 @@ class Context : public AuthKeyHandshakeContext {
class HandshakeTestActor : public Actor { class HandshakeTestActor : public Actor {
public: public:
explicit HandshakeTestActor(Status *result) : result_(result) { HandshakeTestActor(int32 dc_id, Status *result) : dc_id_(dc_id), result_(result) {
} }
private: private:
@ -199,6 +202,7 @@ class HandshakeTestActor : public Actor {
bool wait_for_handshake_ = false; bool wait_for_handshake_ = false;
std::unique_ptr<AuthKeyHandshake> handshake_; std::unique_ptr<AuthKeyHandshake> handshake_;
Status status_; Status status_;
int32 dc_id_ = 0;
bool wait_for_result_ = false; bool wait_for_result_ = false;
void tear_down() override { void tear_down() override {
@ -214,7 +218,7 @@ class HandshakeTestActor : public Actor {
mtproto::TransportType{mtproto::TransportType::Tcp, 0, ""}, nullptr); mtproto::TransportType{mtproto::TransportType::Tcp, 0, ""}, nullptr);
} }
if (!wait_for_handshake_ && !handshake_) { if (!wait_for_handshake_ && !handshake_) {
handshake_ = std::make_unique<AuthKeyHandshake>(0); handshake_ = std::make_unique<AuthKeyHandshake>(dc_id_, 0);
} }
if (raw_connection_ && handshake_) { if (raw_connection_ && handshake_) {
if (wait_for_result_) { if (wait_for_result_) {
@ -283,7 +287,7 @@ class Mtproto_handshake : public td::Test {
bool step() final { bool step() final {
if (!is_inited_) { if (!is_inited_) {
sched_.init(0); sched_.init(0);
sched_.create_actor_unsafe<HandshakeTestActor>(0, "HandshakeTestActor", &result_).release(); sched_.create_actor_unsafe<HandshakeTestActor>(0, "HandshakeTestActor", get_default_dc_id(), &result_).release();
sched_.start(); sched_.start();
is_inited_ = true; is_inited_ = true;
} }
@ -296,7 +300,6 @@ class Mtproto_handshake : public td::Test {
if (result_.is_error()) { if (result_.is_error()) {
LOG(ERROR) << result_; LOG(ERROR) << result_;
} }
ASSERT_TRUE(result_.is_ok());
return false; return false;
} }