2021-04-23 20:45:52 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <AK/Badge.h>
|
2022-03-17 16:03:13 +00:00
|
|
|
#include <AK/NonnullOwnPtr.h>
|
2022-04-07 16:40:33 +00:00
|
|
|
#include <LibCore/Proxy.h>
|
2022-02-25 10:18:30 +00:00
|
|
|
#include <RequestServer/ConnectionFromClient.h>
|
2021-04-23 20:45:52 +00:00
|
|
|
#include <RequestServer/Protocol.h>
|
|
|
|
#include <RequestServer/Request.h>
|
|
|
|
#include <RequestServer/RequestClientEndpoint.h>
|
2021-09-27 20:36:52 +00:00
|
|
|
#include <netdb.h>
|
2021-04-23 20:45:52 +00:00
|
|
|
|
|
|
|
namespace RequestServer {
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
static HashMap<int, RefPtr<ConnectionFromClient>> s_connections;
|
2021-04-23 20:45:52 +00:00
|
|
|
|
2023-02-08 22:05:44 +00:00
|
|
|
ConnectionFromClient::ConnectionFromClient(NonnullOwnPtr<Core::LocalSocket> socket)
|
2022-02-25 10:18:30 +00:00
|
|
|
: IPC::ConnectionFromClient<RequestClientEndpoint, RequestServerEndpoint>(*this, move(socket), 1)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2021-12-06 17:11:05 +00:00
|
|
|
s_connections.set(1, *this);
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
void ConnectionFromClient::die()
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
|
|
|
s_connections.remove(client_id());
|
|
|
|
if (s_connections.is_empty())
|
|
|
|
Core::EventLoop::current().quit(0);
|
|
|
|
}
|
|
|
|
|
2022-12-04 18:02:33 +00:00
|
|
|
Messages::RequestServer::IsSupportedProtocolResponse ConnectionFromClient::is_supported_protocol(DeprecatedString const& protocol)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2021-05-02 17:54:34 +00:00
|
|
|
bool supported = Protocol::find_by_name(protocol.to_lowercase());
|
2021-05-02 02:39:36 +00:00
|
|
|
return supported;
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2023-05-14 21:04:47 +00:00
|
|
|
Messages::RequestServer::StartRequestResponse ConnectionFromClient::start_request(DeprecatedString const& method, URL const& url, HashMap<DeprecatedString, DeprecatedString> const& request_headers, ByteBuffer const& request_body, Core::ProxyData const& proxy_data)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
|
|
|
if (!url.is_valid()) {
|
|
|
|
dbgln("StartRequest: Invalid URL requested: '{}'", url);
|
2021-05-02 02:39:36 +00:00
|
|
|
return { -1, Optional<IPC::File> {} };
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
2022-09-28 23:30:58 +00:00
|
|
|
auto* protocol = Protocol::find_by_name(url.scheme());
|
2021-04-23 20:45:52 +00:00
|
|
|
if (!protocol) {
|
|
|
|
dbgln("StartRequest: No protocol handler for URL: '{}'", url);
|
2021-05-02 02:39:36 +00:00
|
|
|
return { -1, Optional<IPC::File> {} };
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
2023-05-14 21:04:47 +00:00
|
|
|
auto request = protocol->start_request(*this, method, url, request_headers, request_body, proxy_data);
|
2021-04-23 20:45:52 +00:00
|
|
|
if (!request) {
|
|
|
|
dbgln("StartRequest: Protocol handler failed to start request: '{}'", url);
|
2021-05-02 02:39:36 +00:00
|
|
|
return { -1, Optional<IPC::File> {} };
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
auto id = request->id();
|
|
|
|
auto fd = request->request_fd();
|
|
|
|
m_requests.set(id, move(request));
|
2021-05-02 02:39:36 +00:00
|
|
|
return { id, IPC::File(fd, IPC::File::CloseAfterSending) };
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
Messages::RequestServer::StopRequestResponse ConnectionFromClient::stop_request(i32 request_id)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2021-05-02 17:54:34 +00:00
|
|
|
auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
|
2021-04-23 20:45:52 +00:00
|
|
|
bool success = false;
|
|
|
|
if (request) {
|
|
|
|
request->stop();
|
2021-05-02 17:54:34 +00:00
|
|
|
m_requests.remove(request_id);
|
2021-04-23 20:45:52 +00:00
|
|
|
success = true;
|
|
|
|
}
|
2021-05-02 02:39:36 +00:00
|
|
|
return success;
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
void ConnectionFromClient::did_receive_headers(Badge<Request>, Request& request)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2023-05-14 21:04:47 +00:00
|
|
|
auto response_headers = request.response_headers().clone().release_value_but_fixme_should_propagate_errors();
|
2021-05-03 11:33:59 +00:00
|
|
|
async_headers_became_available(request.id(), move(response_headers), request.status_code());
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
void ConnectionFromClient::did_finish_request(Badge<Request>, Request& request, bool success)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2022-06-20 15:43:35 +00:00
|
|
|
if (request.total_size().has_value())
|
|
|
|
async_request_finished(request.id(), success, request.total_size().value());
|
2021-04-23 20:45:52 +00:00
|
|
|
|
|
|
|
m_requests.remove(request.id());
|
|
|
|
}
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
void ConnectionFromClient::did_progress_request(Badge<Request>, Request& request)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2021-05-03 11:33:59 +00:00
|
|
|
async_request_progress(request.id(), request.total_size(), request.downloaded_size());
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
void ConnectionFromClient::did_request_certificates(Badge<Request>, Request& request)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2021-05-03 11:33:59 +00:00
|
|
|
async_certificate_requested(request.id());
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2022-12-04 18:02:33 +00:00
|
|
|
Messages::RequestServer::SetCertificateResponse ConnectionFromClient::set_certificate(i32 request_id, DeprecatedString const& certificate, DeprecatedString const& key)
|
2021-04-23 20:45:52 +00:00
|
|
|
{
|
2021-05-02 17:54:34 +00:00
|
|
|
auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
|
2021-04-23 20:45:52 +00:00
|
|
|
bool success = false;
|
|
|
|
if (request) {
|
2021-05-02 17:54:34 +00:00
|
|
|
request->set_certificate(certificate, key);
|
2021-04-23 20:45:52 +00:00
|
|
|
success = true;
|
|
|
|
}
|
2021-05-02 02:39:36 +00:00
|
|
|
return success;
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|
|
|
|
|
2022-03-17 16:03:13 +00:00
|
|
|
struct Job {
|
|
|
|
explicit Job(URL url)
|
|
|
|
: m_url(move(url))
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static Job& ensure(URL const& url)
|
|
|
|
{
|
|
|
|
if (auto it = s_jobs.find(url); it == s_jobs.end()) {
|
|
|
|
auto job = make<Job>(url);
|
|
|
|
s_jobs.set(url, move(job));
|
|
|
|
}
|
|
|
|
return *s_jobs.find(url)->value;
|
|
|
|
}
|
|
|
|
|
2023-02-08 22:05:44 +00:00
|
|
|
void start(Core::Socket& socket)
|
2022-03-17 16:03:13 +00:00
|
|
|
{
|
|
|
|
auto is_connected = socket.is_open();
|
|
|
|
VERIFY(is_connected);
|
|
|
|
ConnectionCache::request_did_finish(m_url, &socket);
|
|
|
|
s_jobs.remove(m_url);
|
|
|
|
}
|
|
|
|
void fail(Core::NetworkJob::Error error)
|
|
|
|
{
|
|
|
|
dbgln("Pre-connect to {} failed: {}", m_url, Core::to_string(error));
|
|
|
|
s_jobs.remove(m_url);
|
|
|
|
}
|
|
|
|
URL m_url;
|
|
|
|
|
|
|
|
private:
|
|
|
|
static HashMap<URL, NonnullOwnPtr<Job>> s_jobs;
|
|
|
|
};
|
|
|
|
HashMap<URL, NonnullOwnPtr<Job>> Job::s_jobs {};
|
|
|
|
|
2022-02-25 10:18:30 +00:00
|
|
|
void ConnectionFromClient::ensure_connection(URL const& url, ::RequestServer::CacheLevel const& cache_level)
|
2021-09-27 20:36:52 +00:00
|
|
|
{
|
|
|
|
if (!url.is_valid()) {
|
|
|
|
dbgln("EnsureConnection: Invalid URL requested: '{}'", url);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cache_level == CacheLevel::ResolveOnly) {
|
|
|
|
return Core::deferred_invoke([host = url.host()] {
|
|
|
|
dbgln("EnsureConnection: DNS-preload for {}", host);
|
|
|
|
(void)gethostbyname(host.characters());
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-03-17 16:03:13 +00:00
|
|
|
auto& job = Job::ensure(url);
|
2021-09-27 20:36:52 +00:00
|
|
|
dbgln("EnsureConnection: Pre-connect to {}", url);
|
|
|
|
auto do_preconnect = [&](auto& cache) {
|
2021-10-01 11:37:09 +00:00
|
|
|
auto it = cache.find({ url.host(), url.port_or_default() });
|
|
|
|
if (it == cache.end() || it->value->is_empty())
|
|
|
|
ConnectionCache::get_or_create_connection(cache, url, job);
|
2021-09-27 20:36:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
if (url.scheme() == "http"sv)
|
|
|
|
do_preconnect(ConnectionCache::g_tcp_connection_cache);
|
|
|
|
else if (url.scheme() == "https"sv)
|
|
|
|
do_preconnect(ConnectionCache::g_tls_connection_cache);
|
|
|
|
else
|
|
|
|
dbgln("EnsureConnection: Invalid URL scheme: '{}'", url.scheme());
|
|
|
|
}
|
|
|
|
|
2021-04-23 20:45:52 +00:00
|
|
|
}
|