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

All updatePromotedChat.

Browse Source 
GitOrigin-RevId: 4a3c6283026ba15836cb7fa011c4b3ad21a64baa
This commit is contained in:
levlam 2018-05-08 23:02:15 +03:00
parent 5c1612e9eb
commit c65b998cd6
13 changed files with 291 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2083,7 +2083,7 @@ updateScopeNotificationSettings scope:NotificationSettingsScope notification_set
//@chat_id Chat identifier @reply_markup_message_id Identifier of the message from which reply markup needs to be used; 0 if there is no default custom reply markup in the chat
updateChatReplyMarkup chat_id:int53 reply_markup_message_id:int53 = Update;
//@description A draft has changed. Be aware that the update may come in the currently opened chat but with old content of the draft. If the user has changed the content of the draft, this update shouldn't be applied @chat_id Chat identifier @draft_message The new draft message; may be null @order New value of the chat order
//@description A chat draft has changed. Be aware that the update may come in the currently opened chat but with old content of the draft. If the user has changed the content of the draft, this update shouldn't be applied @chat_id Chat identifier @draft_message The new draft message; may be null @order New value of the chat order
updateChatDraftMessage chat_id:int53 draft_message:draftMessage order:int64 = Update;
//@description Some messages were deleted @chat_id Chat identifier @message_ids Identifiers of the deleted messages
@ -2094,6 +2094,9 @@ updateDeleteMessages chat_id:int53 message_ids:vector<int53> is_permanent:Bool f
//@description User activity in the chat has changed @chat_id Chat identifier @user_id Identifier of a user performing an action @action The action description
updateUserChatAction chat_id:int53 user_id:int32 action:ChatAction = Update;
//@description A promoted by enabled proxy chat has changed @chat_id Identifier of the promoted chat or 0 if none
updatePromotedChat chat_id:int53 = Update;
//@description The user went online or offline @user_id User identifier @status New status of the user
updateUserStatus user_id:int32 status:UserStatus = Update;

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

Binary file not shown.

2
td/telegram/Global.cpp
View File

