// // Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2026 // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #include "td/telegram/LinkManager.h" #include "td/telegram/AccessRights.h" #include "td/telegram/BackgroundType.h" #include "td/telegram/ChannelId.h" #include "td/telegram/ChannelType.h" #include "td/telegram/ChatManager.h" #include "td/telegram/ConfigManager.h" #include "td/telegram/DialogId.h" #include "td/telegram/DialogInviteLinkManager.h" #include "td/telegram/DialogManager.h" #include "td/telegram/DialogParticipant.h" #include "td/telegram/Global.h" #include "td/telegram/LanguagePackManager.h" #include "td/telegram/MessageEntity.h" #include "td/telegram/MessageId.h" #include "td/telegram/MessagesManager.h" #include "td/telegram/misc.h" #include "td/telegram/net/Proxy.h" #include "td/telegram/OptionManager.h" #include "td/telegram/ServerMessageId.h" #include "td/telegram/StarGiftCollectionId.h" #include "td/telegram/StickersManager.h" #include "td/telegram/StoryAlbumId.h" #include "td/telegram/StoryId.h" #include "td/telegram/Td.h" #include "td/telegram/TdDb.h" #include "td/telegram/telegram_api.h" #include "td/telegram/UserId.h" #include "td/telegram/UserManager.h" #include "td/mtproto/ProxySecret.h" #include "td/utils/algorithm.h" #include "td/utils/base64.h" #include "td/utils/buffer.h" #include "td/utils/FlatHashSet.h" #include "td/utils/HttpUrl.h" #include "td/utils/logging.h" #include "td/utils/misc.h" #include "td/utils/SliceBuilder.h" #include "td/utils/StringBuilder.h" #include "td/utils/Time.h" #include "td/utils/utf8.h" #include namespace td { static bool is_valid_start_parameter(Slice start_parameter) { return is_base64url_characters(start_parameter); } static bool is_valid_video_chat_invite_hash(Slice invite_hash) { return is_base64url_characters(invite_hash); } static bool is_valid_phone_number(Slice phone_number) { if (phone_number.empty() || phone_number.size() > 32) { return false; } for (auto c : phone_number) { if (!is_digit(c)) { return false; } } return true; } static bool is_valid_phone_number_hash(Slice hash) { if (hash.empty() || hash.size() > 32) { return false; } for (auto c : hash) { if (!is_hex_digit(c)) { return false; } } return true; } static bool is_valid_game_name(Slice name) { return name.size() >= 3 && is_valid_username(name); } static bool is_valid_text_composition_style_name(CSlice name) { return name.size() >= 8u && is_base64url_characters(name); } static bool is_valid_theme_name(CSlice name) { return !name.empty() && check_utf8(name); } static bool is_valid_web_app_name(Slice name) { return name.size() >= 3 && is_valid_username(name); } static bool is_valid_sticker_set_name(Slice name) { return !name.empty() && is_base64url_characters(name); } static bool is_valid_language_pack_id(Slice language_pack_id) { return !language_pack_id.empty() && LanguagePackManager::check_language_code_name(language_pack_id); } static bool is_valid_upgraded_gift_name(CSlice name) { if (name.empty()) { return false; } if (!check_utf8(name)) { return false; } return true; } static bool is_valid_user_token(CSlice token) { return !token.empty() && check_utf8(token); } static bool is_valid_login_code(CSlice code) { return !code.empty() && check_utf8(code); } static bool is_valid_premium_referrer(CSlice referrer) { return check_utf8(referrer); } static bool is_valid_proxy_server(CSlice server) { return !server.empty() && server.size() <= 255u && check_utf8(server); } static bool is_valid_proxy_username(CSlice username) { return check_utf8(username); } static bool is_valid_proxy_password(CSlice password) { return check_utf8(password); } static bool is_valid_invoice_name(CSlice invoice_name) { return !invoice_name.empty() && check_utf8(invoice_name); } static bool is_valid_gift_code(CSlice gift_code) { return !gift_code.empty() && check_utf8(gift_code); } static bool is_valid_business_link_name(CSlice link_name) { return !link_name.empty() && check_utf8(link_name); } static bool is_valid_star_top_up_purpose(CSlice purpose) { return check_utf8(purpose); } static bool is_valid_story_id(Slice story_id) { auto r_story_id = to_integer_safe(story_id); return r_story_id.is_ok() && StoryId(r_story_id.ok()).is_server(); } static bool is_valid_star_gift_collection_id(Slice collection_id) { auto r_collection_id = to_integer_safe(collection_id); return r_collection_id.is_ok() && StarGiftCollectionId(r_collection_id.ok()).is_valid(); } static bool is_valid_story_album_id(Slice story_album_id) { auto r_story_album_id = to_integer_safe(story_album_id); return r_story_album_id.is_ok() && StoryAlbumId(r_story_album_id.ok()).is_valid(); } static const vector &get_appearance_settings_subsections() { static const vector subsections{ "themes", "themes/edit", "themes/create", "wallpapers", "wallpapers/edit", "wallpapers/set", "wallpapers/choose-photo", "your-color/profile", "your-color/profile/add-icons", "your-color/profile/use-gift", "your-color/profile/reset", "your-color/name", "your-color/name/add-icons", "your-color/name/use-gift", "night-mode", "auto-night-mode", "text-size", "text-size/use-system", "message-corners", "animations", "stickers-and-emoji", "stickers-and-emoji/edit", "stickers-and-emoji/trending", "stickers-and-emoji/archived", "stickers-and-emoji/archived/edit", "stickers-and-emoji/emoji", "stickers-and-emoji/emoji/edit", "stickers-and-emoji/emoji/archived", "stickers-and-emoji/emoji/archived/edit", "stickers-and-emoji/emoji/suggest", "stickers-and-emoji/emoji/quick-reaction", "stickers-and-emoji/emoji/quick-reaction/choose", "stickers-and-emoji/suggest-by-emoji", "stickers-and-emoji/large-emoji", "stickers-and-emoji/dynamic-order", "stickers-and-emoji/emoji/show-more", "app-icon", // no formatting "tap-for-next-media"}; return subsections; } static const vector &get_business_settings_subsections() { static const vector subsections{"do-not-hide-ads"}; return subsections; } static const vector &get_data_settings_subsections() { static const vector subsections{ "storage", "storage/edit", "storage/auto-remove", "storage/clear-cache", "storage/max-cache", "usage", "usage/mobile", "usage/wifi", "usage/reset", "usage/roaming", "auto-download/mobile", "auto-download/mobile/enable", "auto-download/mobile/usage", "auto-download/mobile/photos", "auto-download/mobile/stories", "auto-download/mobile/videos", "auto-download/mobile/files", "auto-download/wifi", "auto-download/wifi/enable", "auto-download/wifi/usage", "auto-download/wifi/photos", "auto-download/wifi/stories", "auto-download/wifi/videos", "auto-download/wifi/files", "auto-download/roaming", "auto-download/roaming/enable", "auto-download/roaming/usage", "auto-download/roaming/photos", "auto-download/roaming/stories", "auto-download/roaming/videos", "auto-download/roaming/files", "auto-download/reset", "save-to-photos/chats", "save-to-photos/chats/max-video-size", "save-to-photos/chats/add-exception", "save-to-photos/chats/delete-all", "save-to-photos/groups", "save-to-photos/groups/max-video-size", "save-to-photos/groups/add-exception", "save-to-photos/groups/delete-all", "save-to-photos/channels", "save-to-photos/channels/max-video-size", "save-to-photos/channels/add-exception", "save-to-photos/channels/delete-all", "less-data-calls", "open-links", "share-sheet", "share-sheet/suggested-chats", "share-sheet/suggest-by", "share-sheet/reset", "saved-edited-photos", "pause-music", "raise-to-listen", "raise-to-speak", "show-18-content", "proxy", "proxy/edit", "proxy/use-proxy", "proxy/add-proxy", "proxy/share-list", // no formatting "proxy/use-for-calls"}; return subsections; } static const vector &get_device_settings_subsections() { static const vector subsections{"edit", "link-desktop", "terminate-sessions", "auto-terminate"}; return subsections; } static const vector &get_edit_profile_settings_subsections() { static const vector subsections{"set-photo", "first-name", "last-name", "bio", "birthday", "change-number", "username", "your-color", "channel", "add-account", "log-out"}; return subsections; } static const vector &get_edit_profile_other_settings_subsections() { static const vector subsections{"emoji-status", "profile-color/profile", "profile-color/profile/add-icons", "profile-color/profile/use-gift", "profile-color/name", "profile-color/name/add-icons", "profile-color/name/use-gift", // no formatting "profile-photo/use-emoji"}; return subsections; } static const vector &get_folder_settings_subsections() { static const vector subsections{"edit", "create", "add-recommended", "show-tags", "tab-view"}; return subsections; } static const vector &get_in_app_browser_settings_subsections() { static const vector subsections{"enable-browser", "clear-cookies", "clear-cache", "history", "clear-history", "never-open", "clear-list", "search"}; return subsections; } static const vector &get_language_settings_subsections() { static const vector subsections{"show-button", "translate-chats", "do-not-translate"}; return subsections; } static const vector &get_my_stars_settings_subsections() { static const vector subsections{"top-up", "stats", "gift", "earn"}; return subsections; } static const vector &get_notification_settings_subsections() { static const vector subsections{ "accounts", "private-chats", "private-chats/edit", "private-chats/show", "private-chats/preview", "private-chats/sound", "private-chats/add-exception", "private-chats/delete-exceptions", "private-chats/light-color", "private-chats/vibrate", "private-chats/priority", "groups", "groups/edit", "groups/show", "groups/preview", "groups/sound", "groups/add-exception", "groups/delete-exceptions", "groups/light-color", "groups/vibrate", "groups/priority", "channels", "channels/edit", "channels/show", "channels/preview", "channels/sound", "channels/add-exception", "channels/delete-exceptions", "channels/light-color", "channels/vibrate", "channels/priority", "stories", "stories/new", "stories/important", "stories/show-sender", "stories/sound", "stories/add-exception", "stories/delete-exceptions", "stories/light-color", "stories/vibrate", "stories/priority", "reactions", "reactions/messages", "reactions/stories", "reactions/show-sender", "reactions/sound", "reactions/light-color", "reactions/vibrate", "reactions/priority", "in-app-sounds", "in-app-vibrate", "in-app-preview", "in-chat-sounds", "in-app-popup", "lock-screen-names", "include-channels", "include-muted-chats", "count-unread-messages", "new-contacts", "pinned-messages", "reset", // no formatting "web"}; return subsections; } static const vector &get_power_saving_settings_subsections() { static const vector subsections{"videos", "gifs", "stickers", "emoji", "effects", "preload", "background", "call-animations", "particles", // no formatting "transitions"}; return subsections; } static const vector &get_privacy_settings_subsections() { static const vector subsections{ "blocked", "blocked/edit", "blocked/block-user", "blocked/block-user/chats", "blocked/block-user/contacts", "active-websites", "active-websites/edit", "active-websites/disconnect-all", "passcode", "passcode/disable", "passcode/change", "passcode/auto-lock", "passcode/face-id", "passcode/fingerprint", "2sv", "2sv/change", "2sv/disable", "2sv/change-email", "passkey", "passkey/create", "auto-delete", "auto-delete/set-custom", "login-email", "phone-number", "phone-number/never", "phone-number/always", "last-seen", "last-seen/never", "last-seen/always", "last-seen/hide-read-time", "profile-photos", "profile-photos/never", "profile-photos/always", "profile-photos/set-public", "profile-photos/update-public", "profile-photos/remove-public", "bio", "bio/never", "bio/always", "gifts", "gifts/show-icon", "gifts/never", "gifts/always", "gifts/accepted-types", "birthday", "birthday/add", "birthday/never", "birthday/always", "saved-music", "saved-music/never", "saved-music/always", "forwards", "forwards/never", "forwards/always", "calls", "calls/never", "calls/always", "calls/p2p", "calls/p2p/never", "calls/p2p/always", "calls/ios-integration", "voice", "voice/never", "voice/always", "messages", "messages/set-price", "messages/exceptions", "invites", "invites/never", "invites/always", "self-destruct", "data-settings", "data-settings/sync-contacts", "data-settings/delete-synced", "data-settings/suggest-contacts", "data-settings/delete-cloud-drafts", "data-settings/clear-payment-info", "data-settings/link-previews", "data-settings/bot-settings", "data-settings/map-provider", // no formatting "archive-and-mute"}; return subsections; } static const vector &get_qr_code_settings_subsections() { static const vector subsections{"share", "scan"}; return subsections; } static const vector &get_send_gift_settings_subsections() { static const vector subsections{"self"}; return subsections; } static const vector &get_calls_sections() { static const vector sections{"all", "missed", "edit", "show-tab", "start-call"}; return sections; } static const vector &get_contacts_sections() { static const vector sections{"search", "sort", "new", "invite", "manage"}; return sections; } static const vector &get_my_profile_sections() { static const vector sections{"posts", "posts/all-stories", "posts/add-album", "gifts", "archived-posts"}; return sections; } static string get_url_query_hash(bool is_tg, const HttpUrlQuery &url_query) { const auto &path = url_query.path_; if (is_tg) { if (path.size() == 1 && path[0] == "join") { // join?invite= return url_query.get_arg("invite").str(); } } else { if (path.size() >= 2 && path[0] == "joinchat") { // /joinchat/ return path[1]; } if (!path.empty() && path[0].size() >= 2 && (path[0][0] == ' ' || path[0][0] == '+')) { // /+ return path[0].substr(1); } } return string(); } static string get_url_query_slug(bool is_tg, const HttpUrlQuery &url_query, Slice link_name) { const auto &path = url_query.path_; if (is_tg) { if (path.size() == 1 && path[0] == link_name) { // {link_name}?slug= return url_query.get_arg("slug").str(); } } else { if (path.size() >= 2 && path[0] == link_name) { // /{link_name}/ return path[1]; } } return string(); } static string get_url_query_draft_text(const HttpUrlQuery &url_query) { auto text_slice = url_query.get_arg("text"); if (text_slice.empty()) { return string(); } auto text = text_slice.str(); if (!check_utf8(text)) { return string(); } text = utf8_truncate(std::move(text), 4096u); if (text[0] == '@') { return ' ' + text; } return text; } static vector get_referral_program_start_parameter_prefixes() { if (Scheduler::context() != nullptr) { return full_split(G()->get_option_string("starref_start_param_prefixes", "_tgr_"), ' '); } return vector{"_tgr_"}; } static AdministratorRights get_administrator_rights(Slice rights, bool for_channel) { bool can_manage_dialog = false; bool can_change_info = false; bool can_post_messages = false; bool can_edit_messages = false; bool can_delete_messages = false; bool can_invite_users = false; bool can_restrict_members = false; bool can_pin_messages = false; bool can_manage_topics = false; bool can_promote_members = false; bool can_manage_calls = false; bool can_post_stories = false; bool can_edit_stories = false; bool can_delete_stories = false; bool can_manage_direct_messages = false; bool can_manage_ranks = false; bool is_anonymous = false; for (auto right : full_split(rights, ' ')) { if (right == "change_info") { can_change_info = true; } else if (right == "post_messages") { can_post_messages = true; } else if (right == "edit_messages") { can_edit_messages = true; } else if (right == "delete_messages") { can_delete_messages = true; } else if (right == "restrict_members") { can_restrict_members = true; } else if (right == "invite_users") { can_invite_users = true; } else if (right == "pin_messages") { can_pin_messages = true; } else if (right == "manage_topics") { can_manage_topics = true; } else if (right == "promote_members") { can_promote_members = true; } else if (right == "manage_video_chats") { can_manage_calls = true; } else if (right == "post_stories") { can_post_stories = true; } else if (right == "edit_stories") { can_edit_stories = true; } else if (right == "delete_stories") { can_delete_stories = true; } else if (right == "manage_direct_messages") { can_manage_direct_messages = true; } else if (right == "manage_tags") { can_manage_ranks = true; } else if (right == "anonymous") { is_anonymous = true; } else if (right == "manage_chat") { can_manage_dialog = true; } } return AdministratorRights(is_anonymous, can_manage_dialog, can_change_info, can_post_messages, can_edit_messages, can_delete_messages, can_invite_users, can_restrict_members, can_pin_messages, can_manage_topics, can_promote_members, can_manage_calls, can_post_stories, can_edit_stories, can_delete_stories, can_manage_direct_messages, can_manage_ranks, false, for_channel ? ChannelType::Broadcast : ChannelType::Megagroup); } static string get_admin_string(AdministratorRights rights) { vector admin_rights; if (rights.can_change_info_and_settings()) { admin_rights.emplace_back("change_info"); } if (rights.can_post_messages()) { admin_rights.emplace_back("post_messages"); } if (rights.can_edit_messages()) { admin_rights.emplace_back("edit_messages"); } if (rights.can_delete_messages()) { admin_rights.emplace_back("delete_messages"); } if (rights.can_restrict_members()) { admin_rights.emplace_back("restrict_members"); } if (rights.can_invite_users()) { admin_rights.emplace_back("invite_users"); } if (rights.can_pin_messages()) { admin_rights.emplace_back("pin_messages"); } if (rights.can_manage_topics()) { admin_rights.emplace_back("manage_topics"); } if (rights.can_promote_members()) { admin_rights.emplace_back("promote_members"); } if (rights.can_manage_calls()) { admin_rights.emplace_back("manage_video_chats"); } if (rights.can_post_stories()) { admin_rights.emplace_back("post_stories"); } if (rights.can_edit_stories()) { admin_rights.emplace_back("edit_stories"); } if (rights.can_delete_stories()) { admin_rights.emplace_back("delete_stories"); } if (rights.can_manage_direct_messages()) { admin_rights.emplace_back("manage_direct_messages"); } if (rights.can_manage_ranks()) { admin_rights.emplace_back("manage_tags"); } if (rights.is_anonymous()) { admin_rights.emplace_back("anonymous"); } if (rights.can_manage_dialog()) { admin_rights.emplace_back("manage_chat"); } if (admin_rights.empty()) { return string(); } return "&admin=" + implode(admin_rights, '+'); } static td_api::object_ptr get_target_chat_types(Slice chat_types) { bool allow_users = false; bool allow_bots = false; bool allow_groups = false; bool allow_channels = false; for (auto chat_type : full_split(chat_types, ' ')) { if (chat_type == "users") { allow_users = true; } else if (chat_type == "bots") { allow_bots = true; } else if (chat_type == "groups") { allow_groups = true; } else if (chat_type == "channels") { allow_channels = true; } } if (!allow_users && !allow_bots && !allow_groups && !allow_channels) { return nullptr; } return td_api::make_object(allow_users, allow_bots, allow_groups, allow_channels); } static td_api::object_ptr get_web_app_open_mode_object(const string &mode) { if (mode == "compact") { return td_api::make_object(); } if (mode == "fullscreen") { return td_api::make_object(); } return td_api::make_object(); } class LinkManager::InternalLinkAttachMenuBot final : public InternalLink { td_api::object_ptr allowed_chat_types_; unique_ptr dialog_link_; string bot_username_; string url_; td_api::object_ptr get_internal_link_type_object() const final { td_api::object_ptr target_chat; if (dialog_link_ != nullptr) { target_chat = td_api::make_object(dialog_link_->get_internal_link_type_object()); } else if (allowed_chat_types_ != nullptr) { target_chat = td_api::make_object(td_api::make_object( allowed_chat_types_->allow_user_chats_, allowed_chat_types_->allow_bot_chats_, allowed_chat_types_->allow_group_chats_, allowed_chat_types_->allow_channel_chats_)); } else { target_chat = td_api::make_object(); } return td_api::make_object(std::move(target_chat), bot_username_, url_); } public: InternalLinkAttachMenuBot(td_api::object_ptr allowed_chat_types, unique_ptr dialog_link, string bot_username, Slice start_parameter) : allowed_chat_types_(std::move(allowed_chat_types)) , dialog_link_(std::move(dialog_link)) , bot_username_(std::move(bot_username)) { if (!start_parameter.empty() && is_valid_start_parameter(start_parameter)) { url_ = PSTRING() << "start://" << start_parameter; } } }; class LinkManager::InternalLinkAuthenticationCode final : public InternalLink { string code_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(code_); } public: explicit InternalLinkAuthenticationCode(string &&code) : code_(std::move(code)) { } }; class LinkManager::InternalLinkBackground final : public InternalLink { string background_name_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(background_name_); } public: explicit InternalLinkBackground(string background_name) : background_name_(std::move(background_name)) { } }; class LinkManager::InternalLinkBotAddToChannel final : public InternalLink { string bot_username_; AdministratorRights administrator_rights_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object( bot_username_, administrator_rights_.get_chat_administrator_rights_object()); } public: InternalLinkBotAddToChannel(string bot_username, AdministratorRights &&administrator_rights) : bot_username_(std::move(bot_username)), administrator_rights_(std::move(administrator_rights)) { } }; class LinkManager::InternalLinkBotStart final : public InternalLink { string bot_username_; string start_parameter_; bool autostart_; td_api::object_ptr get_internal_link_type_object() const final { bool autostart = autostart_; if (Scheduler::context() != nullptr && !autostart) { if (bot_username_ == G()->get_option_string("premium_bot_username")) { autostart = true; } else { const Td *td = G()->td().get_actor_unsafe(); auto dialog_id = td->dialog_manager_->get_resolved_dialog_by_username(bot_username_); if (dialog_id.get_type() == DialogType::User && td->messages_manager_->get_dialog_has_last_message(dialog_id) && !td->messages_manager_->is_dialog_blocked(dialog_id)) { autostart = true; } } } return td_api::make_object(bot_username_, start_parameter_, autostart); } public: InternalLinkBotStart(string bot_username, string start_parameter, bool autostart) : bot_username_(std::move(bot_username)), start_parameter_(std::move(start_parameter)), autostart_(autostart) { } }; class LinkManager::InternalLinkBotStartInGroup final : public InternalLink { string bot_username_; string start_parameter_; AdministratorRights administrator_rights_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object( bot_username_, start_parameter_, administrator_rights_ == AdministratorRights() ? nullptr : administrator_rights_.get_chat_administrator_rights_object()); } public: InternalLinkBotStartInGroup(string bot_username, string start_parameter, AdministratorRights &&administrator_rights) : bot_username_(std::move(bot_username)) , start_parameter_(std::move(start_parameter)) , administrator_rights_(std::move(administrator_rights)) { } }; class LinkManager::InternalLinkBusinessChat final : public InternalLink { string link_name_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(link_name_); } public: explicit InternalLinkBusinessChat(string link_name) : link_name_(std::move(link_name)) { } }; class LinkManager::InternalLinkBuyStars final : public InternalLink { int64 star_count_; string purpose_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(star_count_, purpose_); } public: InternalLinkBuyStars(int64 star_count, string purpose) : star_count_(clamp(star_count, static_cast(1), static_cast(1000000000000))) , purpose_(std::move(purpose)) { } }; class LinkManager::InternalLinkCalls final : public InternalLink { string section_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(section_); } public: explicit InternalLinkCalls(string section) : section_(std::move(section)) { } }; class LinkManager::InternalLinkConfirmPhone final : public InternalLink { string hash_; string phone_number_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(hash_, phone_number_); } public: InternalLinkConfirmPhone(string hash, string phone_number) : hash_(std::move(hash)), phone_number_(std::move(phone_number)) { } }; class LinkManager::InternalLinkContacts final : public InternalLink { string section_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(section_); } public: explicit InternalLinkContacts(string section) : section_(std::move(section)) { } }; class LinkManager::InternalLinkDialogBoost final : public InternalLink { string url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(url_); } public: explicit InternalLinkDialogBoost(string url) : url_(std::move(url)) { } }; class LinkManager::InternalLinkDialogFolderInvite final : public InternalLink { string url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(url_); } public: explicit InternalLinkDialogFolderInvite(string url) : url_(std::move(url)) { } }; class LinkManager::InternalLinkDialogInvite final : public InternalLink { string url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(url_); } public: explicit InternalLinkDialogInvite(string url) : url_(std::move(url)) { } }; class LinkManager::InternalLinkDialogReferralProgram final : public InternalLink { string username_; string referral_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(username_, referral_); } public: InternalLinkDialogReferralProgram(string username, string referral) : username_(std::move(username)), referral_(std::move(referral)) { } }; class LinkManager::InternalLinkDialogSelection final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkGame final : public InternalLink { string bot_username_; string game_short_name_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(bot_username_, game_short_name_); } public: InternalLinkGame(string bot_username, string game_short_name) : bot_username_(std::move(bot_username)), game_short_name_(std::move(game_short_name)) { } }; class LinkManager::InternalLinkGiftAuction final : public InternalLink { string slug_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(slug_); } public: explicit InternalLinkGiftAuction(string slug) : slug_(std::move(slug)) { } }; class LinkManager::InternalLinkGroupCall final : public InternalLink { string url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(url_); } public: explicit InternalLinkGroupCall(string url) : url_(std::move(url)) { } }; class LinkManager::InternalLinkInstantView final : public InternalLink { string url_; string fallback_url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(url_, fallback_url_); } public: InternalLinkInstantView(string url, string fallback_url) : url_(std::move(url)), fallback_url_(std::move(fallback_url)) { } }; class LinkManager::InternalLinkInvoice final : public InternalLink { string invoice_name_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(invoice_name_); } public: explicit InternalLinkInvoice(string invoice_name) : invoice_name_(std::move(invoice_name)) { } }; class LinkManager::InternalLinkLanguage final : public InternalLink { string language_pack_id_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(language_pack_id_); } public: explicit InternalLinkLanguage(string &&language_pack_id) : language_pack_id_(std::move(language_pack_id)) { } }; class LinkManager::InternalLinkLiveStory final : public InternalLink { string dialog_username_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(dialog_username_); } public: explicit InternalLinkLiveStory(string dialog_username) : dialog_username_(std::move(dialog_username)) { } }; class LinkManager::InternalLinkMainWebApp final : public InternalLink { string bot_username_; string start_parameter_; string mode_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(bot_username_, start_parameter_, get_web_app_open_mode_object(mode_)); } public: InternalLinkMainWebApp(string bot_username, string start_parameter, string mode) : bot_username_(std::move(bot_username)), start_parameter_(std::move(start_parameter)), mode_(std::move(mode)) { } }; class LinkManager::InternalLinkMessage final : public InternalLink { string url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(url_); } public: explicit InternalLinkMessage(string url) : url_(std::move(url)) { } }; class LinkManager::InternalLinkMessageDraft final : public InternalLink { FormattedText text_; bool contains_link_ = false; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object( get_formatted_text_object(nullptr, text_, true, -1), contains_link_); } public: InternalLinkMessageDraft(FormattedText &&text, bool contains_link) : text_(std::move(text)), contains_link_(contains_link) { } }; class LinkManager::InternalLinkMonoforum final : public InternalLink { string channel_username_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(channel_username_); } public: explicit InternalLinkMonoforum(string channel_username) : channel_username_(std::move(channel_username)) { } }; class LinkManager::InternalLinkMyProfile final : public InternalLink { string section_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(section_); } public: explicit InternalLinkMyProfile(string section) : section_(std::move(section)) { } }; class LinkManager::InternalLinkNewChannelChat final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkNewGroupChat final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkNewPrivateChat final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkOauth final : public InternalLink { string url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(url_); } public: explicit InternalLinkOauth(string url) : url_(std::move(url)) { } }; class LinkManager::InternalLinkPassportDataRequest final : public InternalLink { UserId bot_user_id_; string scope_; string public_key_; string nonce_; string callback_url_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(bot_user_id_.get(), scope_, public_key_, nonce_, callback_url_); } public: InternalLinkPassportDataRequest(UserId bot_user_id, string scope, string public_key, string nonce, string callback_url) : bot_user_id_(bot_user_id) , scope_(std::move(scope)) , public_key_(std::move(public_key)) , nonce_(std::move(nonce)) , callback_url_(std::move(callback_url)) { } }; class LinkManager::InternalLinkPostStory final : public InternalLink { string content_type_; td_api::object_ptr get_internal_link_type_object() const final { auto content_type = [&]() -> td_api::object_ptr { if (content_type_ == "photo") { return td_api::make_object(); } if (content_type_ == "video") { return td_api::make_object(); } if (content_type_ == "live") { return td_api::make_object(); } if (!content_type_.empty()) { return td_api::make_object(); } return nullptr; }(); return td_api::make_object(std::move(content_type)); } public: explicit InternalLinkPostStory(string content_type) : content_type_(std::move(content_type)) { } }; class LinkManager::InternalLinkPremiumFeatures final : public InternalLink { string referrer_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(referrer_); } public: explicit InternalLinkPremiumFeatures(string &&referrer) : referrer_(std::move(referrer)) { } }; class LinkManager::InternalLinkPremiumGift final : public InternalLink { string referrer_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(referrer_); } public: explicit InternalLinkPremiumGift(string &&referrer) : referrer_(std::move(referrer)) { } }; class LinkManager::InternalLinkPremiumGiftCode final : public InternalLink { string code_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(code_); } public: explicit InternalLinkPremiumGiftCode(string code) : code_(std::move(code)) { } }; class LinkManager::InternalLinkProxy final : public InternalLink { string server_; int32 port_; td_api::object_ptr type_; td_api::object_ptr get_internal_link_type_object() const final { auto type = type_.get(); if (type == nullptr) { return td_api::make_object(); } auto proxy_type = [type]() -> td_api::object_ptr { switch (type->get_id()) { case td_api::proxyTypeSocks5::ID: { auto type_socks = static_cast(type); return td_api::make_object(type_socks->username_, type_socks->password_); } case td_api::proxyTypeMtproto::ID: { auto type_mtproto = static_cast(type); return td_api::make_object(type_mtproto->secret_); } default: UNREACHABLE(); return nullptr; } }(); return td_api::make_object( td_api::make_object(server_, port_, std::move(proxy_type))); } public: InternalLinkProxy(string server, int32 port, td_api::object_ptr type) : server_(std::move(server)), port_(port), type_(std::move(type)) { } }; class LinkManager::InternalLinkPublicDialog final : public InternalLink { string dialog_username_; string draft_text_; bool open_profile_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(dialog_username_, draft_text_, open_profile_); } public: InternalLinkPublicDialog(string dialog_username, string draft_text, bool open_profile) : dialog_username_(std::move(dialog_username)), draft_text_(std::move(draft_text)), open_profile_(open_profile) { } }; class LinkManager::InternalLinkQrCodeAuthentication final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkRequestManagedBot final : public InternalLink { string manager_bot_username_; string bot_username_; string bot_name_; td_api::object_ptr get_internal_link_type_object() const final { auto size = bot_username_.size(); if (size < 3u || to_lower(bot_username_[size - 3]) != 'b' || to_lower(bot_username_[size - 2]) != 'o' || to_lower(bot_username_[size - 1]) != 't') { return td_api::make_object( manager_bot_username_, PSTRING() << bot_username_ << "bot", bot_name_); } return td_api::make_object(manager_bot_username_, bot_username_, bot_name_); } public: InternalLinkRequestManagedBot(string &&manager_bot_username, string &&bot_username, string &&bot_name) : manager_bot_username_(std::move(manager_bot_username)) , bot_username_(std::move(bot_username)) , bot_name_(std::move(bot_name)) { } }; class LinkManager::InternalLinkRestorePurchases final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkSavedMessages final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkSearch final : public InternalLink { td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(); } }; class LinkManager::InternalLinkSettings final : public InternalLink { vector path_; td_api::object_ptr get_internal_link_type_object() const final { auto section = [&]() -> td_api::object_ptr { if (path_.empty()) { return nullptr; } string subsection; if (path_.size() >= 2u) { subsection = path_[1]; for (size_t i = 2; i < path_.size(); i++) { subsection += '/'; subsection += path_[i]; } } if (path_[0] == "appearance") { if (td::contains(get_appearance_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "ask-question") { return td_api::make_object(); } if (path_[0] == "auto_delete") { return td_api::make_object("auto-delete"); } if (path_[0] == "business") { if (td::contains(get_business_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "change_number") { return td_api::make_object("change-number"); } if (path_[0] == "chat" && path_.size() >= 2u && path_[1] == "browser") { if (path_.size() == 2u) { subsection = string(); } else { subsection = path_[2]; } if (td::contains(get_in_app_browser_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "data") { if (td::contains(get_data_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "devices") { if (td::contains(get_device_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "edit") { if (td::contains(get_edit_profile_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "edit_profile") { return td_api::make_object(); } if (path_[0] == "emoji-status" || path_[0] == "profile-color" || path_[0] == "profile-photo") { if (subsection.empty()) { subsection = path_[0]; } else { subsection = PSTRING() << path_[0] << '/' << subsection; } if (td::contains(get_edit_profile_other_settings_subsections(), subsection)) { return td_api::make_object(subsection); } if (path_[0] == "emoji-status") { return td_api::make_object(path_[0]); } return td_api::make_object(); } if (path_[0] == "faq") { return td_api::make_object(); } if (path_[0] == "features") { return td_api::make_object(); } if (path_[0] == "folders") { if (td::contains(get_folder_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "language") { if (td::contains(get_language_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "login_email") { return td_api::make_object("login-email"); } if (path_[0] == "notifications") { if (td::contains(get_notification_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "power-saving") { if (td::contains(get_power_saving_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "password") { return td_api::make_object("2sv"); } if (path_[0] == "phone_privacy") { return td_api::make_object("phone-number"); } if (path_[0] == "premium") { return td_api::make_object(); } if (path_[0] == "privacy") { if (td::contains(get_privacy_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "privacy-policy") { return td_api::make_object(); } if (path_[0] == "qr-code") { if (td::contains(get_qr_code_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "search") { return td_api::make_object(); } if (path_[0] == "send-gift") { if (td::contains(get_send_gift_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "stars") { if (td::contains(get_my_stars_settings_subsections(), subsection)) { return td_api::make_object(subsection); } return td_api::make_object(); } if (path_[0] == "themes") { return td_api::make_object(); } if (path_[0] == "grams" || path_[0] == "ton") { return td_api::make_object(); } return nullptr; }(); return td_api::make_object(std::move(section)); } public: explicit InternalLinkSettings(vector &&path) : path_(std::move(path)) { } }; class LinkManager::InternalLinkStickerSet final : public InternalLink { string sticker_set_name_; bool expect_custom_emoji_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(sticker_set_name_, expect_custom_emoji_); } public: InternalLinkStickerSet(string &&sticker_set_name, bool expect_custom_emoji) : sticker_set_name_(std::move(sticker_set_name)), expect_custom_emoji_(expect_custom_emoji) { } }; class LinkManager::InternalLinkStarGiftCollection final : public InternalLink { string gift_owner_username_; StarGiftCollectionId collection_id_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(gift_owner_username_, collection_id_.get()); } public: InternalLinkStarGiftCollection(string gift_owner_username, StarGiftCollectionId collection_id) : gift_owner_username_(std::move(gift_owner_username)), collection_id_(collection_id) { } }; class LinkManager::InternalLinkStory final : public InternalLink { string story_poster_username_; StoryId story_id_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(story_poster_username_, story_id_.get()); } public: InternalLinkStory(string story_poster_username, StoryId story_id) : story_poster_username_(std::move(story_poster_username)), story_id_(story_id) { } }; class LinkManager::InternalLinkStoryAlbum final : public InternalLink { string story_album_owner_username_; StoryAlbumId story_album_id_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(story_album_owner_username_, story_album_id_.get()); } public: InternalLinkStoryAlbum(string story_album_owner_username, StoryAlbumId story_album_id) : story_album_owner_username_(std::move(story_album_owner_username)), story_album_id_(story_album_id) { } }; class LinkManager::InternalLinkTextCompositionStyle final : public InternalLink { string style_name_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(style_name_); } public: explicit InternalLinkTextCompositionStyle(string &&style_name) : style_name_(std::move(style_name)) { } }; class LinkManager::InternalLinkTheme final : public InternalLink { string theme_name_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(theme_name_); } public: explicit InternalLinkTheme(string &&theme_name) : theme_name_(std::move(theme_name)) { } }; class LinkManager::InternalLinkUnknownDeepLink final : public InternalLink { string link_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(link_); } public: explicit InternalLinkUnknownDeepLink(string link) : link_(std::move(link)) { } }; class LinkManager::InternalLinkUserPhoneNumber final : public InternalLink { string phone_number_; string draft_text_; bool open_profile_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(phone_number_, draft_text_, open_profile_); } public: InternalLinkUserPhoneNumber(Slice phone_number, string draft_text, bool open_profile) : phone_number_(PSTRING() << '+' << phone_number) , draft_text_(std::move(draft_text)) , open_profile_(open_profile) { } }; class LinkManager::InternalLinkUpgradedGift final : public InternalLink { string name_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(name_); } public: explicit InternalLinkUpgradedGift(string &&name) : name_(std::move(name)) { } }; class LinkManager::InternalLinkUserToken final : public InternalLink { string token_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(token_); } public: explicit InternalLinkUserToken(string &&token) : token_(std::move(token)) { } }; class LinkManager::InternalLinkVideoChat final : public InternalLink { string dialog_username_; string invite_hash_; bool is_live_stream_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(dialog_username_, invite_hash_, is_live_stream_); } public: InternalLinkVideoChat(string dialog_username, string invite_hash, bool is_live_stream) : dialog_username_(std::move(dialog_username)) , invite_hash_(std::move(invite_hash)) , is_live_stream_(is_live_stream) { } }; class LinkManager::InternalLinkWebApp final : public InternalLink { string bot_username_; string web_app_short_name_; string start_parameter_; string mode_; td_api::object_ptr get_internal_link_type_object() const final { return td_api::make_object(bot_username_, web_app_short_name_, start_parameter_, get_web_app_open_mode_object(mode_)); } public: InternalLinkWebApp(string bot_username, string web_app_short_name, string start_parameter, string mode) : bot_username_(std::move(bot_username)) , web_app_short_name_(std::move(web_app_short_name)) , start_parameter_(std::move(start_parameter)) , mode_(std::move(mode)) { } }; class GetRecentMeUrlsQuery final : public Td::ResultHandler { Promise> promise_; public: explicit GetRecentMeUrlsQuery(Promise> &&promise) : promise_(std::move(promise)) { } void send(const string &referrer) { send_query(G()->net_query_creator().create(telegram_api::help_getRecentMeUrls(referrer))); } void on_result(BufferSlice packet) final { auto result_ptr = fetch_result(packet); if (result_ptr.is_error()) { return on_error(result_ptr.move_as_error()); } auto urls_full = result_ptr.move_as_ok(); td_->user_manager_->on_get_users(std::move(urls_full->users_), "GetRecentMeUrlsQuery"); td_->chat_manager_->on_get_chats(std::move(urls_full->chats_), "GetRecentMeUrlsQuery"); auto urls = std::move(urls_full->urls_); auto results = td_api::make_object(); results->urls_.reserve(urls.size()); for (auto &url_ptr : urls) { CHECK(url_ptr != nullptr); td_api::object_ptr result = td_api::make_object(); switch (url_ptr->get_id()) { case telegram_api::recentMeUrlUser::ID: { auto url = telegram_api::move_object_as(url_ptr); result->url_ = std::move(url->url_); UserId user_id(url->user_id_); if (!user_id.is_valid()) { LOG(ERROR) << "Receive invalid " << user_id; result = nullptr; break; } result->type_ = td_api::make_object( td_->user_manager_->get_user_id_object(user_id, "tMeUrlTypeUser")); break; } case telegram_api::recentMeUrlChat::ID: { auto url = telegram_api::move_object_as(url_ptr); result->url_ = std::move(url->url_); ChannelId channel_id(url->chat_id_); if (!channel_id.is_valid()) { LOG(ERROR) << "Receive invalid " << channel_id; result = nullptr; break; } result->type_ = td_api::make_object( td_->chat_manager_->get_supergroup_id_object(channel_id, "tMeUrlTypeSupergroup")); break; } case telegram_api::recentMeUrlChatInvite::ID: { auto url = telegram_api::move_object_as(url_ptr); result->url_ = std::move(url->url_); td_->dialog_invite_link_manager_->on_get_dialog_invite_link_info(result->url_, std::move(url->chat_invite_), Promise()); auto info_object = td_->dialog_invite_link_manager_->get_chat_invite_link_info_object(result->url_); if (info_object == nullptr) { result = nullptr; break; } result->type_ = td_api::make_object(std::move(info_object)); break; } case telegram_api::recentMeUrlStickerSet::ID: { auto url = telegram_api::move_object_as(url_ptr); result->url_ = std::move(url->url_); auto sticker_set_id = td_->stickers_manager_->on_get_sticker_set_covered(std::move(url->set_), false, "recentMeUrlStickerSet"); if (!sticker_set_id.is_valid()) { LOG(ERROR) << "Receive invalid sticker set"; result = nullptr; break; } result->type_ = td_api::make_object(sticker_set_id.get()); break; } case telegram_api::recentMeUrlUnknown::ID: // skip result = nullptr; break; default: UNREACHABLE(); } if (result != nullptr) { results->urls_.push_back(std::move(result)); } } promise_.set_value(std::move(results)); } void on_error(Status status) final { promise_.set_error(std::move(status)); } }; class GetDeepLinkInfoQuery final : public Td::ResultHandler { Promise> promise_; public: explicit GetDeepLinkInfoQuery(Promise> &&promise) : promise_(std::move(promise)) { } void send(Slice link) { send_query(G()->net_query_creator().create_unauth(telegram_api::help_getDeepLinkInfo(link.str()))); } void on_result(BufferSlice packet) final { auto result_ptr = fetch_result(packet); if (result_ptr.is_error()) { return on_error(result_ptr.move_as_error()); } auto result = result_ptr.move_as_ok(); switch (result->get_id()) { case telegram_api::help_deepLinkInfoEmpty::ID: return promise_.set_value(nullptr); case telegram_api::help_deepLinkInfo::ID: { auto info = telegram_api::move_object_as(result); auto text = get_formatted_text(nullptr, std::move(info->message_), std::move(info->entities_), true, true, "GetDeepLinkInfoQuery"); return promise_.set_value(td_api::make_object( get_formatted_text_object(td_->user_manager_.get(), text, true, -1), info->update_app_)); } default: UNREACHABLE(); } } void on_error(Status status) final { promise_.set_error(std::move(status)); } }; class RequestUrlAuthQuery final : public Td::ResultHandler { Promise> promise_; string url_; DialogId dialog_id_; public: explicit RequestUrlAuthQuery(Promise> &&promise) : promise_(std::move(promise)) { } void send(string url, MessageFullId message_full_id, int32 button_id) { url_ = std::move(url); int32 flags = 0; tl_object_ptr input_peer; if (message_full_id.get_dialog_id().is_valid()) { dialog_id_ = message_full_id.get_dialog_id(); input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read); CHECK(input_peer != nullptr); flags |= telegram_api::messages_requestUrlAuth::PEER_MASK; } else { flags |= telegram_api::messages_requestUrlAuth::URL_MASK; } send_query(G()->net_query_creator().create(telegram_api::messages_requestUrlAuth( flags, std::move(input_peer), message_full_id.get_message_id().get_server_message_id().get(), button_id, url_, string()))); } void on_result(BufferSlice packet) final { auto result_ptr = fetch_result(packet); if (result_ptr.is_error()) { return on_error(result_ptr.move_as_error()); } auto result = result_ptr.move_as_ok(); LOG(INFO) << "Receive result for RequestUrlAuthQuery: " << to_string(result); switch (result->get_id()) { case telegram_api::urlAuthResultRequest::ID: { auto request = telegram_api::move_object_as(result); auto bot_user_id = td_->user_manager_->on_get_user(std::move(request->bot_), "RequestUrlAuthQuery"); if (!bot_user_id.is_valid()) { return on_error(Status::Error(500, "Receive invalid bot_user_id")); } if (request->request_phone_number_ || !request->browser_.empty() || !request->platform_.empty() || !request->ip_.empty() || !request->region_.empty() || !request->match_codes_.empty()) { LOG(ERROR) << "Receive invalid login URL details: " << to_string(request); } promise_.set_value(td_api::make_object( url_, request->domain_, td_->user_manager_->get_user_id_object(bot_user_id, "RequestUrlAuthQuery"), request->request_write_access_)); break; } case telegram_api::urlAuthResultAccepted::ID: { auto accepted = telegram_api::move_object_as(result); promise_.set_value(td_api::make_object(accepted->url_, true)); break; } case telegram_api::urlAuthResultDefault::ID: promise_.set_value(td_api::make_object(url_, false)); break; default: UNREACHABLE(); } } void on_error(Status status) final { if (!dialog_id_.is_valid() || !td_->dialog_manager_->on_get_dialog_error(dialog_id_, status, "RequestUrlAuthQuery")) { LOG(INFO) << "Receive error for RequestUrlAuthQuery: " << status; } if (status.message() == "URL_EXPIRED" || status.message() == "URL_INVALID") { return promise_.set_error(std::move(status)); } promise_.set_value(td_api::make_object(url_, false)); } }; class RequestUrlOauthQuery final : public Td::ResultHandler { Promise> promise_; string url_; public: explicit RequestUrlOauthQuery(Promise> &&promise) : promise_(std::move(promise)) { } void send(string url, const string &in_app_origin) { url_ = std::move(url); int32 flags = telegram_api::messages_requestUrlAuth::URL_MASK; if (!in_app_origin.empty()) { flags |= telegram_api::messages_requestUrlAuth::IN_APP_ORIGIN_MASK; } send_query(G()->net_query_creator().create( telegram_api::messages_requestUrlAuth(flags, nullptr, 0, 0, url_, in_app_origin))); } void on_result(BufferSlice packet) final { auto result_ptr = fetch_result(packet); if (result_ptr.is_error()) { return on_error(result_ptr.move_as_error()); } auto result = result_ptr.move_as_ok(); LOG(INFO) << "Receive result for RequestUrlOauthQuery: " << to_string(result); switch (result->get_id()) { case telegram_api::urlAuthResultRequest::ID: { auto request = telegram_api::move_object_as(result); auto bot_user_id = td_->user_manager_->on_get_user(std::move(request->bot_), "RequestUrlAuthQuery"); if (!bot_user_id.is_valid()) { return on_error(Status::Error(500, "Receive invalid bot_user_id")); } auto user_id = UserId(request->user_id_hint_); if (user_id != UserId() && !user_id.is_valid()) { LOG(ERROR) << "Receive " << to_string(request); user_id = UserId(); } promise_.set_value(td_api::make_object( user_id.get(), url_, request->domain_, request->is_app_, request->verified_app_name_, td_->user_manager_->get_user_id_object(bot_user_id, "oauthLinkInfo"), request->request_write_access_, request->request_phone_number_, request->browser_, request->platform_, request->ip_, request->region_, request->match_codes_first_, std::move(request->match_codes_))); break; } case telegram_api::urlAuthResultAccepted::ID: case telegram_api::urlAuthResultDefault::ID: return on_error(Status::Error(400, "URL_EXPIRED")); default: UNREACHABLE(); } } void on_error(Status status) final { LOG(INFO) << "Receive error for RequestUrlOauthQuery: " << status; promise_.set_error(std::move(status)); } }; class CheckUrlAuthMatchCodeQuery final : public Td::ResultHandler { Promise promise_; public: explicit CheckUrlAuthMatchCodeQuery(Promise &&promise) : promise_(std::move(promise)) { } void send(string url, const string &match_code) { send_query(G()->net_query_creator().create(telegram_api::messages_checkUrlAuthMatchCode(url, match_code))); } void on_result(BufferSlice packet) final { auto result_ptr = fetch_result(packet); if (result_ptr.is_error()) { return on_error(result_ptr.move_as_error()); } if (!result_ptr.ok()) { return on_error(Status::Error(400, "MATCH_CODE_INVALID")); } promise_.set_value(Unit()); } void on_error(Status status) final { promise_.set_error(std::move(status)); } }; class AcceptUrlAuthQuery final : public Td::ResultHandler { Promise promise_; string url_; DialogId dialog_id_; public: explicit AcceptUrlAuthQuery(Promise &&promise) : promise_(std::move(promise)) { } void send(string url, MessageFullId message_full_id, int32 button_id, bool allow_write_access, bool allow_phone_number_access, const string &match_code) { url_ = std::move(url); int32 flags = 0; telegram_api::object_ptr input_peer; if (message_full_id.get_dialog_id().is_valid()) { dialog_id_ = message_full_id.get_dialog_id(); input_peer = td_->dialog_manager_->get_input_peer(dialog_id_, AccessRights::Read); CHECK(input_peer != nullptr); flags |= telegram_api::messages_acceptUrlAuth::PEER_MASK; } else { flags |= telegram_api::messages_acceptUrlAuth::URL_MASK; } send_query(G()->net_query_creator().create(telegram_api::messages_acceptUrlAuth( flags, allow_write_access, allow_phone_number_access, std::move(input_peer), message_full_id.get_message_id().get_server_message_id().get(), button_id, url_, match_code))); } void on_result(BufferSlice packet) final { auto result_ptr = fetch_result(packet); if (result_ptr.is_error()) { return on_error(result_ptr.move_as_error()); } auto result = result_ptr.move_as_ok(); LOG(DEBUG) << "Receive result for AcceptUrlAuthQuery: " << to_string(result); switch (result->get_id()) { case telegram_api::urlAuthResultRequest::ID: LOG(ERROR) << "Receive unexpected " << to_string(result); return on_error(Status::Error(500, "Receive unexpected urlAuthResultRequest")); case telegram_api::urlAuthResultAccepted::ID: { auto accepted = telegram_api::move_object_as(result); promise_.set_value(std::move(accepted->url_)); break; } case telegram_api::urlAuthResultDefault::ID: promise_.set_value(std::move(url_)); break; } } void on_error(Status status) final { if (!dialog_id_.is_valid() || !td_->dialog_manager_->on_get_dialog_error(dialog_id_, status, "AcceptUrlAuthQuery")) { LOG(INFO) << "Receive error for AcceptUrlAuthQuery: " << status; } promise_.set_error(std::move(status)); } }; class DeclineUrlAuthQuery final : public Td::ResultHandler { Promise promise_; public: explicit DeclineUrlAuthQuery(Promise &&promise) : promise_(std::move(promise)) { } void send(string url) { send_query(G()->net_query_creator().create(telegram_api::messages_declineUrlAuth(url))); } void on_result(BufferSlice packet) final { auto result_ptr = fetch_result(packet); if (result_ptr.is_error()) { return on_error(result_ptr.move_as_error()); } promise_.set_value(Unit()); } void on_error(Status status) final { LOG(INFO) << "Receive error for DeclineUrlAuthQuery: " << status; promise_.set_value(Unit()); } }; LinkManager::LinkManager(Td *td, ActorShared<> parent) : td_(td), parent_(std::move(parent)) { } LinkManager::~LinkManager() = default; void LinkManager::start_up() { autologin_update_time_ = Time::now() - 365 * 86400; autologin_domains_ = full_split(G()->td_db()->get_binlog_pmc()->get("autologin_domains"), '\xFF'); url_auth_domains_ = full_split(G()->td_db()->get_binlog_pmc()->get("url_auth_domains"), '\xFF'); whitelisted_domains_ = full_split(G()->td_db()->get_binlog_pmc()->get("whitelisted_domains"), '\xFF'); } void LinkManager::tear_down() { parent_.reset(); } static bool tolower_begins_with(Slice str, Slice prefix) { if (prefix.size() > str.size()) { return false; } for (size_t i = 0; i < prefix.size(); i++) { if (to_lower(str[i]) != prefix[i]) { return false; } } return true; } Result LinkManager::check_link(CSlice link, bool http_only, bool https_only) { auto result = check_link_impl(link, http_only, https_only); if (result.is_ok()) { return result; } auto error = result.move_as_error(); if (check_utf8(link)) { return Status::Error(400, PSLICE() << "URL '" << link << "' is invalid: " << error.message()); } else { return Status::Error(400, PSLICE() << "URL is invalid: " << error.message()); } } string LinkManager::get_checked_link(Slice link, bool http_only, bool https_only) { auto result = check_link_impl(link, http_only, https_only); if (result.is_ok()) { return result.move_as_ok(); } return string(); } Result LinkManager::check_link_impl(Slice link, bool http_only, bool https_only) { bool is_tg = false; bool is_ton = false; bool is_tonsite = false; if (tolower_begins_with(link, "tg:")) { link.remove_prefix(3); is_tg = true; } else if (tolower_begins_with(link, "ton:")) { link.remove_prefix(4); is_ton = true; } else if (tolower_begins_with(link, "tonsite:")) { link.remove_prefix(8); is_tonsite = true; } if ((is_tg || is_ton || is_tonsite) && begins_with(link, "//")) { link.remove_prefix(2); } TRY_RESULT(http_url, parse_url(link)); if (https_only && (http_url.protocol_ != HttpUrl::Protocol::Https || is_tg || is_ton || is_tonsite)) { return Status::Error("Only HTTPS links are allowed"); } if (is_tg || is_ton || is_tonsite) { if (http_only) { return Status::Error("Only HTTP links are allowed"); } if (tolower_begins_with(link, "http://") || http_url.protocol_ == HttpUrl::Protocol::Https || !http_url.userinfo_.empty() || http_url.specified_port_ != 0 || http_url.is_ipv6_) { return Status::Error(is_tg ? Slice("Wrong tg URL") : Slice("Wrong ton URL")); } Slice query(http_url.query_); CHECK(query[0] == '/'); if (query.size() > 1 && query[1] == '?') { query.remove_prefix(1); } for (auto c : http_url.host_) { if (!is_alnum(c) && c != '-' && c != '_' && !(is_tonsite && c == '.')) { return Status::Error("Unallowed characters in URL host"); } } return PSTRING() << (is_tg ? "tg" : (is_tonsite ? "tonsite" : "ton")) << "://" << http_url.host_ << query; } if (http_url.host_.find('.') == string::npos && !http_url.is_ipv6_) { return Status::Error("Wrong HTTP URL"); } return http_url.get_url(); } LinkManager::LinkInfo LinkManager::get_link_info(Slice link) { LinkInfo result; if (link.empty()) { return result; } link.truncate(link.find('#')); bool is_tg = false; if (tolower_begins_with(link, "tg:")) { link.remove_prefix(3); if (begins_with(link, "//")) { link.remove_prefix(2); } is_tg = true; } auto r_http_url = parse_url(link); if (r_http_url.is_error()) { return result; } auto http_url = r_http_url.move_as_ok(); if (!http_url.userinfo_.empty() || http_url.is_ipv6_) { return result; } if (is_tg) { if (tolower_begins_with(link, "http://") || http_url.protocol_ == HttpUrl::Protocol::Https || http_url.specified_port_ != 0) { return result; } result.type_ = LinkType::Tg; result.query_ = link.str(); return result; } else { if (http_url.port_ != 80 && http_url.port_ != 443) { return result; } auto host = url_decode(http_url.host_, false); to_lower_inplace(host); if (ends_with(host, ".t.me") && host.size() >= 9 && host.find('.') == host.size() - 5) { Slice subdomain(&host[0], host.size() - 5); static const FlatHashSet disallowed_subdomains( {"addemoji", "addlist", "addstickers", "addstyle", "addtheme", "auction", "auth", "boost", "call", "confirmphone", "contact", "giftcode", "invoice", "joinchat", "login", "m", "nft", "proxy", "setlanguage", "share", "socks", "web", "a", "k", "z"}); if (is_valid_username(subdomain) && disallowed_subdomains.count(subdomain) == 0) { result.type_ = LinkType::TMe; result.query_ = PSTRING() << '/' << subdomain << http_url.query_; return result; } } if (begins_with(host, "www.")) { host = host.substr(4); } string cur_t_me_url; vector t_me_urls{Slice("t.me"), Slice("telegram.me"), Slice("telegram.dog")}; #if TD_EMSCRIPTEN t_me_urls.push_back(Slice("web.t.me")); t_me_urls.push_back(Slice("a.t.me")); t_me_urls.push_back(Slice("k.t.me")); t_me_urls.push_back(Slice("z.t.me")); #endif if (Scheduler::context() != nullptr) { // for tests only cur_t_me_url = G()->get_option_string("t_me_url"); if (tolower_begins_with(cur_t_me_url, "http://") || tolower_begins_with(cur_t_me_url, "https://")) { Slice t_me_url = cur_t_me_url; t_me_url = t_me_url.substr(t_me_url[4] == 's' ? 8 : 7); if (!td::contains(t_me_urls, t_me_url)) { t_me_urls.push_back(t_me_url); } } } for (auto t_me_url : t_me_urls) { if (host == t_me_url) { result.type_ = LinkType::TMe; Slice query = http_url.query_; while (true) { if (begins_with(query, "/s/")) { query.remove_prefix(2); continue; } if (begins_with(query, "/%73/")) { query.remove_prefix(4); continue; } break; } result.query_ = query.str(); return result; } } if (http_url.query_.size() > 1) { for (auto telegraph_url : {Slice("telegra.ph"), Slice("te.legra.ph"), Slice("graph.org")}) { if (host == telegraph_url) { result.type_ = LinkType::Telegraph; result.query_ = std::move(http_url.query_); return result; } } } } return result; } bool LinkManager::is_internal_link(Slice link) { auto info = get_link_info(link); return info.type_ != LinkType::External; } unique_ptr LinkManager::parse_internal_link(Slice link, bool is_trusted) { auto info = get_link_info(link); switch (info.type_) { case LinkType::External: return nullptr; case LinkType::Tg: return parse_tg_link_query(info.query_, is_trusted); case LinkType::TMe: return parse_t_me_link_query(info.query_, is_trusted); case LinkType::Telegraph: return td::make_unique(PSTRING() << "https://telegra.ph" << info.query_, link.str()); default: UNREACHABLE(); return nullptr; } } namespace { struct CopyArg { Slice name_; const HttpUrlQuery *url_query_; bool *is_first_; CopyArg(Slice name, const HttpUrlQuery *url_query, bool *is_first) : name_(name), url_query_(url_query), is_first_(is_first) { } }; StringBuilder &operator<<(StringBuilder &string_builder, const CopyArg ©_arg) { auto arg = copy_arg.url_query_->get_arg(copy_arg.name_); if (arg.empty()) { for (const auto &query_arg : copy_arg.url_query_->args_) { if (query_arg.first == copy_arg.name_) { char c = *copy_arg.is_first_ ? '?' : '&'; *copy_arg.is_first_ = false; return string_builder << c << copy_arg.name_; } } return string_builder; } char c = *copy_arg.is_first_ ? '?' : '&'; *copy_arg.is_first_ = false; return string_builder << c << copy_arg.name_ << '=' << url_encode(arg); } } // namespace unique_ptr LinkManager::parse_tg_link_query(Slice query, bool is_trusted) { const auto url_query = parse_url_query(query); const auto &path = url_query.path_; bool is_first_arg = true; auto copy_arg = [&](Slice name) { return CopyArg(name, &url_query, &is_first_arg); }; auto pass_arg = [&](Slice name) { return url_encode(url_query.get_arg(name)); }; auto get_arg = [&](Slice name) { return url_query.get_arg(name).str(); }; auto has_arg = [&](Slice name) { return !url_query.get_arg(name).empty(); }; if (path.size() == 1 && path[0] == "resolve") { auto username = get_arg("domain"); if (is_valid_username(username)) { if (has_arg("post")) { // resolve?domain=&post=12345&single&thread=&comment=&t= return td::make_unique(PSTRING() << "tg://resolve" << copy_arg("domain") << copy_arg("post") << copy_arg("single") << copy_arg("thread") << copy_arg("comment") << copy_arg("t") << copy_arg("task") << copy_arg("option")); } if (username == "oauth" && has_arg("startapp")) { return td::make_unique(PSTRING() << "tg://resolve" << copy_arg("domain") << copy_arg("startapp")); } for (auto &arg : url_query.args_) { if ((arg.first == "voicechat" || arg.first == "videochat" || arg.first == "livestream") && is_valid_video_chat_invite_hash(arg.second)) { // resolve?domain=&videochat // resolve?domain=&videochat= if (Scheduler::context() != nullptr) { send_closure(G()->dialog_manager(), &DialogManager::reload_video_chat_on_search, username); } return td::make_unique(std::move(username), arg.second, arg.first == "livestream"); } if (arg.first == "ref" && is_valid_start_parameter(arg.second) && !arg.second.empty()) { // resolve?domain=&ref= return td::make_unique(std::move(username), arg.second); } if (arg.first == "start" && is_valid_start_parameter(arg.second)) { auto prefixes = get_referral_program_start_parameter_prefixes(); for (Slice prefix : prefixes) { if (begins_with(arg.second, prefix) && arg.second.size() > prefix.size()) { // resolve?domain=&start=_tgr_ return td::make_unique(std::move(username), arg.second.substr(prefix.size())); } } // resolve?domain=&start= return td::make_unique(std::move(username), arg.second, is_trusted); } if (arg.first == "startgroup" && is_valid_start_parameter(arg.second)) { // resolve?domain=&startgroup= // resolve?domain=&startgroup=>parameter>&admin=change_info+delete_messages+restrict_members // resolve?domain=&startgroup&admin=change_info+delete_messages+restrict_members auto administrator_rights = get_administrator_rights(url_query.get_arg("admin"), false); return td::make_unique(std::move(username), arg.second, std::move(administrator_rights)); } if (arg.first == "startchannel") { // resolve?domain=&startchannel&admin=change_info+post_messages+promote_members auto administrator_rights = get_administrator_rights(url_query.get_arg("admin"), true); if (administrator_rights != AdministratorRights()) { return td::make_unique(std::move(username), std::move(administrator_rights)); } } if (arg.first == "game" && is_valid_game_name(arg.second)) { // resolve?domain=&game= return td::make_unique(std::move(username), arg.second); } if (arg.first == "appname" && is_valid_web_app_name(arg.second)) { // resolve?domain=&appname= // resolve?domain=&appname=&startapp=&mode=compact return td::make_unique(std::move(username), arg.second, get_arg("startapp"), get_arg("mode")); } if (arg.first == "story" && is_valid_story_id(arg.second)) { // resolve?domain=&story= return td::make_unique(std::move(username), StoryId(to_integer(arg.second))); } if (arg.first == "story" && arg.second == "live") { // resolve?domain=&story=live return td::make_unique(std::move(username)); } if (arg.first == "startapp" && is_valid_start_parameter(arg.second) && !url_query.has_arg("appname")) { // resolve?domain=&startapp= // resolve?domain=&startapp=&mode=compact return td::make_unique(std::move(username), arg.second, get_arg("mode")); } if (arg.first == "attach" && is_valid_username(arg.second)) { // resolve?domain=&attach= // resolve?domain=&attach=&startattach= return td::make_unique( nullptr, td::make_unique(std::move(username), string(), false), arg.second, url_query.get_arg("startattach")); } if (arg.first == "startattach" && !has_arg("attach")) { // resolve?domain=&startattach&choose=users+bots+groups+channels // resolve?domain=&startattach=&choose=users+bots+groups+channels return td::make_unique(get_target_chat_types(url_query.get_arg("choose")), nullptr, std::move(username), arg.second); } if (arg.first == "direct") { // resolve?domain=&direct return td::make_unique(std::move(username)); } if (arg.first == "collection" && is_valid_star_gift_collection_id(arg.second)) { // resolve?domain=&collection= return td::make_unique(std::move(username), StarGiftCollectionId(to_integer(arg.second))); } if (arg.first == "album" && is_valid_story_album_id(arg.second)) { // resolve?domain=&album= return td::make_unique(std::move(username), StoryAlbumId(to_integer(arg.second))); } } if (username == "telegrampassport") { // resolve?domain=telegrampassport&bot_id=...&scope=...&public_key=...&nonce=...&callback_url=... auto passport_link = get_internal_link_passport(query, url_query.args_, false); if (passport_link != nullptr) { return passport_link; } } // resolve?domain= return td::make_unique(std::move(username), get_url_query_draft_text(url_query), url_query.has_arg("profile")); } else { string phone_number_str = get_arg("phone"); auto phone_number = phone_number_str[0] == ' ' ? Slice(phone_number_str).substr(1) : Slice(phone_number_str); if (is_valid_phone_number(phone_number)) { auto attach = url_query.get_arg("attach"); if (is_valid_username(attach)) { // resolve?phone=&attach= // resolve?phone=&attach=&startattach= return td::make_unique( nullptr, td::make_unique(phone_number, string(), false), attach.str(), url_query.get_arg("startattach")); } // resolve?phone=12345 return td::make_unique(phone_number, get_url_query_draft_text(url_query), url_query.has_arg("profile")); } } } else if (path.size() == 1 && path[0] == "nft") { // nft?slug= auto name = get_arg("slug"); if (is_valid_upgraded_gift_name(name)) { return td::make_unique(std::move(name)); } } else if (path.size() == 1 && path[0] == "contact") { // contact?token= auto token = get_arg("token"); if (is_valid_user_token(token)) { return td::make_unique(std::move(token)); } } else if (path.size() >= 1u && path[0] == "contacts") { // contacts[/section] if (path.size() == 2u && td::contains(get_contacts_sections(), path[1])) { return td::make_unique(path[1]); } return td::make_unique(string()); } else if (path.size() == 2 && path[0] == "chats" && path[1] == "edit") { // chats/edit return td::make_unique(); } else if (path.size() == 2 && path[0] == "chats" && path[1] == "emoji-status") { // chats/emoji-status return td::make_unique(vector{"emoji-status"}); } else if (path.size() == 2 && path[0] == "chats" && path[1] == "search") { // chats/search return td::make_unique(); } else if (path.size() == 1 && path[0] == "login") { // login?code=123456 auto code = get_arg("code"); if (is_valid_login_code(code)) { return td::make_unique(std::move(code)); } // login?token= if (has_arg("token")) { return td::make_unique(); } } else if (path.size() == 1 && path[0] == "new") { // new return td::make_unique(); } else if (path.size() == 2 && path[0] == "new" && path[1] == "channel") { // new/channel return td::make_unique(); } else if (path.size() == 2 && path[0] == "new" && path[1] == "group") { // new/group return td::make_unique(); } else if (path.size() == 1 && path[0] == "oauth" && has_arg("token")) { // oauth?token=... return td::make_unique(PSTRING() << "tg://oauth" << copy_arg("token")); } else if (path.size() <= 2 && path[0] == "post") { // post[/content-type] return td::make_unique(path.size() == 2 ? path[1] : string()); } else if (path.size() == 1 && path[0] == "restore_purchases") { // restore_purchases return td::make_unique(); } else if (path.size() == 1 && path[0] == "passport") { // passport?bot_id=...&scope=...&public_key=...&nonce=...&callback_url=... return get_internal_link_passport(query, url_query.args_, true); } else if (path.size() == 1 && path[0] == "premium_offer") { // premium_offer?ref= auto referrer = get_arg("ref"); if (is_valid_premium_referrer(referrer)) { return td::make_unique(std::move(referrer)); } } else if (path.size() == 1 && path[0] == "premium_multigift") { // premium_multigift?ref= auto referrer = get_arg("ref"); if (is_valid_premium_referrer(referrer)) { return td::make_unique(std::move(referrer)); } } else if (path.size() >= 2 && path[0] == "settings" && path[1] == "saved-messages") { // settings/saved-messages return td::make_unique(); } else if (path.size() >= 2 && path[0] == "settings" && path[1] == "calls") { // settings/calls[/section] string section; if (path.size() >= 3u) { section = path[2]; for (size_t i = 3; i < path.size(); i++) { section += '/'; section += path[i]; } } if (!td::contains(get_calls_sections(), section)) { section = string(); } return td::make_unique(std::move(section)); } else if (path.size() >= 2 && path[0] == "settings" && path[1] == "my-profile") { // settings/my-profile[/section] string section; if (path.size() >= 3u) { section = path[2]; for (size_t i = 3; i < path.size(); i++) { section += '/'; section += path[i]; } } if (!td::contains(get_my_profile_sections(), section)) { section = string(); } return td::make_unique(std::move(section)); } else if (!path.empty() && path[0] == "settings") { // settings[/section[/subsection]] return td::make_unique(vector{path.begin() + 1, path.end()}); } else if (!path.empty() && path[0] == "stars") { // stars return td::make_unique(vector{"stars"}); } else if (!path.empty() && (path[0] == "ton" || path[0] == "grams")) { // grams return td::make_unique