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

Move Proxy to Proxy.h.

Browse Source 
GitOrigin-RevId: b1e4f03b7e49b15ea576e4f05c05c8fe8709e3eb
This commit is contained in:
levlam 2019-07-09 05:13:10 +03:00
parent 7958916080
commit c626bbefe6
5 changed files with 162 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -580,6 +580,7 @@ set(TDLIB_SOURCE
td/telegram/net/NetQueryDispatcher.h
td/telegram/net/NetStatsManager.h
td/telegram/net/NetType.h
td/telegram/net/Proxy.h
td/telegram/net/PublicRsaKeyShared.h
td/telegram/net/PublicRsaKeyWatchdog.h
td/telegram/net/Session.h

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

@ -125,61 +125,6 @@ class ConnectionCreator::ProxyInfo {
IPAddress ip_address_;
};
template <class StorerT>
void Proxy::store(StorerT &storer) const {
using td::store;
store(type_, storer);
if (type_ == Proxy::Type::Socks5 || type_ == Proxy::Type::HttpTcp || type_ == Proxy::Type::HttpCaching) {
store(server_, storer);
store(port_, storer);
store(user_, storer);
store(password_, storer);
} else if (type_ == Proxy::Type::Mtproto) {
store(server_, storer);
store(port_, storer);
store(secret_.get_encoded_secret(), storer);
} else {
CHECK(type_ == Proxy::Type::None);
}
}
template <class ParserT>
void Proxy::parse(ParserT &parser) {
using td::parse;
parse(type_, parser);
if (type_ == Proxy::Type::Socks5 || type_ == Proxy::Type::HttpTcp || type_ == Proxy::Type::HttpCaching) {
parse(server_, parser);
parse(port_, parser);
parse(user_, parser);
parse(password_, parser);
} else if (type_ == Proxy::Type::Mtproto) {
parse(server_, parser);
parse(port_, parser);
secret_ = mtproto::ProxySecret::from_link(parser.template fetch_string<Slice>()).move_as_ok();
} else {
LOG_CHECK(type_ == Proxy::Type::None) << static_cast<int32>(type_);
}
}
StringBuilder &operator<<(StringBuilder &string_builder, const Proxy &proxy) {
switch (proxy.type()) {
case Proxy::Type::Socks5:
return string_builder << "ProxySocks5 " << proxy.server() << ":" << proxy.port();
case Proxy::Type::HttpTcp:
return string_builder << "ProxyHttpTcp " << proxy.server() << ":" << proxy.port();
case Proxy::Type::HttpCaching:
return string_builder << "ProxyHttpCaching " << proxy.server() << ":" << proxy.port();
case Proxy::Type::Mtproto:
return string_builder << "ProxyMtproto " << proxy.server() << ":" << proxy.port() << "/"
<< proxy.secret().get_encoded_secret();
case Proxy::Type::None:
return string_builder << "ProxyEmpty";
default:
UNREACHABLE();
return string_builder;
}
}
ConnectionCreator::ClientInfo::ClientInfo() {
flood_control.add_limit(1, 1);
flood_control.add_limit(4, 2);

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

@ -13,18 +13,18 @@
#include "td/telegram/net/DcOptions.h"
#include "td/telegram/net/DcOptionsSet.h"
#include "td/telegram/net/NetQuery.h"
#include "td/telegram/net/Proxy.h"
#include "td/telegram/StateManager.h"
#include "td/mtproto/AuthData.h"
#include "td/mtproto/ProxySecret.h"
#include "td/mtproto/TransportType.h"
#include "td/net/NetStats.h"
#include "td/actor/actor.h"
#include "td/actor/PromiseFuture.h"
#include "td/actor/SignalSlot.h"
#include "td/net/NetStats.h"
#include "td/utils/common.h"
#include "td/utils/FloodControlStrict.h"
#include "td/utils/logging.h"
@ -32,7 +32,6 @@
#include "td/utils/port/SocketFd.h"
#include "td/utils/Slice.h"
#include "td/utils/Status.h"
#include "td/utils/StringBuilder.h"
#include "td/utils/Time.h"
#include <map>
@ -55,98 +54,6 @@ namespace td {
extern int VERBOSITY_NAME(connections);
class Proxy {
public:
static Proxy socks5(string server, int32 port, string user, string password) {
Proxy proxy;
proxy.type_ = Type::Socks5;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.user_ = std::move(user);
proxy.password_ = std::move(password);
return proxy;
}
static Proxy http_tcp(string server, int32 port, string user, string password) {
Proxy proxy;
proxy.type_ = Type::HttpTcp;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.user_ = std::move(user);
proxy.password_ = std::move(password);
return proxy;
}
static Proxy http_caching(string server, int32 port, string user, string password) {
Proxy proxy;
proxy.type_ = Type::HttpCaching;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.user_ = std::move(user);
proxy.password_ = std::move(password);
return proxy;
}
static Proxy mtproto(string server, int32 port, mtproto::ProxySecret secret) {
Proxy proxy;
proxy.type_ = Type::Mtproto;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.secret_ = std::move(secret);
return proxy;
}
CSlice server() const {
return server_;
}
int32 port() const {
return port_;
}
CSlice user() const {
return user_;
}
CSlice password() const {
return password_;
}
const mtproto::ProxySecret &secret() const {
return secret_;
}
enum class Type : int32 { None, Socks5, Mtproto, HttpTcp, HttpCaching };
Type type() const {
return type_;
}
template <class StorerT>
void store(StorerT &storer) const;
template <class ParserT>
void parse(ParserT &parser);
private:
Type type_{Type::None};
string server_;
int32 port_ = 0;
string user_;
string password_;
mtproto::ProxySecret secret_;
};
inline bool operator==(const Proxy &lhs, const Proxy &rhs) {
return lhs.type() == rhs.type() && lhs.server() == rhs.server() && lhs.port() == rhs.port() &&
lhs.user() == rhs.user() && lhs.password() == rhs.password() && lhs.secret() == rhs.secret();
}
inline bool operator!=(const Proxy &lhs, const Proxy &rhs) {
return !(lhs == rhs);
}
StringBuilder &operator<<(StringBuilder &string_builder, const Proxy &proxy);
class ConnectionCreator : public NetQueryCallback {
public:
explicit ConnectionCreator(ActorShared<> parent);

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

@ -6,7 +6,7 @@
//
#pragma once
#include "td/telegram/net/ConnectionCreator.h"
#include "td/telegram/net/Proxy.h"
#include "td/utils/common.h"
#include "td/utils/Slice.h"

157
td/telegram/net/Proxy.h Normal file
View File

@ -0,0 +1,157 @@
//
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2019
//
// 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)
//
#pragma once
#include "td/mtproto/ProxySecret.h"
#include "td/utils/common.h"
#include "td/utils/Slice.h"
#include "td/utils/StringBuilder.h"
#include "td/utils/tl_helpers.h"
namespace td {
class Proxy {
public:
static Proxy socks5(string server, int32 port, string user, string password) {
Proxy proxy;
proxy.type_ = Type::Socks5;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.user_ = std::move(user);
proxy.password_ = std::move(password);
return proxy;
}
static Proxy http_tcp(string server, int32 port, string user, string password) {
Proxy proxy;
proxy.type_ = Type::HttpTcp;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.user_ = std::move(user);
proxy.password_ = std::move(password);
return proxy;
}
static Proxy http_caching(string server, int32 port, string user, string password) {
Proxy proxy;
proxy.type_ = Type::HttpCaching;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.user_ = std::move(user);
proxy.password_ = std::move(password);
return proxy;
}
static Proxy mtproto(string server, int32 port, mtproto::ProxySecret secret) {
Proxy proxy;
proxy.type_ = Type::Mtproto;
proxy.server_ = std::move(server);
proxy.port_ = std::move(port);
proxy.secret_ = std::move(secret);
return proxy;
}
CSlice server() const {
return server_;
}
int32 port() const {
return port_;
}
CSlice user() const {
return user_;
}
CSlice password() const {
return password_;
}
const mtproto::ProxySecret &secret() const {
return secret_;
}
enum class Type : int32 { None, Socks5, Mtproto, HttpTcp, HttpCaching };
Type type() const {
return type_;
}
template <class StorerT>
void store(StorerT &storer) const {
using td::store;
store(type_, storer);
if (type_ == Proxy::Type::Socks5 || type_ == Proxy::Type::HttpTcp || type_ == Proxy::Type::HttpCaching) {
store(server_, storer);
store(port_, storer);
store(user_, storer);
store(password_, storer);
} else if (type_ == Proxy::Type::Mtproto) {
store(server_, storer);
store(port_, storer);
store(secret_.get_encoded_secret(), storer);
} else {
CHECK(type_ == Proxy::Type::None);
}
}
template <class ParserT>
void parse(ParserT &parser) {
using td::parse;
parse(type_, parser);
if (type_ == Proxy::Type::Socks5 || type_ == Proxy::Type::HttpTcp || type_ == Proxy::Type::HttpCaching) {
parse(server_, parser);
parse(port_, parser);
parse(user_, parser);
parse(password_, parser);
} else if (type_ == Proxy::Type::Mtproto) {
parse(server_, parser);
parse(port_, parser);
secret_ = mtproto::ProxySecret::from_link(parser.template fetch_string<Slice>()).move_as_ok();
} else {
LOG_CHECK(type_ == Proxy::Type::None) << static_cast<int32>(type_);
}
}
private:
Type type_{Type::None};
string server_;
int32 port_ = 0;
string user_;
string password_;
mtproto::ProxySecret secret_;
};
inline bool operator==(const Proxy &lhs, const Proxy &rhs) {
return lhs.type() == rhs.type() && lhs.server() == rhs.server() && lhs.port() == rhs.port() &&
lhs.user() == rhs.user() && lhs.password() == rhs.password() && lhs.secret() == rhs.secret();
}
inline bool operator!=(const Proxy &lhs, const Proxy &rhs) {
return !(lhs == rhs);
}
inline StringBuilder &operator<<(StringBuilder &string_builder, const Proxy &proxy) {
switch (proxy.type()) {
case Proxy::Type::Socks5:
return string_builder << "ProxySocks5 " << proxy.server() << ":" << proxy.port();
case Proxy::Type::HttpTcp:
return string_builder << "ProxyHttpTcp " << proxy.server() << ":" << proxy.port();
case Proxy::Type::HttpCaching:
return string_builder << "ProxyHttpCaching " << proxy.server() << ":" << proxy.port();
case Proxy::Type::Mtproto:
return string_builder << "ProxyMtproto " << proxy.server() << ":" << proxy.port() << "/"
<< proxy.secret().get_encoded_secret();
case Proxy::Type::None:
return string_builder << "ProxyEmpty";
default:
UNREACHABLE();
return string_builder;
}
}
} // namespace td