Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / 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("{}"), &params)

## `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("{}"), &params)

## SPAM_DEBUG (AK/Debug.h; off).
let resource_loader_spam_debug: bool = false