mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

refactor: partially c++ifiy tr_rpc_server (#2965) 

Replace the older C-style API methods to be class methods.
This commit is contained in:
Charles Kerr 2022-04-22 09:19:20 -05:00 committed by GitHub
parent 3643a8aee5
commit 7918113e0b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 207 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

238
libtransmission/rpc-server.cc
View File

@ -279,7 +279,7 @@ static void handle_web_client(struct evhttp_request* req, tr_rpc_server* server)
else
{
// TODO: string_view
char* const subpath = tr_strdup(req->uri + std::size(server->url) + 4);
char* const subpath = tr_strdup(req->uri + std::size(server->url()) + 4);
if (char* pch = strchr(subpath, '?'); pch != nullptr)
{
*pch = '\0';
@ -366,10 +366,13 @@ static void handle_rpc(struct evhttp_request* req, tr_rpc_server* server)
static bool isAddressAllowed(tr_rpc_server const* server, char const* address)
{
auto const& src = server->whitelist;
if (!server->isWhitelistEnabled())
{
return true;
}
return !server->isWhitelistEnabled ||
std::any_of(std::begin(src), std::end(src), [&address](auto const& s) { return tr_wildmat(address, s); });
auto const& src = server->whitelist_;
return std::any_of(std::begin(src), std::end(src), [&address](auto const& s) { return tr_wildmat(address, s); });
}
static bool isIPAddressWithOptionalPort(char const* host)
@ -384,7 +387,7 @@ static bool isIPAddressWithOptionalPort(char const* host)
static bool isHostnameAllowed(tr_rpc_server const* server, struct evhttp_request* req)
{
/* If password auth is enabled, any hostname is permitted. */
if (server->isPasswordEnabled)
if (server->isPasswordEnabled())
{
return true;
}
@ -435,7 +438,7 @@ static bool test_session_id(tr_rpc_server* server, evhttp_request const* req)
static bool isAuthorized(tr_rpc_server const* server, char const* auth_header)
{
if (!server->isPasswordEnabled)
if (!server->isPasswordEnabled())
{
return true;
}
@ -455,7 +458,7 @@ static bool isAuthorized(tr_rpc_server const* server, char const* auth_header)
auto decoded = std::string_view{ decoded_str };
auto const username = tr_strvSep(&decoded, ':');
auto const password = decoded;
return server->username == username && tr_ssha1_matches(server->salted_password, password);
return server->username() == username && tr_ssha1_matches(server->salted_password_, password);
}
static void handle_request(struct evhttp_request* req, void* arg)
@ -466,7 +469,7 @@ static void handle_request(struct evhttp_request* req, void* arg)
{
evhttp_add_header(req->output_headers, "Server", MY_REALM);
if (server->isAntiBruteForceEnabled && server->loginattempts >= server->antiBruteForceThreshold)
if (server->isAntiBruteForceEnabled() && server->login_attempts_ >= server->anti_brute_force_limit_)
{
send_simple_response(req, 403, "<p>Too many unsuccessful login attempts. Please restart transmission-daemon.</p>");
return;
@ -502,26 +505,26 @@ static void handle_request(struct evhttp_request* req, void* arg)
if (!isAuthorized(server, evhttp_find_header(req->input_headers, "Authorization")))
{
evhttp_add_header(req->output_headers, "WWW-Authenticate", "Basic realm=\"" MY_REALM "\"");
if (server->isAntiBruteForceEnabled)
if (server->isAntiBruteForceEnabled())
{
++server->loginattempts;
++server->login_attempts_;
}
auto const unauthuser = fmt::format(
FMT_STRING("<p>Unauthorized User. {:d} unsuccessful login attempts.</p>"),
server->loginattempts);
server->login_attempts_);
send_simple_response(req, 401, unauthuser.c_str());
return;
}
server->loginattempts = 0;
server->login_attempts_ = 0;
auto uri = std::string_view{ req->uri };
auto const location = tr_strvStartsWith(uri, server->url) ? uri.substr(std::size(server->url)) : ""sv;
auto const location = tr_strvStartsWith(uri, server->url()) ? uri.substr(std::size(server->url())) : ""sv;
if (std::empty(location) || location == "web"sv)
{
auto const new_location = fmt::format(FMT_STRING("{:s}web/"), server->url);
auto const new_location = fmt::format(FMT_STRING("{:s}web/"), server->url());
evhttp_add_header(req->output_headers, "Location", new_location.c_str());
send_simple_response(req, HTTP_MOVEPERM, nullptr);
}
@ -737,13 +740,12 @@ static void startServer(tr_rpc_server* server)
evhttp_set_allowed_methods(httpd, EVHTTP_REQ_GET | EVHTTP_REQ_POST | EVHTTP_REQ_OPTIONS);
char const* address = tr_rpcGetBindAddress(server);
auto const address = server->getBindAddress();
auto const port = server->port();
bool const success = server->bindAddress->type == TR_RPC_AF_UNIX ?
bindUnixSocket(base, httpd, address, server->rpc_socket_mode) :
(evhttp_bind_socket(httpd, address, port.host()) != -1);
bindUnixSocket(base, httpd, address.c_str(), server->socket_mode_) :
(evhttp_bind_socket(httpd, address.c_str(), port.host()) != -1);
auto const addr_port_str = tr_rpc_address_with_port(server);
@ -791,14 +793,14 @@ static void stopServer(tr_rpc_server* server)
return;
}
char const* address = tr_rpcGetBindAddress(server);
auto const address = server->getBindAddress();
server->httpd = nullptr;
evhttp_free(httpd);
if (server->bindAddress->type == TR_RPC_AF_UNIX)
{
unlink(address + std::size(TrUnixSocketPrefix));
unlink(address.c_str() + std::size(TrUnixSocketPrefix));
}
tr_logAddInfo(fmt::format(
@ -806,33 +808,28 @@ static void stopServer(tr_rpc_server* server)
fmt::arg("address", tr_rpc_address_with_port(server))));
}
static void onEnabledChanged(tr_rpc_server* const server)
void tr_rpc_server::setEnabled(bool is_enabled)
{
if (!server->isEnabled)
{
stopServer(server);
}
else
{
startServer(server);
}
}
is_enabled_ = is_enabled;
void tr_rpcSetEnabled(tr_rpc_server* server, bool isEnabled)
{
server->isEnabled = isEnabled;
tr_runInEventThread(server->session, onEnabledChanged, server);
}
bool tr_rpcIsEnabled(tr_rpc_server const* server)
{
return server->isEnabled;
tr_runInEventThread(
this->session,
[this]()
{
if (!is_enabled_)
{
stopServer(this);
}
else
{
startServer(this);
}
});
}
static void restartServer(tr_rpc_server* const server)
{
if (server->isEnabled)
if (server->isEnabled())
{
stopServer(server);
startServer(server);
@ -848,21 +845,16 @@ void tr_rpc_server::setPort(tr_port port) noexcept
port_ = port;
if (isEnabled)
if (isEnabled())
{
tr_runInEventThread(session, restartServer, this);
}
}
void tr_rpcSetUrl(tr_rpc_server* server, std::string_view url)
void tr_rpc_server::setUrl(std::string_view url)
{
server->url = url;
tr_logAddDebug(fmt::format("setting our URL to '{}'", server->url));
}
std::string const& tr_rpcGetUrl(tr_rpc_server const* server)
{
return server->url;
url_ = url;
tr_logAddDebug(fmt::format(FMT_STRING("setting our URL to '{:s}'"), url_));
}
static auto parseWhitelist(std::string_view whitelist)
@ -891,60 +883,20 @@ static auto parseWhitelist(std::string_view whitelist)
return list;
}
static void tr_rpcSetHostWhitelist(tr_rpc_server* server, std::string_view whitelist)
void tr_rpc_server::setWhitelist(std::string_view sv)
{
server->hostWhitelist = parseWhitelist(whitelist);
}
void tr_rpcSetWhitelist(tr_rpc_server* server, std::string_view whitelist)
{
server->whitelistStr = whitelist;
server->whitelist = parseWhitelist(whitelist);
}
std::string const& tr_rpcGetWhitelist(tr_rpc_server const* server)
{
return server->whitelistStr;
}
void tr_rpcSetWhitelistEnabled(tr_rpc_server* server, bool isEnabled)
{
server->isWhitelistEnabled = isEnabled;
}
bool tr_rpcGetWhitelistEnabled(tr_rpc_server const* server)
{
return server->isWhitelistEnabled;
}
static void tr_rpcSetHostWhitelistEnabled(tr_rpc_server* server, bool isEnabled)
{
server->isHostWhitelistEnabled = isEnabled;
}
int tr_rpcGetRPCSocketMode(tr_rpc_server const* server)
{
return server->rpc_socket_mode;
}
static void tr_rpcSetRPCSocketMode(tr_rpc_server* server, int socket_mode)
{
server->rpc_socket_mode = socket_mode;
this->whitelist_str_ = sv;
this->whitelist_ = parseWhitelist(sv);
}
/****
***** PASSWORD
****/
void tr_rpcSetUsername(tr_rpc_server* server, std::string_view username)
void tr_rpc_server::setUsername(std::string_view username)
{
server->username = username;
tr_logAddDebug(fmt::format("setting our username to '{}'", server->username));
}
std::string const& tr_rpcGetUsername(tr_rpc_server const* server)
{
return server->username;
username_ = username;
tr_logAddDebug(fmt::format(FMT_STRING("setting our username to '{:s}'"), username_));
}
static bool isSalted(std::string_view password)
@ -952,59 +904,35 @@ static bool isSalted(std::string_view password)
return tr_ssha1_test(password);
}
void tr_rpcSetPassword(tr_rpc_server* server, std::string_view password)
void tr_rpc_server::setPassword(std::string_view password) noexcept
{
server->salted_password = isSalted(password) ? password : tr_ssha1(password);
salted_password_ = isSalted(password) ? password : tr_ssha1(password);
tr_logAddDebug(fmt::format("setting our salted password to '{}'", server->salted_password));
tr_logAddDebug(fmt::format(FMT_STRING("setting our salted password to '{:s}'"), salted_password_));
}
std::string const& tr_rpcGetPassword(tr_rpc_server const* server)
void tr_rpc_server::setPasswordEnabled(bool enabled)
{
return server->salted_password;
is_password_enabled_ = enabled;
tr_logAddDebug(fmt::format("setting password-enabled to '{}'", enabled));
}
void tr_rpcSetPasswordEnabled(tr_rpc_server* server, bool isEnabled)
std::string tr_rpc_server::getBindAddress() const
{
server->isPasswordEnabled = isEnabled;
tr_logAddDebug(fmt::format("setting password-enabled to '{}'", isEnabled));
auto buf = std::array<char, TrUnixAddrStrLen>{};
return tr_rpc_address_to_string(*this->bindAddress, std::data(buf), std::size(buf));
}
bool tr_rpcIsPasswordEnabled(tr_rpc_server const* server)
void tr_rpc_server::setAntiBruteForceEnabled(bool enabled) noexcept
{
return server->isPasswordEnabled;
}
is_anti_brute_force_enabled_ = enabled;
char const* tr_rpcGetBindAddress(tr_rpc_server const* server)
{
static char addr_buf[TrUnixAddrStrLen];
return tr_rpc_address_to_string(*server->bindAddress, addr_buf, sizeof(addr_buf));
}
bool tr_rpcGetAntiBruteForceEnabled(tr_rpc_server const* server)
{
return server->isAntiBruteForceEnabled;
}
void tr_rpcSetAntiBruteForceEnabled(tr_rpc_server* server, bool isEnabled)
{
server->isAntiBruteForceEnabled = isEnabled;
if (!isEnabled)
if (!enabled)
{
server->loginattempts = 0;
login_attempts_ = 0;
}
}
int tr_rpcGetAntiBruteForceThreshold(tr_rpc_server const* server)
{
return server->antiBruteForceThreshold;
}
void tr_rpcSetAntiBruteForceThreshold(tr_rpc_server* server, int badRequests)
{
server->antiBruteForceThreshold = badRequests;
}
/****
***** LIFE CYCLE
****/
@ -1031,7 +959,7 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
this->isEnabled = boolVal;
this->is_enabled_ = boolVal;
}
key = TR_KEY_rpc_port;
@ -1053,11 +981,11 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else if (std::empty(sv) || sv.back() != '/')
{
this->url = fmt::format(FMT_STRING("{:s}/"), sv);
this->url_ = fmt::format(FMT_STRING("{:s}/"), sv);
}
else
{
this->url = sv;
this->url_ = sv;
}
key = TR_KEY_rpc_whitelist_enabled;
@ -1068,7 +996,7 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetWhitelistEnabled(this, boolVal);
this->setWhitelistEnabled(boolVal);
}
key = TR_KEY_rpc_host_whitelist_enabled;
@ -1079,18 +1007,18 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetHostWhitelistEnabled(this, boolVal);
this->isHostWhitelistEnabled = boolVal;
}
key = TR_KEY_rpc_host_whitelist;
if (!tr_variantDictFindStrView(settings, key, &sv) && !std::empty(sv))
if (!tr_variantDictFindStrView(settings, key, &sv))
{
missing_settings_key(key);
}
else
else if (!std::empty(sv))
{
tr_rpcSetHostWhitelist(this, sv);
this->hostWhitelist = parseWhitelist(sv);
}
key = TR_KEY_rpc_authentication_required;
@ -1101,18 +1029,18 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetPasswordEnabled(this, boolVal);
this->setPasswordEnabled(boolVal);
}
key = TR_KEY_rpc_whitelist;
if (!tr_variantDictFindStrView(settings, key, &sv) && !std::empty(sv))
if (!tr_variantDictFindStrView(settings, key, &sv))
{
missing_settings_key(key);
}
else
else if (!std::empty(sv))
{
tr_rpcSetWhitelist(this, sv);
this->setWhitelist(sv);
}
key = TR_KEY_rpc_username;
@ -1123,7 +1051,7 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetUsername(this, sv);
this->setUsername(sv);
}
key = TR_KEY_rpc_password;
@ -1134,7 +1062,7 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetPassword(this, sv);
this->setPassword(sv);
}
key = TR_KEY_anti_brute_force_enabled;
@ -1145,7 +1073,7 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetAntiBruteForceEnabled(this, boolVal);
this->setAntiBruteForceEnabled(boolVal);
}
key = TR_KEY_anti_brute_force_threshold;
@ -1156,7 +1084,7 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetAntiBruteForceThreshold(this, i);
this->setAntiBruteForceLimit(i);
}
key = TR_KEY_rpc_socket_mode;
@ -1167,7 +1095,7 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
}
else
{
tr_rpcSetRPCSocketMode(this, i);
this->socket_mode_ = i;
}
key = TR_KEY_rpc_bind_address;
@ -1188,22 +1116,22 @@ tr_rpc_server::tr_rpc_server(tr_session* session_in, tr_variant* settings)
if (bindAddress->type == TR_RPC_AF_UNIX)
{
this->isWhitelistEnabled = false;
this->setWhitelistEnabled(false);
this->isHostWhitelistEnabled = false;
}
if (this->isEnabled)
if (this->isEnabled())
{
auto const rpc_uri = tr_rpc_address_with_port(this) + this->url;
auto const rpc_uri = tr_rpc_address_with_port(this) + this->url_;
tr_logAddInfo(fmt::format(_("Serving RPC and Web requests on {address}"), fmt::arg("address", rpc_uri)));
tr_runInEventThread(session, startServer, this);
if (this->isWhitelistEnabled)
if (this->isWhitelistEnabled())
{
tr_logAddInfo(_("Whitelist enabled"));
}
if (this->isPasswordEnabled)
if (this->isPasswordEnabled())
{
tr_logAddInfo(_("Password required"));
}

142
libtransmission/rpc-server.h
View File

@ -42,14 +42,90 @@ public:
void setPort(tr_port) noexcept;
[[nodiscard]] constexpr auto isEnabled() const noexcept
{
return is_enabled_;
}
void setEnabled(bool is_enabled);
[[nodiscard]] constexpr auto isWhitelistEnabled() const noexcept
{
return is_whitelist_enabled_;
}
constexpr void setWhitelistEnabled(bool is_whitelist_enabled) noexcept
{
is_whitelist_enabled_ = is_whitelist_enabled;
}
[[nodiscard]] constexpr auto const& whitelist() const noexcept
{
return whitelist_str_;
}
void setWhitelist(std::string_view whitelist);
[[nodiscard]] constexpr auto const& username() const noexcept
{
return username_;
}
void setUsername(std::string_view username);
[[nodiscard]] constexpr auto isPasswordEnabled() const noexcept
{
return is_password_enabled_;
}
void setPasswordEnabled(bool enabled);
[[nodiscard]] constexpr auto const& getSaltedPassword()
{
return salted_password_;
}
void setPassword(std::string_view salted) noexcept;
[[nodiscard]] constexpr auto isAntiBruteForceEnabled() const noexcept
{
return is_anti_brute_force_enabled_;
}
void setAntiBruteForceEnabled(bool enabled) noexcept;
[[nodiscard]] constexpr auto getAntiBruteForceLimit() const noexcept
{
return anti_brute_force_limit_;
}
constexpr void setAntiBruteForceLimit(int limit) noexcept
{
anti_brute_force_limit_ = limit;
}
std::shared_ptr<libdeflate_compressor> compressor;
[[nodiscard]] constexpr auto const& url() const noexcept
{
return url_;
}
void setUrl(std::string_view url);
[[nodiscard]] std::string getBindAddress() const;
[[nodiscard]] constexpr auto socketMode() const noexcept
{
return socket_mode_;
}
std::vector<std::string> hostWhitelist;
std::vector<std::string> whitelist;
std::string salted_password;
std::string username;
std::string whitelistStr;
std::string url;
std::vector<std::string> whitelist_;
std::string salted_password_;
std::string username_;
std::string whitelist_str_;
std::string url_;
std::unique_ptr<struct tr_rpc_address> bindAddress;
@ -57,59 +133,17 @@ public:
struct evhttp* httpd = nullptr;
tr_session* const session;
int antiBruteForceThreshold = 0;
int loginattempts = 0;
int anti_brute_force_limit_ = 0;
int login_attempts_ = 0;
int start_retry_counter = 0;
static int constexpr DefaultRpcSocketMode = 0750;
int rpc_socket_mode = DefaultRpcSocketMode;
int socket_mode_ = DefaultRpcSocketMode;
tr_port port_;
bool isAntiBruteForceEnabled = false;
bool isEnabled = false;
bool is_anti_brute_force_enabled_ = false;
bool is_enabled_ = false;
bool isHostWhitelistEnabled = false;
bool isPasswordEnabled = false;
bool isWhitelistEnabled = false;
bool is_password_enabled_ = false;
bool is_whitelist_enabled_ = false;
};
void tr_rpcSetEnabled(tr_rpc_server* server, bool isEnabled);
bool tr_rpcIsEnabled(tr_rpc_server const* server);
void tr_rpcSetUrl(tr_rpc_server* server, std::string_view url);
std::string const& tr_rpcGetUrl(tr_rpc_server const* server);
int tr_rpcSetTest(tr_rpc_server const* server, char const* whitelist, char** allocme_errmsg);
void tr_rpcSetWhitelistEnabled(tr_rpc_server* server, bool isEnabled);
bool tr_rpcGetWhitelistEnabled(tr_rpc_server const* server);
void tr_rpcSetWhitelist(tr_rpc_server* server, std::string_view whitelist);
int tr_rpcGetRPCSocketMode(tr_rpc_server const* server);
std::string const& tr_rpcGetWhitelist(tr_rpc_server const* server);
void tr_rpcSetPassword(tr_rpc_server* server, std::string_view password);
std::string const& tr_rpcGetPassword(tr_rpc_server const* server);
void tr_rpcSetUsername(tr_rpc_server* server, std::string_view username);
std::string const& tr_rpcGetUsername(tr_rpc_server const* server);
void tr_rpcSetPasswordEnabled(tr_rpc_server* server, bool isEnabled);
bool tr_rpcIsPasswordEnabled(tr_rpc_server const* session);
bool tr_rpcGetAntiBruteForceEnabled(tr_rpc_server const* server);
void tr_rpcSetAntiBruteForceEnabled(tr_rpc_server* server, bool is_enabled);
int tr_rpcGetAntiBruteForceThreshold(tr_rpc_server const* server);
void tr_rpcSetAntiBruteForceThreshold(tr_rpc_server* server, int badRequests);
char const* tr_rpcGetBindAddress(tr_rpc_server const* server);

