jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
3 *
4 * SPDX-License-Identifier: BSD-2-Clause
5 */
6
7#include <AK/Badge.h>
8#include <AK/NonnullOwnPtr.h>
9#include <LibCore/Proxy.h>
10#include <RequestServer/ConnectionFromClient.h>
11#include <RequestServer/Protocol.h>
12#include <RequestServer/Request.h>
13#include <RequestServer/RequestClientEndpoint.h>
14#include <netdb.h>
15
16namespace RequestServer {
17
18static HashMap<int, RefPtr<ConnectionFromClient>> s_connections;
19
20ConnectionFromClient::ConnectionFromClient(NonnullOwnPtr<Core::LocalSocket> socket)
21 : IPC::ConnectionFromClient<RequestClientEndpoint, RequestServerEndpoint>(*this, move(socket), 1)
22{
23 s_connections.set(1, *this);
24}
25
26void ConnectionFromClient::die()
27{
28 s_connections.remove(client_id());
29 if (s_connections.is_empty())
30 Core::EventLoop::current().quit(0);
31}
32
33Messages::RequestServer::IsSupportedProtocolResponse ConnectionFromClient::is_supported_protocol(DeprecatedString const& protocol)
34{
35 bool supported = Protocol::find_by_name(protocol.to_lowercase());
36 return supported;
37}
38
39Messages::RequestServer::StartRequestResponse ConnectionFromClient::start_request(DeprecatedString const& method, URL const& url, IPC::Dictionary const& request_headers, ByteBuffer const& request_body, Core::ProxyData const& proxy_data)
40{
41 if (!url.is_valid()) {
42 dbgln("StartRequest: Invalid URL requested: '{}'", url);
43 return { -1, Optional<IPC::File> {} };
44 }
45 auto* protocol = Protocol::find_by_name(url.scheme());
46 if (!protocol) {
47 dbgln("StartRequest: No protocol handler for URL: '{}'", url);
48 return { -1, Optional<IPC::File> {} };
49 }
50 auto request = protocol->start_request(*this, method, url, request_headers.entries(), request_body, proxy_data);
51 if (!request) {
52 dbgln("StartRequest: Protocol handler failed to start request: '{}'", url);
53 return { -1, Optional<IPC::File> {} };
54 }
55 auto id = request->id();
56 auto fd = request->request_fd();
57 m_requests.set(id, move(request));
58 return { id, IPC::File(fd, IPC::File::CloseAfterSending) };
59}
60
61Messages::RequestServer::StopRequestResponse ConnectionFromClient::stop_request(i32 request_id)
62{
63 auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
64 bool success = false;
65 if (request) {
66 request->stop();
67 m_requests.remove(request_id);
68 success = true;
69 }
70 return success;
71}
72
73void ConnectionFromClient::did_receive_headers(Badge<Request>, Request& request)
74{
75 IPC::Dictionary response_headers;
76 for (auto& it : request.response_headers())
77 response_headers.add(it.key, it.value);
78
79 async_headers_became_available(request.id(), move(response_headers), request.status_code());
80}
81
82void ConnectionFromClient::did_finish_request(Badge<Request>, Request& request, bool success)
83{
84 if (request.total_size().has_value())
85 async_request_finished(request.id(), success, request.total_size().value());
86
87 m_requests.remove(request.id());
88}
89
90void ConnectionFromClient::did_progress_request(Badge<Request>, Request& request)
91{
92 async_request_progress(request.id(), request.total_size(), request.downloaded_size());
93}
94
95void ConnectionFromClient::did_request_certificates(Badge<Request>, Request& request)
96{
97 async_certificate_requested(request.id());
98}
99
100Messages::RequestServer::SetCertificateResponse ConnectionFromClient::set_certificate(i32 request_id, DeprecatedString const& certificate, DeprecatedString const& key)
101{
102 auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
103 bool success = false;
104 if (request) {
105 request->set_certificate(certificate, key);
106 success = true;
107 }
108 return success;
109}
110
111struct Job {
112 explicit Job(URL url)
113 : m_url(move(url))
114 {
115 }
116
117 static Job& ensure(URL const& url)
118 {
119 if (auto it = s_jobs.find(url); it == s_jobs.end()) {
120 auto job = make<Job>(url);
121 s_jobs.set(url, move(job));
122 }
123 return *s_jobs.find(url)->value;
124 }
125
126 void start(Core::Socket& socket)
127 {
128 auto is_connected = socket.is_open();
129 VERIFY(is_connected);
130 ConnectionCache::request_did_finish(m_url, &socket);
131 s_jobs.remove(m_url);
132 }
133 void fail(Core::NetworkJob::Error error)
134 {
135 dbgln("Pre-connect to {} failed: {}", m_url, Core::to_string(error));
136 s_jobs.remove(m_url);
137 }
138 URL m_url;
139
140private:
141 static HashMap<URL, NonnullOwnPtr<Job>> s_jobs;
142};
143HashMap<URL, NonnullOwnPtr<Job>> Job::s_jobs {};
144
145void ConnectionFromClient::ensure_connection(URL const& url, ::RequestServer::CacheLevel const& cache_level)
146{
147 if (!url.is_valid()) {
148 dbgln("EnsureConnection: Invalid URL requested: '{}'", url);
149 return;
150 }
151
152 if (cache_level == CacheLevel::ResolveOnly) {
153 return Core::deferred_invoke([host = url.host()] {
154 dbgln("EnsureConnection: DNS-preload for {}", host);
155 (void)gethostbyname(host.characters());
156 });
157 }
158
159 auto& job = Job::ensure(url);
160 dbgln("EnsureConnection: Pre-connect to {}", url);
161 auto do_preconnect = [&](auto& cache) {
162 auto it = cache.find({ url.host(), url.port_or_default() });
163 if (it == cache.end() || it->value->is_empty())
164 ConnectionCache::get_or_create_connection(cache, url, job);
165 };
166
167 if (url.scheme() == "http"sv)
168 do_preconnect(ConnectionCache::g_tcp_connection_cache);
169 else if (url.scheme() == "https"sv)
170 do_preconnect(ConnectionCache::g_tls_connection_cache);
171 else
172 dbgln("EnsureConnection: Invalid URL scheme: '{}'", url.scheme());
173}
174
175}