@ -51,7 +51,7 @@ void Global::set_temp_auth_key_watchdog(ActorOwn<TempAuthKeyWatchdog> actor) {
temp_auth_key_watchdog_ = std::move(actor);
}
const MtprotoHeader &Global::mtproto_header() const {
MtprotoHeader &Global::mtproto_header() {
return *mtproto_header_;
}
void Global::set_mtproto_header(std::unique_ptr<MtprotoHeader> mtproto_header) {

2
td/telegram/Global.h
View File

@ -221,7 +221,7 @@ class Global : public ActorContext {
ActorId<TempAuthKeyWatchdog> temp_auth_key_watchdog() const;
void set_temp_auth_key_watchdog(ActorOwn<TempAuthKeyWatchdog> actor);
const MtprotoHeader &mtproto_header() const;
MtprotoHeader &mtproto_header();
void set_mtproto_header(std::unique_ptr<MtprotoHeader> mtproto_header);
const TdParameters &parameters() const {

148
td/telegram/MessagesManager.cpp
View File

@ -4700,46 +4700,6 @@ MessagesManager::MessagesManager(Td *td, ActorShared<> parent) : td_(td), parent
active_dialog_action_timeout_.set_callback_data(static_cast<void *>(this));
sequence_dispatcher_ = create_actor<MultiSequenceDispatcher>("multi sequence dispatcher");
if (G()->parameters().use_message_db) {
auto last_database_server_dialog_date_string = G()->td_db()->get_binlog_pmc()->get("last_server_dialog_date");
if (!last_database_server_dialog_date_string.empty()) {
string order_str;
string dialog_id_str;
std::tie(order_str, dialog_id_str) = split(last_database_server_dialog_date_string);
auto r_order = to_integer_safe<int64>(order_str);
auto r_dialog_id = to_integer_safe<int64>(dialog_id_str);
if (r_order.is_error() || r_dialog_id.is_error()) {
LOG(ERROR) << "Can't parse " << last_database_server_dialog_date_string;
} else {
last_database_server_dialog_date_ = DialogDate(r_order.ok(), DialogId(r_dialog_id.ok()));
}
}
LOG(INFO) << "Load last_database_server_dialog_date_ = " << last_database_server_dialog_date_;
auto unread_message_count_string = G()->td_db()->get_binlog_pmc()->get("unread_message_count");
if (!unread_message_count_string.empty()) {
string total_count;
string muted_count;
std::tie(total_count, muted_count) = split(unread_message_count_string);
auto r_total_count = to_integer_safe<int32>(total_count);
auto r_muted_count = to_integer_safe<int32>(muted_count);
if (r_total_count.is_error() || r_muted_count.is_error()) {
LOG(ERROR) << "Can't parse " << unread_message_count_string;
} else {
unread_message_total_count_ = r_total_count.ok();
unread_message_muted_count_ = r_muted_count.ok();
is_unread_count_inited_ = true;
send_update_unread_message_count(DialogId(), true, "load unread_message_count");
}
}
LOG(INFO) << "Load last_database_server_dialog_date_ = " << last_database_server_dialog_date_;
} else {
G()->td_db()->get_binlog_pmc()->erase("last_server_dialog_date");
G()->td_db()->get_binlog_pmc()->erase("unread_message_count");
}
}
MessagesManager::~MessagesManager() = default;
@ -9598,6 +9558,70 @@ void MessagesManager::tear_down() {
void MessagesManager::start_up() {
always_wait_for_mailbox();
if (G()->parameters().use_message_db) {
auto last_database_server_dialog_date_string = G()->td_db()->get_binlog_pmc()->get("last_server_dialog_date");
if (!last_database_server_dialog_date_string.empty()) {
string order_str;
string dialog_id_str;
std::tie(order_str, dialog_id_str) = split(last_database_server_dialog_date_string);
auto r_order = to_integer_safe<int64>(order_str);
auto r_dialog_id = to_integer_safe<int64>(dialog_id_str);
if (r_order.is_error() || r_dialog_id.is_error()) {
LOG(ERROR) << "Can't parse " << last_database_server_dialog_date_string;
} else {
last_database_server_dialog_date_ = DialogDate(r_order.ok(), DialogId(r_dialog_id.ok()));
}
}
LOG(INFO) << "Load last_database_server_dialog_date_ = " << last_database_server_dialog_date_;
auto unread_message_count_string = G()->td_db()->get_binlog_pmc()->get("unread_message_count");
if (!unread_message_count_string.empty()) {
string total_count;
string muted_count;
std::tie(total_count, muted_count) = split(unread_message_count_string);
auto r_total_count = to_integer_safe<int32>(total_count);
auto r_muted_count = to_integer_safe<int32>(muted_count);
if (r_total_count.is_error() || r_muted_count.is_error()) {
LOG(ERROR) << "Can't parse " << unread_message_count_string;
} else {
unread_message_total_count_ = r_total_count.ok();
unread_message_muted_count_ = r_muted_count.ok();
is_unread_count_inited_ = true;
send_update_unread_message_count(DialogId(), true, "load unread_message_count");
}
}
LOG(INFO) << "Load last_database_server_dialog_date_ = " << last_database_server_dialog_date_;
auto promoted_dialog_id_string = G()->td_db()->get_binlog_pmc()->get("promoted_dialog_id");
if (!promoted_dialog_id_string.empty()) {
auto r_dialog_id = to_integer_safe<int64>(promoted_dialog_id_string);
if (r_dialog_id.is_error()) {
LOG(ERROR) << "Can't parse " << promoted_dialog_id_string;
} else {
promoted_dialog_id_ = DialogId(r_dialog_id.ok());
if (!promoted_dialog_id_.is_valid()) {
LOG(ERROR) << "Have invalid chat ID " << promoted_dialog_id_string;
promoted_dialog_id_ = DialogId();
} else {
Dialog *d = get_dialog_force(promoted_dialog_id_);
if (d == nullptr) {
LOG(ERROR) << "Can't load " << promoted_dialog_id_;
promoted_dialog_id_ = DialogId();
}
}
}
}
if (promoted_dialog_id_.is_valid()) {
send_update_promoted_chat();
}
} else {
G()->td_db()->get_binlog_pmc()->erase("last_server_dialog_date");
G()->td_db()->get_binlog_pmc()->erase("unread_message_count");
G()->td_db()->get_binlog_pmc()->erase("promoted_dialog_id");
}
if (G()->parameters().use_message_db) {
ttl_db_loop_start(G()->server_time());
}
@ -19120,6 +19144,13 @@ void MessagesManager::send_update_chat_unread_mention_count(const Dialog *d) {
}
}
void MessagesManager::send_update_promoted_chat() const {
if (!td_->auth_manager_->is_bot()) {
LOG(INFO) << "Update promoted chat to " << promoted_dialog_id_;
send_closure(G()->td(), &Td::send_update, make_tl_object<td_api::updatePromotedChat>(promoted_dialog_id_.get()));
}
}
void MessagesManager::on_send_message_get_quick_ack(int64 random_id) {
auto it = being_sent_messages_.find(random_id);
if (it == being_sent_messages_.end()) {
@ -25816,4 +25847,41 @@ void MessagesManager::get_payment_receipt(FullMessageId full_message_id,
td::get_payment_receipt(message_id.get_server_message_id(), std::move(promise));
}
void MessagesManager::on_get_promoted_dialog_id(tl_object_ptr<telegram_api::Peer> peer,
vector<tl_object_ptr<telegram_api::User>> users,
vector<tl_object_ptr<telegram_api::Chat>> chats) {
if (peer == nullptr) {
set_promoted_dialog_id(DialogId());
return;
}
td_->contacts_manager_->on_get_users(std::move(users));
td_->contacts_manager_->on_get_chats(std::move(chats));
set_promoted_dialog_id(DialogId(peer));
}
void MessagesManager::set_promoted_dialog_id(DialogId dialog_id) {
if (promoted_dialog_id_ == dialog_id) {
return;
}
promoted_dialog_id_ = dialog_id;
if (dialog_id.is_valid()) {
force_create_dialog(dialog_id, "set_promoted_dialog_id");
/*
Dialog *d = get_dialog(dialog_id);
CHECK(d != nullptr);
update_dialog_pos(d, false, "set_promoted_dialog_id");
*/
}
if (G()->parameters().use_message_db) {
G()->td_db()->get_binlog_pmc()->set("promoted_dialog_id", to_string(promoted_dialog_id_.get()));
LOG(INFO) << "Save promoted " << promoted_dialog_id_;
}
send_update_promoted_chat();
}
} // namespace td

10
td/telegram/MessagesManager.h
View File

@ -1401,6 +1401,10 @@ class MessagesManager : public Actor {
void on_get_dialog_query_finished(DialogId dialog_id, Status &&status);
void on_get_promoted_dialog_id(tl_object_ptr<telegram_api::Peer> peer,
vector<tl_object_ptr<telegram_api::User>> users,
vector<tl_object_ptr<telegram_api::Chat>> chats);
void on_binlog_events(vector<BinlogEvent> &&events);
void get_payment_form(FullMessageId full_message_id, Promise<tl_object_ptr<td_api::paymentForm>> &&promise);
@ -2218,6 +2222,8 @@ class MessagesManager : public Actor {
void send_update_chat_unread_mention_count(const Dialog *d);
void send_update_promoted_chat() const;
tl_object_ptr<td_api::message> get_message_object(DialogId dialog_id, const Message *message) const;
static tl_object_ptr<td_api::messages> get_messages_object(int32 total_count,
@ -2597,6 +2603,8 @@ class MessagesManager : public Actor {
void on_upload_dialog_photo(FileId file_id, tl_object_ptr<telegram_api::InputFile> input_file);
void on_upload_dialog_photo_error(FileId file_id, Status status);
void set_promoted_dialog_id(DialogId dialog_id);
static uint64 get_sequence_dispatcher_id(DialogId dialog_id, int32 message_content_type);
Dialog *get_service_notifications_dialog();
@ -2884,6 +2892,8 @@ class MessagesManager : public Actor {
std::unordered_map<DialogId, NetQueryRef, DialogIdHash> set_typing_query_;
DialogId promoted_dialog_id_;
Td *td_;
ActorShared<> parent_;
};

3
td/telegram/StateManager.cpp
View File

@ -14,6 +14,7 @@
#include "td/utils/Time.h"
namespace td {
void StateManager::inc_connect() {
auto &cnt = get_link_token() == 1 ? connect_cnt_ : connect_proxy_cnt_;
cnt++;
@ -48,6 +49,7 @@ void StateManager::on_synchronized(bool is_synchronized) {
void StateManager::on_network(NetType new_network_type) {
do_on_network(new_network_type, true /*inc_generation*/);
}
void StateManager::do_on_network(NetType new_network_type, bool inc_generation) {
bool new_network_flag = new_network_type != NetType::None;
if (network_flag_ != new_network_flag) {
@ -176,4 +178,5 @@ void StateManager::loop() {
has_timestamp_ = false;
}
}
} // namespace td

2
td/telegram/StateManager.h
View File

@ -14,6 +14,7 @@
#include "td/utils/common.h"
namespace td {
class StateManager final : public Actor {
public:
enum class State : int32 { WaitingForNetwork, ConnectingToProxy, Connecting, Updating, Ready, Empty };
@ -131,4 +132,5 @@ class StateManager final : public Actor {
return ConnectionToken(std::move(actor));
}
};
} // namespace td

1
td/telegram/Td.h
View File

@ -30,6 +30,7 @@
#include <utility>
namespace td {
class AnimationsManager;
class AudiosManager;
class AuthManager;

1
td/telegram/TdDb.cpp
View File

@ -304,6 +304,7 @@ Status TdDb::init_sqlite(int32 scheduler_id, const TdParameters &parameters, DbK
if (dialog_db_was_created) {
binlog_pmc.erase("unread_message_count");
binlog_pmc.erase("last_server_dialog_date");
binlog_pmc.erase("promoted_dialog_id");
}
if (db_version == 0) {
binlog_pmc.erase_by_prefix("top_dialogs");

160
td/telegram/net/ConnectionCreator.cpp
View File

@ -6,9 +6,14 @@
//
#include "td/telegram/net/ConnectionCreator.h"
#include "td/telegram/telegram_api.h"
#include "td/telegram/ConfigManager.h"
#include "td/telegram/Global.h"
#include "td/telegram/logevent/LogEvent.h"
#include "td/telegram/MessagesManager.h"
#include "td/telegram/net/MtprotoHeader.h"
#include "td/telegram/net/NetQueryDispatcher.h"
#include "td/telegram/StateManager.h"
#include "td/mtproto/IStreamTransport.h"
@ -216,15 +221,24 @@ void ConnectionCreator::set_proxy(Proxy proxy) {
}
void ConnectionCreator::set_proxy_impl(Proxy proxy, bool from_db) {
auto have_proxy = proxy.type() != Proxy::Type::None;
if (proxy_ == proxy) {
if (!have_proxy) {
on_get_proxy_info(make_tl_object<telegram_api::help_proxyDataEmpty>(0));
}
return;
}
proxy_ = std::move(proxy);
send_closure(G()->state_manager(), &StateManager::on_proxy, proxy_.type() != Proxy::Type::None);
G()->mtproto_header().set_proxy(proxy_);
send_closure(G()->state_manager(), &StateManager::on_proxy, have_proxy);
if (!from_db) {
G()->td_db()->get_binlog_pmc()->set("proxy", log_event_store(proxy_).as_slice().str());
if (have_proxy) {
G()->td_db()->get_binlog_pmc()->set("proxy", log_event_store(proxy_).as_slice().str());
} else {
G()->td_db()->get_binlog_pmc()->erase("proxy");
}
for (auto &child : children_) {
child.second.reset();
}
@ -233,6 +247,14 @@ void ConnectionCreator::set_proxy_impl(Proxy proxy, bool from_db) {
resolve_proxy_query_token_ = 0;
resolve_proxy_timestamp_ = Timestamp();
proxy_ip_address_ = IPAddress();
get_proxy_info_query_token_ = 0;
get_proxy_info_timestamp_ = Timestamp();
if (!have_proxy || !from_db) {
on_get_proxy_info(make_tl_object<telegram_api::help_proxyDataEmpty>(0));
} else {
schedule_get_proxy_info(0);
}
}
void ConnectionCreator::get_proxy(Promise<Proxy> promise) {
@ -246,6 +268,7 @@ void ConnectionCreator::on_network(bool network_flag, uint32 network_generation)
if (network_flag_) {
resolve_proxy_query_token_ = 0;
resolve_proxy_timestamp_ = Timestamp();
get_proxy_info_timestamp_ = Timestamp();
for (auto &client : clients_) {
client.second.backoff.clear();
client.second.flood_control.clear_events();
@ -258,6 +281,7 @@ void ConnectionCreator::on_network(bool network_flag, uint32 network_generation)
}
}
}
void ConnectionCreator::on_online(bool online_flag) {
online_flag_ = online_flag;
if (online_flag_) {
@ -597,19 +621,20 @@ void ConnectionCreator::on_dc_update(DcId dc_id, string ip_port, Promise<> promi
void ConnectionCreator::start_up() {
class StateCallback : public StateManager::Callback {
public:
explicit StateCallback(ActorId<ConnectionCreator> session) : session_(std::move(session)) {
explicit StateCallback(ActorId<ConnectionCreator> connection_creator)
: connection_creator_(std::move(connection_creator)) {
}
bool on_network(NetType network_type, uint32 generation) override {
send_closure(session_, &ConnectionCreator::on_network, network_type != NetType::None, generation);
return session_.is_alive();
send_closure(connection_creator_, &ConnectionCreator::on_network, network_type != NetType::None, generation);
return connection_creator_.is_alive();
}
bool on_online(bool online_flag) override {
send_closure(session_, &ConnectionCreator::on_online, online_flag);
return session_.is_alive();
send_closure(connection_creator_, &ConnectionCreator::on_online, online_flag);
return connection_creator_.is_alive();
}
private:
ActorId<ConnectionCreator> session_;
ActorId<ConnectionCreator> connection_creator_;
};
send_closure(G()->state_manager(), &StateManager::add_callback, make_unique<StateCallback>(actor_id(this)));
@ -622,15 +647,15 @@ void ConnectionCreator::start_up() {
on_dc_options(std::move(dc_options));
}
Proxy proxy;
auto log_event_proxy = G()->td_db()->get_binlog_pmc()->get("proxy");
if (!log_event_proxy.empty()) {
Proxy proxy;
log_event_parse(proxy, log_event_proxy).ensure();
set_proxy_impl(std::move(proxy), true);
}
set_proxy_impl(std::move(proxy), true);
get_host_by_name_actor_ =
create_actor_on_scheduler<GetHostByNameActor>("GetHostByNameActor", G()->get_gc_scheduler_id(), 29 * 60, 0);
create_actor_on_scheduler<GetHostByNameActor>("GetHostByNameActor", G()->get_gc_scheduler_id(), 5 * 60 - 1, 0);
ref_cnt_guard_ = create_reference(-1);
@ -703,38 +728,121 @@ void ConnectionCreator::loop() {
if (!network_flag_) {
return;
}
if (proxy_.type() == Proxy::Type::None) {
return;
Timestamp timeout;
if (proxy_.type() == Proxy::Type::Mtproto) {
if (get_proxy_info_timestamp_.is_in_past()) {
if (get_proxy_info_query_token_ == 0) {
get_proxy_info_query_token_ = next_token();
auto query = G()->net_query_creator().create(create_storer(telegram_api::help_getProxyData()));
G()->net_query_dispatcher().dispatch_with_callback(std::move(query),
actor_shared(this, get_proxy_info_query_token_));
}
} else {
CHECK(get_proxy_info_query_token_ == 0);
timeout.relax(get_proxy_info_timestamp_);
}
}
if (resolve_proxy_query_token_ != 0) {
return;
if (proxy_.type() != Proxy::Type::None) {
if (resolve_proxy_timestamp_.is_in_past()) {
if (resolve_proxy_query_token_ == 0) {
resolve_proxy_query_token_ = next_token();
send_closure(
get_host_by_name_actor_, &GetHostByNameActor::run, proxy_.server().str(), proxy_.port(),
PromiseCreator::lambda([actor_id = create_reference(resolve_proxy_query_token_)](Result<IPAddress> result) {
send_closure(std::move(actor_id), &ConnectionCreator::on_proxy_resolved, std::move(result), false);
}));
}
} else {
CHECK(resolve_proxy_query_token_ == 0);
timeout.relax(resolve_proxy_timestamp_);
}
}
if (resolve_proxy_timestamp_ && !resolve_proxy_timestamp_.is_in_past()) {
set_timeout_at(resolve_proxy_timestamp_.at());
return;
if (timeout) {
set_timeout_at(timeout.at());
}
resolve_proxy_query_token_ = next_token();
send_closure(
get_host_by_name_actor_, &GetHostByNameActor::run, proxy_.server().str(), proxy_.port(),
PromiseCreator::lambda([actor_id = create_reference(resolve_proxy_query_token_)](Result<IPAddress> result) {
send_closure(std::move(actor_id), &ConnectionCreator::on_proxy_resolved, std::move(result), false);
}));
}
void ConnectionCreator::on_proxy_resolved(Result<IPAddress> r_ip_address, bool dummy) {
void ConnectionCreator::on_result(NetQueryPtr query) {
if (get_link_token() != get_proxy_info_query_token_) {
return;
}
SCOPE_EXIT {
loop();
};
get_proxy_info_query_token_ = 0;
auto res = fetch_result<telegram_api::help_getProxyData>(std::move(query));
if (res.is_error()) {
if (G()->close_flag()) {
return;
}
LOG(ERROR) << "Receive error for getProxyData: " << res.error();
return schedule_get_proxy_info(60);
}
on_get_proxy_info(res.move_as_ok());
}
void ConnectionCreator::on_get_proxy_info(telegram_api::object_ptr<telegram_api::help_ProxyData> proxy_data_ptr) {
CHECK(proxy_data_ptr != nullptr);
LOG(INFO) << "Receive " << to_string(proxy_data_ptr);
int32 expires = 0;
switch (proxy_data_ptr->get_id()) {
case telegram_api::help_proxyDataEmpty::ID: {
auto proxy = telegram_api::move_object_as<telegram_api::help_proxyDataEmpty>(proxy_data_ptr);
expires = proxy->expires_;
send_closure(G()->messages_manager(), &MessagesManager::on_get_promoted_dialog_id, nullptr,
vector<tl_object_ptr<telegram_api::User>>(), vector<tl_object_ptr<telegram_api::Chat>>());
break;
}
case telegram_api::help_proxyDataPromo::ID: {
auto proxy = telegram_api::move_object_as<telegram_api::help_proxyDataPromo>(proxy_data_ptr);
expires = proxy->expires_;
send_closure(G()->messages_manager(), &MessagesManager::on_get_promoted_dialog_id, std::move(proxy->peer_),
std::move(proxy->users_), std::move(proxy->chats_));
break;
}
default:
UNREACHABLE();
}
if (expires != 0) {
expires -= G()->unix_time();
}
schedule_get_proxy_info(expires);
}
void ConnectionCreator::schedule_get_proxy_info(int32 expires) {
if (expires < 0) {
LOG(ERROR) << "Receive wrong expires: " << expires;
expires = 0;
}
if (expires != 0 && expires < 60) {
expires = 60;
}
if (expires > 86400) {
expires = 86400;
}
get_proxy_info_timestamp_ = Timestamp::in(expires);
}
void ConnectionCreator::on_proxy_resolved(Result<IPAddress> r_ip_address, bool dummy) {
if (get_link_token() != resolve_proxy_query_token_) {
return;
}
SCOPE_EXIT {
loop();
};
resolve_proxy_query_token_ = 0;
if (r_ip_address.is_error()) {
resolve_proxy_timestamp_ = Timestamp::in(1 * 60);
return;
}
proxy_ip_address_ = r_ip_address.move_as_ok();
proxy_ip_address_.set_port(proxy_.port());
resolve_proxy_timestamp_ = Timestamp::in(5 * 60);
for (auto &client : clients_) {
client_loop(client.second);

16
td/telegram/net/ConnectionCreator.h
View File

@ -10,6 +10,7 @@
#include "td/telegram/net/DcOptions.h"
#include "td/telegram/net/DcOptionsSet.h"
#include "td/telegram/net/NetQuery.h"
#include "td/telegram/StateManager.h"
#include "td/mtproto/IStreamTransport.h"
@ -148,7 +149,7 @@ inline bool operator!=(const Proxy &lhs, const Proxy &rhs) {
return !(lhs == rhs);
}
class ConnectionCreator : public Actor {
class ConnectionCreator : public NetQueryCallback {
public:
explicit ConnectionCreator(ActorShared<> parent);
ConnectionCreator(ConnectionCreator &&other);
@ -180,6 +181,9 @@ class ConnectionCreator : public Actor {
Timestamp resolve_proxy_timestamp_;
uint64 resolve_proxy_query_token_{0};
uint64 get_proxy_info_query_token_{0};
Timestamp get_proxy_info_timestamp_;
struct ClientInfo {
class Backoff {
#if TD_ANDROID || TD_DARWIN_IOS || TD_DARWIN_WATCH_OS || TD_TIZEN
@ -233,10 +237,10 @@ class ConnectionCreator : public Actor {
int ref_cnt_{0};
ActorShared<ConnectionCreator> create_reference(int64 token);
bool close_flag_{false};
int64 current_token_ = 0;
uint64 current_token_ = 0;
std::map<int64, ActorShared<>> children_;
int64 next_token() {
uint64 next_token() {
return ++current_token_;
}
void set_proxy_impl(Proxy proxy, bool from_db);
@ -246,6 +250,8 @@ class ConnectionCreator : public Actor {
void hangup() override;
void loop() override;
void on_result(NetQueryPtr query) override;
void save_dc_options();
Result<SocketFd> do_request_connection(DcId dc_id, bool allow_media_only);
Result<std::pair<std::unique_ptr<mtproto::RawConnection>, bool>> do_request_raw_connection(DcId dc_id,
@ -270,6 +276,10 @@ class ConnectionCreator : public Actor {
bool check_flag);
void client_set_timeout_at(ClientInfo &client, double wakeup_at);
void on_get_proxy_info(telegram_api::object_ptr<telegram_api::help_ProxyData> proxy_data_ptr);
void schedule_get_proxy_info(int32 expires);
void on_proxy_resolved(Result<IPAddress> ip_address, bool dummy);
static DcOptions get_default_dc_options(bool is_test);

15
td/telegram/net/MtprotoHeader.h
View File

@ -24,8 +24,13 @@ class MtprotoHeader {
Proxy proxy;
};
explicit MtprotoHeader(const Options &options)
: default_header_(gen_header(options, false)), anonymous_header_(gen_header(options, true)) {
explicit MtprotoHeader(const Options &options) : options_(options) {
gen_headers();
}
void set_proxy(Proxy proxy) {
options_.proxy = proxy;
default_header_ = gen_header(options_, false);
}
Slice get_default_header() const {
@ -36,9 +41,15 @@ class MtprotoHeader {
}
private:
Options options_;
string default_header_;
string anonymous_header_;
void gen_headers() {
default_header_ = gen_header(options_, false);
anonymous_header_ = gen_header(options_, true);
}
static string gen_header(const Options &options, bool is_anonymous);
};