83
libtransmission/session.cc
View File

@ -441,11 +441,11 @@ void tr_sessionGetSettings(tr_session const* s, tr_variant* d)
tr_variantDictAddBool(d, TR_KEY_ratio_limit_enabled, s->isRatioLimited);
tr_variantDictAddBool(d, TR_KEY_rename_partial_files, tr_sessionIsIncompleteFileNamingEnabled(s));
tr_variantDictAddBool(d, TR_KEY_rpc_authentication_required, tr_sessionIsRPCPasswordEnabled(s));
tr_variantDictAddStr(d, TR_KEY_rpc_bind_address, tr_sessionGetRPCBindAddress(s));
tr_variantDictAddStr(d, TR_KEY_rpc_bind_address, s->rpc_server_->getBindAddress());
tr_variantDictAddBool(d, TR_KEY_rpc_enabled, tr_sessionIsRPCEnabled(s));
tr_variantDictAddStr(d, TR_KEY_rpc_password, tr_sessionGetRPCPassword(s));
tr_variantDictAddInt(d, TR_KEY_rpc_port, tr_sessionGetRPCPort(s));
tr_variantDictAddInt(d, TR_KEY_rpc_socket_mode, tr_rpcGetRPCSocketMode(s->rpc_server_.get()));
tr_variantDictAddInt(d, TR_KEY_rpc_socket_mode, s->rpc_server_->socketMode());
tr_variantDictAddStr(d, TR_KEY_rpc_url, tr_sessionGetRPCUrl(s));
tr_variantDictAddStr(d, TR_KEY_rpc_username, tr_sessionGetRPCUsername(s));
tr_variantDictAddStr(d, TR_KEY_rpc_whitelist, tr_sessionGetRPCWhitelist(s));
@ -2531,36 +2531,31 @@ char const* tr_blocklistGetURL(tr_session const* session)
void tr_session::setRpcWhitelist(std::string_view whitelist) const
{
tr_rpcSetWhitelist(this->rpc_server_.get(), whitelist);
}
std::string const& tr_session::rpcWhitelist() const
{
return tr_rpcGetWhitelist(this->rpc_server_.get());
this->rpc_server_->setWhitelist(whitelist);
}
void tr_session::useRpcWhitelist(bool enabled) const
{
tr_rpcSetWhitelistEnabled(this->rpc_server_.get(), enabled);
this->rpc_server_->setWhitelistEnabled(enabled);
}
bool tr_session::useRpcWhitelist() const
{
return tr_rpcGetWhitelistEnabled(this->rpc_server_.get());
return this->rpc_server_->isWhitelistEnabled();
}
void tr_sessionSetRPCEnabled(tr_session* session, bool isEnabled)
void tr_sessionSetRPCEnabled(tr_session* session, bool is_enabled)
{
TR_ASSERT(tr_isSession(session));
tr_rpcSetEnabled(session->rpc_server_.get(), isEnabled);
session->rpc_server_->setEnabled(is_enabled);
}
bool tr_sessionIsRPCEnabled(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcIsEnabled(session->rpc_server_.get());
return session->rpc_server_->isEnabled();
}
void tr_sessionSetRPCPort(tr_session* session, uint16_t hport)
@ -2584,14 +2579,14 @@ void tr_sessionSetRPCUrl(tr_session* session, char const* url)
{
TR_ASSERT(tr_isSession(session));
tr_rpcSetUrl(session->rpc_server_.get(), url != nullptr ? url : "");
session->rpc_server_->setUrl(url != nullptr ? url : "");
}
char const* tr_sessionGetRPCUrl(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcGetUrl(session->rpc_server_.get()).c_str();
return session->rpc_server_->url().c_str();
}
void tr_sessionSetRPCCallback(tr_session* session, tr_rpc_func func, void* user_data)
@ -2613,7 +2608,7 @@ char const* tr_sessionGetRPCWhitelist(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return session->rpcWhitelist().c_str();
return session->rpc_server_->whitelist().c_str();
}
void tr_sessionSetRPCWhitelistEnabled(tr_session* session, bool enabled)
@ -2634,49 +2629,42 @@ void tr_sessionSetRPCPassword(tr_session* session, char const* password)
{
TR_ASSERT(tr_isSession(session));
tr_rpcSetPassword(session->rpc_server_.get(), password != nullptr ? password : "");
session->rpc_server_->setPassword(password != nullptr ? password : "");
}
char const* tr_sessionGetRPCPassword(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcGetPassword(session->rpc_server_.get()).c_str();
return session->rpc_server_->getSaltedPassword().c_str();
}
void tr_sessionSetRPCUsername(tr_session* session, char const* username)
{
TR_ASSERT(tr_isSession(session));
tr_rpcSetUsername(session->rpc_server_.get(), username != nullptr ? username : "");
session->rpc_server_->setUsername(username != nullptr ? username : "");
}
char const* tr_sessionGetRPCUsername(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcGetUsername(session->rpc_server_.get()).c_str();
return session->rpc_server_->username().c_str();
}
void tr_sessionSetRPCPasswordEnabled(tr_session* session, bool isEnabled)
void tr_sessionSetRPCPasswordEnabled(tr_session* session, bool enabled)
{
TR_ASSERT(tr_isSession(session));
tr_rpcSetPasswordEnabled(session->rpc_server_.get(), isEnabled);
session->rpc_server_->setPasswordEnabled(enabled);
}
bool tr_sessionIsRPCPasswordEnabled(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcIsPasswordEnabled(session->rpc_server_.get());
}
char const* tr_sessionGetRPCBindAddress(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcGetBindAddress(session->rpc_server_.get());
return session->rpc_server_->isPasswordEnabled();
}
/****
@ -2780,32 +2768,33 @@ int tr_sessionGetQueueStalledMinutes(tr_session const* session)
return session->queueStalledMinutes;
}
void tr_sessionSetAntiBruteForceThreshold(tr_session* session, int bad_requests)
void tr_sessionSetAntiBruteForceThreshold(tr_session* session, int limit)
{
TR_ASSERT(tr_isSession(session));
TR_ASSERT(bad_requests > 0);
tr_rpcSetAntiBruteForceThreshold(session->rpc_server_.get(), bad_requests);
}
TR_ASSERT(limit > 0);
void tr_sessionSetAntiBruteForceEnabled(tr_session* session, bool is_enabled)
{
TR_ASSERT(tr_isSession(session));
tr_rpcSetAntiBruteForceEnabled(session->rpc_server_.get(), is_enabled);
}
bool tr_sessionGetAntiBruteForceEnabled(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcGetAntiBruteForceEnabled(session->rpc_server_.get());
session->rpc_server_->setAntiBruteForceLimit(limit);
}
int tr_sessionGetAntiBruteForceThreshold(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return tr_rpcGetAntiBruteForceThreshold(session->rpc_server_.get());
return session->rpc_server_->getAntiBruteForceLimit();
}
void tr_sessionSetAntiBruteForceEnabled(tr_session* session, bool is_enabled)
{
TR_ASSERT(tr_isSession(session));
session->rpc_server_->setAntiBruteForceEnabled(is_enabled);
}
bool tr_sessionGetAntiBruteForceEnabled(tr_session const* session)
{
TR_ASSERT(tr_isSession(session));
return session->rpc_server_->isAntiBruteForceEnabled();
}
std::vector<tr_torrent*> tr_sessionGetNextQueuedTorrents(tr_session* session, tr_direction direction, size_t num_wanted)

2
libtransmission/session.h
View File

@ -223,8 +223,6 @@ public:
void setRpcWhitelist(std::string_view whitelist) const;
std::string const& rpcWhitelist() const;
void useRpcWhitelist(bool enabled) const;
[[nodiscard]] bool useRpcWhitelist() const;

2
libtransmission/transmission.h
View File

@ -389,8 +389,6 @@ void tr_sessionSetRPCPasswordEnabled(tr_session* session, bool isEnabled);
bool tr_sessionIsRPCPasswordEnabled(tr_session const* session);
char const* tr_sessionGetRPCBindAddress(tr_session const* session);
void tr_sessionSetDefaultTrackers(tr_session* session, char const* trackers);
enum tr_rpc_callback_type