dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / loader / resource_loader_1.lucb
#==============================================================================================
#
# resource_loader_1 - ResourceLoader: the process's loader, its settings, and its logging and
# blocking helpers
#
# DESCRIPTION:
# Port of Libraries/LibWeb/Loader/ResourceLoader.cpp (lines 33-196) with the inline
# functions of ResourceLoader.h (lines 25-66). The loader, ResourceLoader::the(), lives in
# the C heap for the process with what it keeps (DESIGN.md §3.3 rule 7): the strings its
# setters are given are copied there, and its active requests, cells, are rooted
# (resource_loader_2). Its RequestClient is the in-process seam of
# external/lib_requests/request_client.lucb, which the embedder makes and installs here.
#
# Copyright (c) 2018-2024, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2022, Dex♪ <dexes.ttp@gmail.com>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: The loader ==============================================================================
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:25 Web::ResourceLoader::class_name (C_OBJECT_ABSTRACT).
pub func resource_loader_class_name_impl(this: ResourceLoader*) -> ak.StringView:
return ak.sv("ResourceLoader")
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:35 Web::ResourceLoader::initialize.
pub func resource_loader_initialize(heap: gc.Heap*, request_client: RequestsRequestClient*):
# adopt_ref(*new ResourceLoader(heap, move(request_client))): in the C heap.
let saved_atomic_allocator = ak.atomic_allocator
ak.atomic_allocator = none
defer ak.atomic_allocator = saved_atomic_allocator
with memory.heap:
let loader = new ResourceLoader(vtable = &resource_loader_vtable, m_heap = heap) else trap("out of memory")
resource_loader_construct(loader, heap, request_client)
s_resource_loader = loader
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:40 Web::ResourceLoader::is_initialized.
pub func resource_loader_is_initialized() -> bool:
return s_resource_loader != none
## The loader forgotten as the VM whose heap it was initialized with is destroyed (vm_destroy): in
## Ladybird it lives as long as the process's one VM. Its active requests' roots are released while
## the heap is still there; the next VM's embedder initializes another.
func resource_loader_forget(heap: gc.Heap*):
let loader = s_resource_loader else return
if loader.m_heap != heap:
return
s_resource_loader = none
for entry in ak.hash_map_begin(&loader.m_active_requests):
gc.root_release(&entry.value)
with memory.heap:
ak.hash_map_clear(&loader.m_active_requests)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:40 Web::ResourceLoader::request_client.
pub func resource_loader_request_client(this: ResourceLoader*) -> (RequestsRequestClient*?)*:
return &this.m_request_client
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:45 Web::ResourceLoader::the.
pub func resource_loader_the() -> ResourceLoader*:
if let loader = s_resource_loader:
return loader
ak.dbgln("Web::ResourceLoader was not initialized")
trap("VERIFY_NOT_REACHED")
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:47 Web::ResourceLoader::pending_loads.
pub func resource_loader_pending_loads(this: ResourceLoader*) -> i32:
return this.m_pending_loads
## A copy of `value` in the C heap, for a member of the loader (DESIGN.md §3.3 rule 7).
func resource_loader_kept_string(value: ak.String) -> ak.String:
let saved_atomic_allocator = ak.atomic_allocator
ak.atomic_allocator = none
defer ak.atomic_allocator = saved_atomic_allocator
with memory.heap:
return ak.string_from_utf8(ak.string_bytes_as_string_view(&value)) else trap("MUST: String::from_utf8")
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:49 Web::ResourceLoader::user_agent (of ResourceLoader::the()).
pub func resource_loader_user_agent() -> ak.String:
return resource_loader_the().m_user_agent
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:50 Web::ResourceLoader::set_user_agent.
pub func resource_loader_set_user_agent(this: ResourceLoader*, user_agent: ak.String):
this.m_user_agent = resource_loader_kept_string(user_agent)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:52 Web::ResourceLoader::platform (of ResourceLoader::the()).
pub func resource_loader_platform() -> ak.String:
return resource_loader_the().m_platform
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:53 Web::ResourceLoader::set_platform.
pub func resource_loader_set_platform(this: ResourceLoader*, platform: ak.String):
this.m_platform = resource_loader_kept_string(platform)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:54 Web::ResourceLoader::ResourceLoader. Runs in the C heap,
## with ak's atomic allocator unset (resource_loader_initialize).
func resource_loader_construct(this: ResourceLoader*, heap: gc.Heap*, request_client: RequestsRequestClient*):
resource_loader_init_fields(this)
this.m_heap = heap
this.m_request_client = request_client
this.m_user_agent = ak.string_from_utf8(ak.sv(default_user_agent)) else trap("MUST: String::from_utf8")
this.m_platform = ak.string_from_utf8(ak.sv(default_platform)) else trap("MUST: String::from_utf8")
var preferred_languages: ak.Vector[ak.String]
ak.vector_append_t(&preferred_languages, ak.string_from_str("en-US"))
this.m_preferred_languages = preferred_languages
this.m_navigator_compatibility_mode = default_navigator_compatibility_mode
request_client.on_request_server_died = ak.Function0[unit](call = resource_loader_on_request_server_died, context = this)
## The lambda of on_request_server_died: the loader forgets its client.
func resource_loader_on_request_server_died(context: void*?):
let this = (ResourceLoader*)(context else trap("on_request_server_died: no loader"))
this.m_request_client = none
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:55 Web::ResourceLoader::preferred_languages (of ResourceLoader::the()).
pub func resource_loader_preferred_languages() -> const ak.Vector[ak.String]*:
return &resource_loader_the().m_preferred_languages
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:56 Web::ResourceLoader::set_preferred_languages.
pub func resource_loader_set_preferred_languages(this: ResourceLoader*, preferred_languages: ak.Vector[ak.String]):
var kept: ak.Vector[ak.String]
for language in ak.vector_span_const(&preferred_languages):
let kept_language = resource_loader_kept_string(language)
with memory.heap:
ak.vector_append_t(&kept, kept_language)
this.m_preferred_languages = kept
assert(not ak.vector_is_empty(&this.m_preferred_languages))
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:62 Web::ResourceLoader::navigator_compatibility_mode (of ResourceLoader::the()).
pub func resource_loader_navigator_compatibility_mode() -> NavigatorCompatibilityMode:
return resource_loader_the().m_navigator_compatibility_mode
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:63 Web::ResourceLoader::set_navigator_compatibility_mode.
pub func resource_loader_set_navigator_compatibility_mode(this: ResourceLoader*, mode: NavigatorCompatibilityMode):
this.m_navigator_compatibility_mode = mode
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:65 Web::ResourceLoader::enable_global_privacy_control.
pub func resource_loader_enable_global_privacy_control(this: ResourceLoader*) -> bool:
return this.m_enable_global_privacy_control
## Ported from Libraries/LibWeb/Loader/ResourceLoader.h:66 Web::ResourceLoader::set_enable_global_privacy_control.
pub func resource_loader_set_enable_global_privacy_control(this: ResourceLoader*, enable: bool):
this.m_enable_global_privacy_control = enable
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:67 Web::ResourceLoader::set_client.
pub func resource_loader_set_client(this: ResourceLoader*, request_client: RequestsRequestClient*):
this.m_request_client = request_client
request_client.on_request_server_died = ak.Function0[unit](call = resource_loader_on_request_server_died, context = this)
## `url.scheme().is_one_of("file"sv, "data"sv)`.
func resource_loader_is_file_or_data_url(url: const web_url.Url*) -> bool:
let scheme = web_url.url_scheme(url)
return ak.string_eq_string_view(&scheme, ak.sv("file")) or ak.string_eq_string_view(&scheme, ak.sv("data"))
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:76 Web::ResourceLoader::prefetch_dns (of ResourceLoader::the()).
pub func resource_loader_prefetch_dns(url: web_url.Url):
let this = resource_loader_the()
if resource_loader_is_file_or_data_url(&url):
return
if content_filter_is_filtered(content_filter_the(), url):
let text = web_url.url_to_byte_string(&url)
ak.dbgln(f"ResourceLoader: Refusing to prefetch DNS for '{ak.string_view_text(ak.byte_string_view(&text))}': \u{1b}[31;1mURL was filtered\u{1b}[0m")
return
# FIXME: We could put this request in a queue until the client connection is re-established.
if let request_client = this.m_request_client:
requests_request_client_ensure_connection(request_client, url, RequestServerCacheLevel.resolve_only)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:91 Web::ResourceLoader::preconnect (of ResourceLoader::the()).
pub func resource_loader_preconnect(url: web_url.Url):
let this = resource_loader_the()
if resource_loader_is_file_or_data_url(&url):
return
if content_filter_is_filtered(content_filter_the(), url):
let text = web_url.url_to_byte_string(&url)
ak.dbgln(f"ResourceLoader: Refusing to pre-connect to '{ak.string_view_text(ak.byte_string_view(&text))}': \u{1b}[31;1mURL was filtered\u{1b}[0m")
return
# FIXME: We could put this request in a queue until the client connection is re-established.
if let request_client = this.m_request_client:
requests_request_client_ensure_connection(request_client, url, RequestServerCacheLevel.create_connection)
# mark: Helpers =================================================================================
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:105 Web::sanitized_url_for_logging.
func sanitized_url_for_logging(url: web_url.Url) -> ak.ByteString:
let scheme = web_url.url_scheme(&url)
if ak.string_eq_string_view(&scheme, ak.sv("data")):
return ak.byte_string_from_str("[data URL]")
return web_url.url_to_byte_string(&url)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:112 Web::store_response_cookies.
func store_response_cookies(page: Page*, url: web_url.Url, set_cookie_entry: ak.StringView):
let decoded_cookie: ak.String? = ak.string_from_utf8(set_cookie_entry) catch:
recover none
let decoded = decoded_cookie else return
let cookie = http_parse_cookie(url, ak.string_bytes_as_string_view(&decoded)) else return
page_client_page_did_set_cookie(page_client(page), url, cookie, HttpSource.http)
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:125 Web::response_headers_for_file.
func response_headers_for_file(path: ak.StringView, modified_time: i64?) -> HttpHeaderList*:
# For file:// and resource:// URLs, we have to guess the MIME type, since there's no HTTP header to tell us what
# it is. We insert a fake Content-Type header here, so that clients can use it to learn the MIME type.
let mime_type = core_guess_mime_type_based_on_filename(path)
var headers: ak.Vector[HttpHeader]
ak.vector_append_t(&headers, http_header_create(ak.sv("Access-Control-Allow-Origin"), ak.sv("null")))
ak.vector_append_t(&headers, http_header_create(ak.sv("Content-Type"), mime_type))
let response_headers = http_header_list_create(headers)
if let seconds = modified_time:
let datetime = ak.unix_date_time_from_seconds_since_epoch(seconds)
let formatted = ak.unix_date_time_to_byte_string(&datetime, ak.sv("%a, %d %b %Y %H:%M:%S GMT"), ak.UnixDateTimeLocalTime.no)
http_header_list_set(response_headers, http_header_create(ak.sv("Last-Modified"), ak.byte_string_view(&formatted)))
return response_headers
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:144 Web::log_request_start.
func log_request_start(request: const LoadRequest*):
let url_for_logging = sanitized_url_for_logging(load_request_url(request) else trap("VERIFY: a load request's URL"))
if resource_loader_spam_debug:
ak.dbgln(f"ResourceLoader: Starting load of: \"{ak.string_view_text(ak.byte_string_view(&url_for_logging))}\"")
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:151 Web::log_success.
func log_success(request: const LoadRequest*):
let url_for_logging = sanitized_url_for_logging(load_request_url(request) else trap("VERIFY: a load request's URL"))
let load_time = load_request_load_time(request)
let load_time_ms = ak.duration_to_milliseconds(&load_time)
if resource_loader_spam_debug:
ak.dbgln(f"ResourceLoader: Finished load of: \"{ak.string_view_text(ak.byte_string_view(&url_for_logging))}\", Duration: {load_time_ms}ms")
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:160 Web::log_failure (the error formatted as text).
func log_failure(request: const LoadRequest*, error_: ak.StringView):
let url_for_logging = sanitized_url_for_logging(load_request_url(request) else trap("VERIFY: a load request's URL"))
let load_time = load_request_load_time(request)
let load_time_ms = ak.duration_to_milliseconds(&load_time)
ak.dbgln(f"ResourceLoader: Failed load of: \"{ak.string_view_text(ak.byte_string_view(&url_for_logging))}\", \u{1b}[31;1mError: {ak.string_view_text(error_)}\u{1b}[0m, Duration: {load_time_ms}ms")
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:168 Web::log_filtered_request.
func log_filtered_request(request: const LoadRequest*):
let url_for_logging = sanitized_url_for_logging(load_request_url(request) else trap("VERIFY: a load request's URL"))
ak.dbgln(f"ResourceLoader: Filtered request to: \"{ak.string_view_text(ak.byte_string_view(&url_for_logging))}\"")
## should_block_request's `ports`.
let resource_loader_blocked_ports: i32[65] = [1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42,
43, 53, 77, 79, 87, 95, 101, 102, 103, 104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 139,
143, 179, 389, 465, 512, 513, 514, 515, 526, 530, 531, 532, 540, 556, 563, 587, 601, 636,
993, 995, 2049, 3659, 4045, 6000, 6379, 6665, 6666, 6667, 6668, 6669]
## should_block_request's is_port_blocked.
func resource_loader_is_port_blocked(port: i32) -> bool:
for blocked in resource_loader_blocked_ports:
if blocked == port:
return true
return false
## Ported from Libraries/LibWeb/Loader/ResourceLoader.cpp:174 Web::should_block_request.
func should_block_request(request: const LoadRequest*) -> bool:
let url = load_request_url(request) else trap("VERIFY: a load request's URL")
let port = web_url.url_port_or_default(&url)
if resource_loader_is_port_blocked((i32)port):
var message = ak.string_builder_new()
ak.string_builder_append(&message, "Port #")
let port_text = ak.string_number_u64((u64)port)
ak.string_builder_append_string_view(&message, ak.string_bytes_as_string_view(&port_text))
ak.string_builder_append(&message, " is blocked")
log_failure(request, ak.string_builder_string_view(&message))
return true
if content_filter_is_filtered(content_filter_the(), url):
log_filtered_request(request)
return true
return false
## `ByteString::formatted("{}", error)` of a caught failure: the AK::Error it stands for, formatted.
func resource_loader_format_failure(failure: Error) -> ak.ByteString:
var error_ = ak.ak_error_from_failure(failure)
let parameters: ak.TypeErasedParameter[1] = [ak.arg_custom(&error_, ak.format_value_error)]
var params = ak.type_erased_format_params_create(parameters)
return ak.byte_string_vformatted(ak.sv("{}"), ¶ms)
## `ByteString::formatted("{}", error)` of an AK::Error.
func resource_loader_format_error(error_: ak.AkError) -> ak.ByteString:
var value = error_
let parameters: ak.TypeErasedParameter[1] = [ak.arg_custom(&value, ak.format_value_error)]
var params = ak.type_erased_format_params_create(parameters)
return ak.byte_string_vformatted(ak.sv("{}"), ¶ms)
## SPAM_DEBUG (AK/Debug.h; off).
let resource_loader_spam_debug: bool = false