diff --git a/Libraries/LibRequests/ALPNHttpVersion.h b/Libraries/LibRequests/ALPNHttpVersion.h new file mode 100644 index 00000000000..6dfaaabb6ec --- /dev/null +++ b/Libraries/LibRequests/ALPNHttpVersion.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2025, Luke Wilde + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include + +namespace Requests { + +// https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids +enum class ALPNHttpVersion { + None, + Http1_0, + Http1_1, + Http2_TLS, + Http2_TCP, + Http3, +}; + +inline FlyString alpn_http_version_to_fly_string(ALPNHttpVersion version) +{ + switch (version) { + case ALPNHttpVersion::None: + return ""_fly_string; + case ALPNHttpVersion::Http1_0: + return "http/1.0"_fly_string; + case ALPNHttpVersion::Http1_1: + return "http/1.1"_fly_string; + case ALPNHttpVersion::Http2_TLS: + return "h2"_fly_string; + case ALPNHttpVersion::Http2_TCP: + return "h2c"_fly_string; + case ALPNHttpVersion::Http3: + return "h3"_fly_string; + default: + VERIFY_NOT_REACHED(); + } +} + +} diff --git a/Libraries/LibRequests/Forward.h b/Libraries/LibRequests/Forward.h index e8b80a80bef..b9cbe703d39 100644 --- a/Libraries/LibRequests/Forward.h +++ b/Libraries/LibRequests/Forward.h @@ -11,5 +11,6 @@ namespace Requests { class Request; class RequestClient; class WebSocket; +struct RequestTimingInfo; } diff --git a/Libraries/LibRequests/Request.cpp b/Libraries/LibRequests/Request.cpp index 4adf079f2c7..d5b9fb33b30 100644 --- a/Libraries/LibRequests/Request.cpp +++ b/Libraries/LibRequests/Request.cpp @@ -53,12 +53,13 @@ void Request::set_buffered_request_finished_callback(BufferedRequestFinished on_ m_internal_buffered_data->reason_phrase = reason_phrase; }; - on_finish = [this, on_buffered_request_finished = move(on_buffered_request_finished)](auto total_size, auto network_error) { + on_finish = [this, on_buffered_request_finished = move(on_buffered_request_finished)](auto total_size, auto& timing_info, auto network_error) { auto output_buffer = ByteBuffer::create_uninitialized(m_internal_buffered_data->payload_stream.used_buffer_size()).release_value_but_fixme_should_propagate_errors(); m_internal_buffered_data->payload_stream.read_until_filled(output_buffer).release_value_but_fixme_should_propagate_errors(); on_buffered_request_finished( total_size, + timing_info, network_error, m_internal_buffered_data->response_headers, m_internal_buffered_data->response_code, @@ -83,10 +84,10 @@ void Request::set_unbuffered_request_callbacks(HeadersReceived on_headers_receiv set_up_internal_stream_data(move(on_data_received)); } -void Request::did_finish(Badge, u64 total_size, Optional const& network_error) +void Request::did_finish(Badge, u64 total_size, RequestTimingInfo const& timing_info, Optional const& network_error) { if (on_finish) - on_finish(total_size, network_error); + on_finish(total_size, timing_info, network_error); } void Request::did_receive_headers(Badge, HTTP::HeaderMap const& response_headers, Optional response_code, Optional const& reason_phrase) @@ -115,9 +116,10 @@ void Request::set_up_internal_stream_data(DataReceived on_data_available) m_internal_stream_data->read_stream = MUST(Core::File::adopt_fd(fd(), Core::File::OpenMode::Read)); auto user_on_finish = move(on_finish); - on_finish = [this](auto total_size, auto network_error) { + on_finish = [this](auto total_size, auto const& timing_info, auto network_error) { m_internal_stream_data->total_size = total_size; m_internal_stream_data->network_error = network_error; + m_internal_stream_data->timing_info = timing_info; m_internal_stream_data->request_done = true; m_internal_stream_data->on_finish(); }; @@ -125,7 +127,7 @@ void Request::set_up_internal_stream_data(DataReceived on_data_available) m_internal_stream_data->on_finish = [this, user_on_finish = move(user_on_finish)]() { if (!m_internal_stream_data->user_finish_called && (!m_internal_stream_data->read_stream || m_internal_stream_data->read_stream->is_eof())) { m_internal_stream_data->user_finish_called = true; - user_on_finish(m_internal_stream_data->total_size, m_internal_stream_data->network_error); + user_on_finish(m_internal_stream_data->total_size, m_internal_stream_data->timing_info, m_internal_stream_data->network_error); } }; diff --git a/Libraries/LibRequests/Request.h b/Libraries/LibRequests/Request.h index 2f60feb5d86..8e0808049cc 100644 --- a/Libraries/LibRequests/Request.h +++ b/Libraries/LibRequests/Request.h @@ -15,6 +15,7 @@ #include #include #include +#include namespace Requests { @@ -36,7 +37,7 @@ public: int fd() const { return m_fd; } bool stop(); - using BufferedRequestFinished = Function const& network_error, HTTP::HeaderMap const& response_headers, Optional response_code, Optional reason_phrase, ReadonlyBytes payload)>; + using BufferedRequestFinished = Function const& network_error, HTTP::HeaderMap const& response_headers, Optional response_code, Optional reason_phrase, ReadonlyBytes payload)>; // Configure the request such that the entirety of the response data is buffered. The callback receives that data and // the response headers all at once. Using this method is mutually exclusive with `set_unbuffered_data_received_callback`. @@ -44,7 +45,7 @@ public: using HeadersReceived = Function response_code, Optional const& reason_phrase)>; using DataReceived = Function; - using RequestFinished = Function network_error)>; + using RequestFinished = Function network_error)>; // Configure the request such that the response data is provided unbuffered as it is received. Using this method is // mutually exclusive with `set_buffered_request_finished_callback`. @@ -52,7 +53,7 @@ public: Function on_certificate_requested; - void did_finish(Badge, u64 total_size, Optional const& network_error); + void did_finish(Badge, u64 total_size, RequestTimingInfo const& timing_info, Optional const& network_error); void did_receive_headers(Badge, HTTP::HeaderMap const& response_headers, Optional response_code, Optional const& reason_phrase); void did_request_certificates(Badge); @@ -94,6 +95,7 @@ private: u32 total_size { 0 }; Optional network_error; bool request_done { false }; + RequestTimingInfo timing_info; Function on_finish {}; bool user_finish_called { false }; }; diff --git a/Libraries/LibRequests/RequestClient.cpp b/Libraries/LibRequests/RequestClient.cpp index be6d43d3313..e4360f4b02f 100644 --- a/Libraries/LibRequests/RequestClient.cpp +++ b/Libraries/LibRequests/RequestClient.cpp @@ -69,11 +69,11 @@ bool RequestClient::set_certificate(Badge, Request& request, ByteString return IPCProxy::set_certificate(request.id(), move(certificate), move(key)); } -void RequestClient::request_finished(i32 request_id, u64 total_size, Optional const& network_error) +void RequestClient::request_finished(i32 request_id, u64 total_size, RequestTimingInfo const& timing_info, Optional const& network_error) { RefPtr request; if ((request = m_requests.get(request_id).value_or(nullptr))) { - request->did_finish({}, total_size, network_error); + request->did_finish({}, total_size, timing_info, network_error); } m_requests.remove(request_id); } diff --git a/Libraries/LibRequests/RequestClient.h b/Libraries/LibRequests/RequestClient.h index 09e8d5dd12b..f5795cae996 100644 --- a/Libraries/LibRequests/RequestClient.h +++ b/Libraries/LibRequests/RequestClient.h @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -42,7 +43,7 @@ private: virtual void die() override; virtual void request_started(i32, IPC::File const&) override; - virtual void request_finished(i32, u64, Optional const&) override; + virtual void request_finished(i32, u64, RequestTimingInfo const&, Optional const&) override; virtual void certificate_requested(i32) override; virtual void headers_became_available(i32, HTTP::HeaderMap const&, Optional const&, Optional const&) override; diff --git a/Libraries/LibRequests/RequestTimingInfo.h b/Libraries/LibRequests/RequestTimingInfo.h new file mode 100644 index 00000000000..258368d585c --- /dev/null +++ b/Libraries/LibRequests/RequestTimingInfo.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2025, Luke Wilde + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#pragma once + +#include +#include +#include +#include + +namespace Requests { + +struct RequestTimingInfo { + long domain_lookup_start_microseconds { 0 }; + long domain_lookup_end_microseconds { 0 }; + long connect_start_microseconds { 0 }; + long connect_end_microseconds { 0 }; + long secure_connect_start_microseconds { 0 }; + long request_start_microseconds { 0 }; + long response_start_microseconds { 0 }; + long response_end_microseconds { 0 }; + long encoded_body_size { 0 }; + ALPNHttpVersion http_version_alpn_identifier { ALPNHttpVersion::None }; +}; + +} + +namespace IPC { + +template<> +inline ErrorOr encode(Encoder& encoder, Requests::RequestTimingInfo const& timing_info) +{ + TRY(encoder.encode(timing_info.domain_lookup_start_microseconds)); + TRY(encoder.encode(timing_info.domain_lookup_end_microseconds)); + TRY(encoder.encode(timing_info.connect_start_microseconds)); + TRY(encoder.encode(timing_info.connect_end_microseconds)); + TRY(encoder.encode(timing_info.secure_connect_start_microseconds)); + TRY(encoder.encode(timing_info.request_start_microseconds)); + TRY(encoder.encode(timing_info.response_start_microseconds)); + TRY(encoder.encode(timing_info.response_end_microseconds)); + TRY(encoder.encode(timing_info.encoded_body_size)); + TRY(encoder.encode(timing_info.http_version_alpn_identifier)); + return {}; +} + +template<> +inline ErrorOr decode(Decoder& decoder) +{ + auto domain_lookup_start_microseconds = TRY(decoder.decode()); + auto domain_lookup_end_microseconds = TRY(decoder.decode()); + auto connect_start_microseconds = TRY(decoder.decode()); + auto connect_end_microseconds = TRY(decoder.decode()); + auto secure_connect_start_microseconds = TRY(decoder.decode()); + auto request_start_microseconds = TRY(decoder.decode()); + auto response_start_microseconds = TRY(decoder.decode()); + auto response_end_microseconds = TRY(decoder.decode()); + auto encoded_body_size = TRY(decoder.decode()); + auto http_version_alpn_identifier = TRY(decoder.decode()); + + return Requests::RequestTimingInfo { + .domain_lookup_start_microseconds = domain_lookup_start_microseconds, + .domain_lookup_end_microseconds = domain_lookup_end_microseconds, + .connect_start_microseconds = connect_start_microseconds, + .connect_end_microseconds = connect_end_microseconds, + .secure_connect_start_microseconds = secure_connect_start_microseconds, + .request_start_microseconds = request_start_microseconds, + .response_start_microseconds = response_start_microseconds, + .response_end_microseconds = response_end_microseconds, + .encoded_body_size = encoded_body_size, + .http_version_alpn_identifier = http_version_alpn_identifier, + }; +} + +} diff --git a/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp b/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp index 311319b6f0a..3faab7b50b6 100644 --- a/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp +++ b/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -2399,7 +2400,7 @@ WebIDL::ExceptionOr> nonstandard_resource_loader_file_o } }); - auto on_complete = GC::create_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Optional error_message) { + auto on_complete = GC::create_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Requests::RequestTimingInfo const&, Optional error_message) { HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes }; // 16.1.1.2. Otherwise, if the bytes transmission for response’s message body is done normally and stream is readable, @@ -2422,7 +2423,7 @@ WebIDL::ExceptionOr> nonstandard_resource_loader_file_o ResourceLoader::the().load_unbuffered(load_request, on_headers_received, on_data_received, on_complete); } else { - auto on_load_success = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, HTTP::HeaderMap const& response_headers, Optional status_code, Optional const& reason_phrase) { + auto on_load_success = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& response_headers, Optional status_code, Optional const& reason_phrase) { (void)request; dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' complete", request->url()); if constexpr (WEB_FETCH_DEBUG) @@ -2442,7 +2443,7 @@ WebIDL::ExceptionOr> nonstandard_resource_loader_file_o pending_response->resolve(response); }); - auto on_load_error = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Optional status_code, Optional const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) { + auto on_load_error = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Requests::RequestTimingInfo const&, Optional status_code, Optional const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) { (void)request; dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' failed: {} (status {})", request->url(), error, status_code.value_or(0)); if constexpr (WEB_FETCH_DEBUG) diff --git a/Libraries/LibWeb/Loader/ResourceLoader.cpp b/Libraries/LibWeb/Loader/ResourceLoader.cpp index 3782fe1f324..0d25b84ba35 100644 --- a/Libraries/LibWeb/Loader/ResourceLoader.cpp +++ b/Libraries/LibWeb/Loader/ResourceLoader.cpp @@ -110,10 +110,10 @@ RefPtr ResourceLoader::load_resource(Resource::Type type, LoadRequest& load( request, - GC::create_function(m_heap, [resource](ReadonlyBytes data, HTTP::HeaderMap const& headers, Optional status_code, Optional const&) { + GC::create_function(m_heap, [resource](ReadonlyBytes data, Requests::RequestTimingInfo const&, HTTP::HeaderMap const& headers, Optional status_code, Optional const&) { resource->did_load({}, data, headers, status_code); }), - GC::create_function(m_heap, [resource](ByteString const& error, Optional status_code, Optional const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) { + GC::create_function(m_heap, [resource](ByteString const& error, Requests::RequestTimingInfo const&, Optional status_code, Optional const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) { resource->did_fail({}, error, data, headers, status_code); })); @@ -240,23 +240,26 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes request.start_timer(); if (should_block_request(request)) { - error_callback->function()("Request was blocked", {}, {}, {}, {}); + error_callback->function()("Request was blocked", {}, {}, {}, {}, {}); return; } auto respond_directory_page = [](LoadRequest const& request, URL::URL const& url, GC::Root success_callback, GC::Root error_callback) { + // FIXME: Implement timing info for directory requests. + Requests::RequestTimingInfo fixme_implement_timing_info {}; + auto maybe_response = load_file_directory_page(url); if (maybe_response.is_error()) { log_failure(request, maybe_response.error()); if (error_callback) - error_callback->function()(ByteString::formatted("{}", maybe_response.error()), 500u, {}, {}, {}); + error_callback->function()(ByteString::formatted("{}", maybe_response.error()), fixme_implement_timing_info, 500u, {}, {}, {}); return; } log_success(request); HTTP::HeaderMap response_headers; response_headers.set("Content-Type"sv, "text/html"sv); - success_callback->function()(maybe_response.release_value().bytes(), response_headers, {}, {}); + success_callback->function()(maybe_response.release_value().bytes(), fixme_implement_timing_info, response_headers, {}, {}); }; if (url.scheme() == "about") { @@ -266,9 +269,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes HTTP::HeaderMap response_headers; response_headers.set("Content-Type", "text/html; charset=UTF-8"); + // FIXME: Implement timing info for about requests. + Requests::RequestTimingInfo fixme_implement_timing_info {}; + // About version page if (url.path_segment_at_index(0) == "version") { - success_callback->function()(MUST(load_about_version_page()).bytes(), response_headers, {}, {}); + success_callback->function()(MUST(load_about_version_page()).bytes(), fixme_implement_timing_info, response_headers, {}, {}); return; } @@ -276,12 +282,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes auto resource = Core::Resource::load_from_uri(MUST(String::formatted("resource://ladybird/{}.html", url.path_segment_at_index(0)))); if (!resource.is_error()) { auto data = resource.value()->data(); - success_callback->function()(data, response_headers, {}, {}); + success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {}); return; } - Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [success_callback, response_headers = move(response_headers)] { - success_callback->function()(ByteString::empty().to_byte_buffer(), response_headers, {}, {}); + Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [success_callback, response_headers = move(response_headers), fixme_implement_timing_info = move(fixme_implement_timing_info)] { + success_callback->function()(ByteString::empty().to_byte_buffer(), fixme_implement_timing_info, response_headers, {}, {}); })); return; } @@ -291,7 +297,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes if (data_url_or_error.is_error()) { auto error_message = data_url_or_error.error().string_literal(); log_failure(request, error_message); - error_callback->function()(error_message, {}, {}, {}, {}); + error_callback->function()(error_message, {}, {}, {}, {}, {}); return; } auto data_url = data_url_or_error.release_value(); @@ -306,7 +312,10 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes log_success(request); Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [data = move(data_url.body), response_headers = move(response_headers), success_callback] { - success_callback->function()(data, response_headers, {}, {}); + // FIXME: Implement timing info for data requests. + Requests::RequestTimingInfo fixme_implement_timing_info {}; + + success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {}); })); return; } @@ -316,7 +325,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes if (resource.is_error()) { log_failure(request, resource.error()); if (error_callback) - error_callback->function()(ByteString::formatted("{}", resource.error()), {}, {}, {}, {}); + error_callback->function()(ByteString::formatted("{}", resource.error()), {}, {}, {}, {}, {}); return; } @@ -331,8 +340,11 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes auto data = resource.value()->data(); auto response_headers = response_headers_for_file(URL::percent_decode(url.serialize_path()), resource.value()->modified_time()); + // FIXME: Implement timing info for resource requests. + Requests::RequestTimingInfo fixme_implement_timing_info {}; + log_success(request); - success_callback->function()(data, response_headers, {}, {}); + success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {}); return; } @@ -352,7 +364,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes if (file_or_error.is_error()) { log_failure(request, file_or_error.error()); if (error_callback) - error_callback->function()(ByteString::formatted("{}", file_or_error.error()), {}, {}, {}, {}); + error_callback->function()(ByteString::formatted("{}", file_or_error.error()), {}, {}, {}, {}, {}); return; } @@ -369,7 +381,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes if (st_or_error.is_error()) { log_failure(request, st_or_error.error()); if (error_callback) - error_callback->function()(ByteString::formatted("{}", st_or_error.error()), {}, {}, {}, {}); + error_callback->function()(ByteString::formatted("{}", st_or_error.error()), {}, {}, {}, {}, {}); return; } @@ -378,7 +390,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes if (maybe_file.is_error()) { log_failure(request, maybe_file.error()); if (error_callback) - error_callback->function()(ByteString::formatted("{}", maybe_file.error()), {}, {}, {}, {}); + error_callback->function()(ByteString::formatted("{}", maybe_file.error()), {}, {}, {}, {}, {}); return; } @@ -387,15 +399,18 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes if (maybe_data.is_error()) { log_failure(request, maybe_data.error()); if (error_callback) - error_callback->function()(ByteString::formatted("{}", maybe_data.error()), {}, {}, {}, {}); + error_callback->function()(ByteString::formatted("{}", maybe_data.error()), {}, {}, {}, {}, {}); return; } auto data = maybe_data.release_value(); auto response_headers = response_headers_for_file(URL::percent_decode(request.url().serialize_path()), st_or_error.value().st_mtime); + // FIXME: Implement timing info for file requests. + Requests::RequestTimingInfo fixme_implement_timing_info {}; + log_success(request); - success_callback->function()(data, response_headers, {}, {}); + success_callback->function()(data, fixme_implement_timing_info, response_headers, {}, {}); }); page->client().request_file(move(file_request)); @@ -411,7 +426,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes auto protocol_request = start_network_request(request); if (!protocol_request) { if (error_callback) - error_callback->function()("Failed to start network request"sv, {}, {}, {}, {}); + error_callback->function()("Failed to start network request"sv, {}, {}, {}, {}, {}); return; } @@ -426,7 +441,7 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes timer->start(); } - auto on_buffered_request_finished = [this, success_callback, error_callback, request, &protocol_request = *protocol_request](auto, auto const& network_error, auto& response_headers, auto status_code, auto const& reason_phrase, ReadonlyBytes payload) mutable { + auto on_buffered_request_finished = [this, success_callback, error_callback, request, &protocol_request = *protocol_request](auto, auto const& timing_info, auto const& network_error, auto& response_headers, auto status_code, auto const& reason_phrase, ReadonlyBytes payload) mutable { handle_network_response_headers(request, response_headers); // NOTE: We finish the network request *after* invoking callbacks, otherwise a nested @@ -449,12 +464,12 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes log_failure(request, error_builder.string_view()); if (error_callback) - error_callback->function()(error_builder.to_byte_string(), status_code, reason_phrase, payload, response_headers); + error_callback->function()(error_builder.to_byte_string(), timing_info, status_code, reason_phrase, payload, response_headers); return; } log_success(request); - success_callback->function()(payload, response_headers, status_code, reason_phrase); + success_callback->function()(payload, timing_info, response_headers, status_code, reason_phrase); }; protocol_request->set_buffered_request_finished_callback(move(on_buffered_request_finished)); @@ -463,8 +478,9 @@ void ResourceLoader::load(LoadRequest& request, GC::Root succes auto not_implemented_error = ByteString::formatted("Protocol not implemented: {}", url.scheme()); log_failure(request, not_implemented_error); - if (error_callback) - error_callback->function()(not_implemented_error, {}, {}, {}, {}); + if (error_callback) { + error_callback->function()(not_implemented_error, {}, {}, {}, {}, {}); + } } void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root on_headers_received, GC::Root on_data_received, GC::Root on_complete) @@ -475,19 +491,19 @@ void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Rootfunction()(false, "Request was blocked"sv); + on_complete->function()(false, {}, "Request was blocked"sv); return; } if (!url.scheme().is_one_of("http"sv, "https"sv)) { // FIXME: Non-network requests from fetch should not go through this path. - on_complete->function()(false, "Cannot establish connection non-network scheme"sv); + on_complete->function()(false, {}, "Cannot establish connection non-network scheme"sv); return; } auto protocol_request = start_network_request(request); if (!protocol_request) { - on_complete->function()(false, "Failed to start network request"sv); + on_complete->function()(false, {}, "Failed to start network request"sv); return; } @@ -500,15 +516,15 @@ void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Rootfunction()(data); }; - auto protocol_complete = [this, on_complete, request, &protocol_request = *protocol_request](u64, Optional const& network_error) { + auto protocol_complete = [this, on_complete, request, &protocol_request = *protocol_request](u64, Requests::RequestTimingInfo const& timing_info, Optional const& network_error) { finish_network_request(protocol_request); if (!network_error.has_value()) { log_success(request); - on_complete->function()(true, {}); + on_complete->function()(true, timing_info, {}); } else { log_failure(request, "Request finished with error"sv); - on_complete->function()(false, "Request finished with error"sv); + on_complete->function()(false, timing_info, "Request finished with error"sv); } }; diff --git a/Libraries/LibWeb/Loader/ResourceLoader.h b/Libraries/LibWeb/Loader/ResourceLoader.h index 96e31ef5af3..2547c85fd10 100644 --- a/Libraries/LibWeb/Loader/ResourceLoader.h +++ b/Libraries/LibWeb/Loader/ResourceLoader.h @@ -26,15 +26,15 @@ public: RefPtr load_resource(Resource::Type, LoadRequest&); - using SuccessCallback = GC::Function status_code, Optional const& reason_phrase)>; - using ErrorCallback = GC::Function status_code, Optional const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>; + using SuccessCallback = GC::Function status_code, Optional const& reason_phrase)>; + using ErrorCallback = GC::Function status_code, Optional const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>; using TimeoutCallback = GC::Function; void load(LoadRequest&, GC::Root success_callback, GC::Root error_callback = nullptr, Optional timeout = {}, GC::Root timeout_callback = nullptr); using OnHeadersReceived = GC::Function status_code, Optional const& reason_phrase)>; using OnDataReceived = GC::Function; - using OnComplete = GC::Function error_message)>; + using OnComplete = GC::Function error_message)>; void load_unbuffered(LoadRequest&, GC::Root, GC::Root, GC::Root); diff --git a/Services/RequestServer/ConnectionFromClient.cpp b/Services/RequestServer/ConnectionFromClient.cpp index fd524f53d53..a2db58e3233 100644 --- a/Services/RequestServer/ConnectionFromClient.cpp +++ b/Services/RequestServer/ConnectionFromClient.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -382,12 +383,14 @@ void ConnectionFromClient::start_request(i32 request_id, ByteString const& metho m_resolver->dns.lookup(host, DNS::Messages::Class::IN, { DNS::Messages::ResourceType::A, DNS::Messages::ResourceType::AAAA }) ->when_rejected([this, request_id](auto const& error) { dbgln("StartRequest: DNS lookup failed: {}", error); - async_request_finished(request_id, 0, Requests::NetworkError::UnableToResolveHost); + // FIXME: Implement timing info for DNS lookup failure. + async_request_finished(request_id, 0, {}, Requests::NetworkError::UnableToResolveHost); }) .when_resolved([this, request_id, host, url, method, request_body, request_headers, proxy_data](auto const& dns_result) { if (dns_result->records().is_empty() || dns_result->cached_addresses().is_empty()) { dbgln("StartRequest: DNS lookup failed for '{}'", host); - async_request_finished(request_id, 0, Requests::NetworkError::UnableToResolveHost); + // FIXME: Implement timing info for DNS lookup failure. + async_request_finished(request_id, 0, {}, Requests::NetworkError::UnableToResolveHost); return; } @@ -522,6 +525,75 @@ static Requests::NetworkError map_curl_code_to_network_error(CURLcode const& cod } } +static Requests::RequestTimingInfo get_timing_info_from_curl_easy_handle(CURL* easy_handle) +{ + /* + * curl_easy_perform() + * | + * |--QUEUE + * |--|--NAMELOOKUP + * |--|--|--CONNECT + * |--|--|--|--APPCONNECT + * |--|--|--|--|--PRETRANSFER + * |--|--|--|--|--|--POSTTRANSFER + * |--|--|--|--|--|--|--STARTTRANSFER + * |--|--|--|--|--|--|--|--TOTAL + * |--|--|--|--|--|--|--|--REDIRECT + */ + + auto get_timing_info = [easy_handle](auto option) { + curl_off_t time_value = 0; + auto result = curl_easy_getinfo(easy_handle, option, &time_value); + VERIFY(result == CURLE_OK); + return time_value; + }; + + auto queue_time = get_timing_info(CURLINFO_QUEUE_TIME_T); + auto domain_lookup_time = get_timing_info(CURLINFO_NAMELOOKUP_TIME_T); + auto connect_time = get_timing_info(CURLINFO_CONNECT_TIME_T); + auto secure_connect_time = get_timing_info(CURLINFO_APPCONNECT_TIME_T); + auto request_start_time = get_timing_info(CURLINFO_PRETRANSFER_TIME_T); + auto response_start_time = get_timing_info(CURLINFO_STARTTRANSFER_TIME_T); + auto response_end_time = get_timing_info(CURLINFO_TOTAL_TIME_T); + auto encoded_body_size = get_timing_info(CURLINFO_SIZE_DOWNLOAD_T); + + long http_version = 0; + auto get_version_result = curl_easy_getinfo(easy_handle, CURLINFO_HTTP_VERSION, &http_version); + VERIFY(get_version_result == CURLE_OK); + + auto http_version_alpn = Requests::ALPNHttpVersion::None; + switch (http_version) { + case CURL_HTTP_VERSION_1_0: + http_version_alpn = Requests::ALPNHttpVersion::Http1_0; + break; + case CURL_HTTP_VERSION_1_1: + http_version_alpn = Requests::ALPNHttpVersion::Http1_1; + break; + case CURL_HTTP_VERSION_2_0: + http_version_alpn = Requests::ALPNHttpVersion::Http2_TLS; + break; + case CURL_HTTP_VERSION_3: + http_version_alpn = Requests::ALPNHttpVersion::Http3; + break; + default: + http_version_alpn = Requests::ALPNHttpVersion::None; + break; + } + + return Requests::RequestTimingInfo { + .domain_lookup_start_microseconds = queue_time, + .domain_lookup_end_microseconds = queue_time + domain_lookup_time, + .connect_start_microseconds = queue_time + domain_lookup_time, + .connect_end_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time, + .secure_connect_start_microseconds = queue_time + domain_lookup_time + connect_time, + .request_start_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + request_start_time, + .response_start_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + response_start_time, + .response_end_microseconds = queue_time + domain_lookup_time + connect_time + secure_connect_time + response_end_time, + .encoded_body_size = encoded_body_size, + .http_version_alpn_identifier = http_version_alpn, + }; +} + void ConnectionFromClient::check_active_requests() { int msgs_in_queue = 0; @@ -547,6 +619,7 @@ void ConnectionFromClient::check_active_requests() auto* request = static_cast(application_private); if (!request->is_connect_only) { + auto timing_info = get_timing_info_from_curl_easy_handle(msg->easy_handle); request->flush_headers_if_needed(); auto result_code = msg->data.result; @@ -562,7 +635,7 @@ void ConnectionFromClient::check_active_requests() } } - async_request_finished(request->request_id, request->downloaded_so_far, network_error); + async_request_finished(request->request_id, request->downloaded_so_far, timing_info, network_error); } m_active_requests.remove(request->request_id); diff --git a/Services/RequestServer/RequestClient.ipc b/Services/RequestServer/RequestClient.ipc index 29624811788..a214cbecebc 100644 --- a/Services/RequestServer/RequestClient.ipc +++ b/Services/RequestServer/RequestClient.ipc @@ -1,11 +1,12 @@ #include #include +#include #include endpoint RequestClient { request_started(i32 request_id, IPC::File fd) =| - request_finished(i32 request_id, u64 total_size, Optional network_error) =| + request_finished(i32 request_id, u64 total_size, Requests::RequestTimingInfo timing_info, Optional network_error) =| headers_became_available(i32 request_id, HTTP::HeaderMap response_headers, Optional status_code, Optional reason_phrase) =| // Websocket API