Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / fetch / fetching / fetching_4.lucb

#==============================================================================================
#
#   fetching_4 - Fetch::Fetching: scheme fetch
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/Fetch/Fetching/Fetching.cpp (lines 932-1193): scheme fetch,
#       for about:blank, blob: (FileAPI's blob URL store is phase 3: its calls trap), data:,
#       file: and resource: (Ladybird's ad-hoc network fetch through the ResourceLoader, for
#       subresources of file: and resource: pages) and HTTP(S) (HTTP fetch, fetching_5).
#
#       Copyright (c) 2022-2023, Linus Groh <linusg@serenityos.org>
#       Copyright (c) 2023, Luke Wilde <lukew@serenityos.org>
#       Copyright (c) 2023, Sam Atkins <atkinssj@serenityos.org>
#       Copyright (c) 2024, Jamie Mansfield <jmansfield@cadixdev.org>
#       Copyright (c) 2025, Shannon Booth <shannon@serenityos.org>
#       Copyright (c) 2025, Kenneth Myhra <kennethmyhra@serenityos.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

## A network error as a resolved pending response: `PendingResponse::create(vm, request,
## Infrastructure::Response::network_error(vm, message))`.
func fetch_fetching_pending_network_error(vm: Vm*, request: FetchRequest*, message: str) -> FetchPendingResponse*:
    return fetch_pending_response_create_fetch_response(vm, request, fetch_response_network_error(vm, ak.string_from_str(message)))

## `request->current_url().paths().size() == 1 && request->current_url().paths()[0] == "blank"sv`.
func fetch_fetching_url_path_is_blank(url: const web_url.Url*) -> bool:
    let paths = web_url.url_paths(url)
    if ak.vector_size(&paths) != 1:
        return false
    let first = *ak.vector_at_const(&paths, 0)
    return ak.string_eq_string_view(&first, ak.sv("blank"))

## `origin->is_opaque() || origin->scheme() == "file"sv || origin->scheme() == "resource"sv` of the file: and resource:
## steps.
func fetch_fetching_origin_may_load_local_files(origin: const web_url.Origin*) -> bool:
    if web_url.origin_is_opaque(origin):
        return true
    let scheme = web_url.origin_scheme(origin) else return false
    return ak.string_eq_string_view(&scheme, ak.sv("file")) or ak.string_eq_string_view(&scheme, ak.sv("resource"))

## `request->origin().get_pointer<URL::Origin>()`: the request's origin when it is an origin.
func fetch_fetching_request_origin(request: FetchRequest*) -> web_url.Origin?:
    match fetch_request_origin(request):
        .origin(value): return value
        _: return none

## Ported from Libraries/LibWeb/Fetch/Fetching/Fetching.cpp:933 Web::Fetch::Fetching::scheme_fetch.
# https://fetch.spec.whatwg.org/#concept-scheme-fetch
pub func fetch_fetching_scheme_fetch(realm: Realm*, fetch_params: FetchParams*) -> FetchPendingResponse*:
    if fetch_web_fetch_debug:
        ak.dbgln(f"Fetch: Running 'scheme fetch' with: fetch_params @ {(void*)fetch_params}")

    let vm = realm_vm(realm)

    # 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
    if fetch_params_is_canceled(fetch_params):
        return fetch_pending_response_create_fetch_response(vm, fetch_params_request(fetch_params), fetch_response_appropriate_network_error(vm, fetch_params))

    # 2. Let request be fetchParams’s request.
    let request = fetch_params_request(fetch_params)

    # 3. Switch on request’s current URL’s scheme and run the associated steps:
    let current_url = fetch_request_current_url(request)
    let scheme = web_url.url_scheme(&current_url)
    # -> "about"
    if ak.string_eq_string_view(&scheme, ak.sv("about")):
        # If request’s current URL’s path is the string "blank", then return a new response whose status message is
        # `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) », and body is the empty byte sequence as
        # a body.
        # NOTE: URLs such as "about:config" are handled during navigation and result in a network error in the context
        #       of fetching.
        if fetch_fetching_url_path_is_blank(&current_url):
            let response = fetch_infrastructure_response_create(vm)
            fetch_response_set_status_message(response, ak.byte_string_from_str("OK"))
            http_header_list_append(fetch_response_header_list(response), http_header_create(ak.sv("Content-Type"), ak.sv("text/html;charset=utf-8")))
            fetch_response_set_body(response, fetch_byte_sequence_as_body(realm, "".bytes))

            return fetch_pending_response_create_fetch_response(vm, request, response)

        # FIXME: This is actually wrong, see note above.
        return fetch_fetching_nonstandard_resource_loader_file_or_http_network_fetch(realm, fetch_params)
    # -> "blob"
    elif ak.string_eq_string_view(&scheme, ak.sv("blob")):
        return fetch_fetching_scheme_fetch_blob(realm, request)
    # -> "data"
    elif ak.string_eq_string_view(&scheme, ak.sv("data")):
        # 1. Let dataURLStruct be the result of running the data: URL processor on request’s current URL.
        # 2. If dataURLStruct is failure, then return a network error.
        let data_url_struct = fetch_process_data_url(current_url) catch:
            return fetch_fetching_pending_network_error(vm, request, "Failed to process 'data:' URL")

        # 3. Let mimeType be dataURLStruct’s MIME type, serialized.
        let mime_type = mime_type_serialized(&data_url_struct.mime_type)

        # 4. Return a new response whose status message is `OK`, header list is « (`Content-Type`, mimeType) », and
        #    body is dataURLStruct’s body as a body.
        let response = fetch_infrastructure_response_create(vm)
        fetch_response_set_status_message(response, ak.byte_string_from_str("OK"))

        let header = http_header_isomorphic_encode(ak.sv("Content-Type"), ak.string_bytes_as_string_view(&mime_type))
        http_header_list_append(fetch_response_header_list(response), header)

        fetch_response_set_body(response, fetch_byte_sequence_as_body(realm, ak.byte_buffer_bytes_const(&data_url_struct.body)))
        return fetch_pending_response_create_fetch_response(vm, request, response)
    # -> "file"
    # AD-HOC: "resource"
    elif ak.string_eq_string_view(&scheme, ak.sv("file")) or ak.string_eq_string_view(&scheme, ak.sv("resource")):
        # For now, unfortunate as it is, file: URLs are left as an exercise for the reader.
        # When in doubt, return a network error.

        let error_ = fetch_fetching_pending_network_error(vm, request, "Request with 'file:' or 'resource:' URL blocked")

        let origin = fetch_fetching_request_origin(request) else return error_

        if not fetch_fetching_origin_may_load_local_files(&origin):
            return error_

        # Allow file:// pages to load subresources (scripts, styles, fonts, etc.) from other file:// URLs,
        # but block the fetch() API and other requests without a destination from reading arbitrary files.
        # Requests made via fetch() have an empty destination, so we use that to distinguish between
        # subresource loads initiated by the browser (which have a destination) and programmatic fetches
        # (which do not). This prevents data exfiltration via fetch() from file:// pages.
        if fetch_request_destination(request) == none:
            return error_

        return fetch_fetching_nonstandard_resource_loader_file_or_http_network_fetch(realm, fetch_params)
    # -> HTTP(S) scheme
    elif fetch_is_http_or_https_scheme(ak.string_bytes_as_string_view(&scheme)):
        # Return the result of running HTTP fetch given fetchParams.
        return fetch_fetching_http_fetch(realm, fetch_params)

    # 4. Return a network error.
    let message = "Request has invalid 'about:' URL, only 'about:blank' can be fetched" if ak.string_eq_string_view(&scheme, ak.sv("about")) else "Request URL has invalid scheme, must be one of 'about', 'blob', 'data', 'file', 'http', or 'https'"
    return fetch_fetching_pending_network_error(vm, request, message)

## The "blob" steps of scheme fetch (Fetching.cpp:967-1133). FileAPI's blobs and blob URL store are phase 3: the
## steps trap in their closure stubs.
func fetch_fetching_scheme_fetch_blob(realm: Realm*, request: FetchRequest*) -> FetchPendingResponse*:
    let vm = realm_vm(realm)
    let current_url = fetch_request_current_url(request)

    # 1. Let blobURLEntry be request’s current URL’s blob URL entry.
    let blob_url_entry = web_url.url_blob_url_entry(&current_url)

    # 2. If request’s method is not `GET` or blobURLEntry is null, then return a network error. [FILEAPI]
    let method = fetch_request_method(request)
    if not ak.byte_string_eq_string_view(&method, ak.sv("GET")) or blob_url_entry == none:
        return fetch_fetching_pending_network_error(vm, request, "Request has an invalid 'blob:' URL")

    # 3. Let requestEnvironment be the result of determining the environment given request.
    let request_environment = fetch_fetching_determine_the_environment(request)

    # 4. Let isTopLevelSelfFetch be false.
    var is_top_level_self_fetch = false

    # 5. If request’s client is non-null:
    if let client = fetch_request_client(request):
        # 1. Let global be request’s client’s global object.
        let global_window = as_if_html_window((gc.Cell*)html_environment_settings_object_global_object(client))

        # 2. If all of the following conditions are true:
        if let window = global_window:
            # global is a Window object;
            if let navigable = html_window_navigable(window):
                # global’s navigable is not null;
                # global’s navigable’s parent is null; and
                # requestEnvironment’s creation URL equals request’s current URL,
                let environment = request_environment else trap("VERIFY: requestEnvironment")
                if html_navigable_parent(navigable) == none and web_url.url_eq(&environment.creation_url, current_url):
                    # then set isTopLevelSelfFetch to true.
                    is_top_level_self_fetch = true

    # 6. Let stringOrEnvironment be the result of these steps:
    var string_or_environment: FileApiEnvironmentOrTopLevelSelfFetch = .top_level_navigation
    # 1. If request’s destination is "document", then return "top-level-navigation".
    if fetch_request_destination(request) == FetchRequestDestination.document:
        string_or_environment = .top_level_navigation
    # 2. If isTopLevelSelfFetch is true, then return "top-level-self-fetch".
    elif is_top_level_self_fetch:
        string_or_environment = .top_level_self_fetch
    # 3. Return requestEnvironment.
    else:
        string_or_environment = .environment(request_environment else trap("VERIFY: requestEnvironment"))

    # 7. Let blob be the result of obtaining a blob object given blobURLEntry and navigationOrEnvironment.
    let maybe_blob_object = file_api_obtain_a_blob_object(blob_url_entry else trap("unreachable"), string_or_environment)

    # 8. If blob is not a Blob object, then return a network error.
    let blob_url_entry_object = maybe_blob_object else return fetch_fetching_pending_network_error(vm, request, "Failed to obtain a Blob object from 'blob:' URL")

    let blob_object: web_url.BlobUrlEntryBlob? = match blob_url_entry_object:
        .blob_url_entry_blob(value) => value
        _ => none
    let blob_data = blob_object else return fetch_fetching_pending_network_error(vm, request, "Failed to obtain a Blob object from 'blob:' URL")
    let blob = file_api_blob_create(realm, blob_data.data, blob_data.type_)

    # 9. Let response be a new response.
    let response = fetch_infrastructure_response_create(vm)

    # 10. Let fullLength be blob’s size.
    let full_length = file_api_blob_size(blob)

    # 11. Let serializedFullLength be fullLength, serialized and isomorphic encoded.
    let serialized_full_length = ak.string_number_u64(full_length)

    # 12. Let type be blob’s type.
    let type_ = file_api_blob_type(blob)

    # 13. If request’s header list does not contain `Range`:
    if not http_header_list_contains(fetch_request_header_list(request), ak.sv("Range")):
        # 1. Let bodyWithType be the result of safely extracting blob.
        let body_with_type = fetch_safely_extract_body_bytes(realm, file_api_blob_raw_bytes(blob))

        # 2. Set response’s status message to `OK`.
        fetch_response_set_status_message(response, ak.byte_string_from_str("OK"))

        # 3. Set response’s body to bodyWithType’s body.
        fetch_response_set_body(response, body_with_type.body)

        # 4. Set response’s header list to « (`Content-Length`, serializedFullLength), (`Content-Type`, type) ».
        let content_length_header = http_header_isomorphic_encode(ak.sv("Content-Length"), ak.string_bytes_as_string_view(&serialized_full_length))
        http_header_list_append(fetch_response_header_list(response), content_length_header)

        let content_type_header = http_header_isomorphic_encode(ak.sv("Content-Type"), ak.string_bytes_as_string_view(&type_))
        http_header_list_append(fetch_response_header_list(response), content_type_header)
    # 14. Otherwise:
    else:
        # 1. Set response’s range-requested flag.
        fetch_response_set_range_requested(response, true)

        # 2. Let rangeHeader be the result of getting `Range` from request’s header list.
        let range_header = http_header_list_get(fetch_request_header_list(request), ak.sv("Range")) else ak.byte_string_empty()

        # 3. Let rangeValue be the result of parsing a single range header value given rangeHeader and true.
        let maybe_range_value = http_parse_single_range_header_value(ak.byte_string_view(&range_header), true)

        # 4. If rangeValue is failure, then return a network error.
        # 5. Let (rangeStart, rangeEnd) be rangeValue.
        let range_value = maybe_range_value else return fetch_fetching_pending_network_error(vm, request, "Failed to parse single range header value")
        var range_start = range_value.start
        var range_end = range_value.end

        # 6. If rangeStart is null:
        if range_start == none:
            let end = range_end else trap("VERIFY: range_end.has_value()")

            # 1. Set rangeStart to fullLength − rangeEnd.
            let start = full_length - end
            range_start = start

            # 2. Set rangeEnd to rangeStart + rangeEnd − 1.
            range_end = start + end - 1
        # 7. Otherwise:
        else:
            # 1. If rangeStart is greater than or equal to fullLength, then return a network error.
            if (range_start else trap("unreachable")) >= full_length:
                return fetch_fetching_pending_network_error(vm, request, "rangeStart is greater than or equal to fullLength")

            # 2. If rangeEnd is null or rangeEnd is greater than or equal to fullLength, then set rangeEnd to fullLength − 1.
            if range_end == none or (range_end else trap("unreachable")) >= full_length:
                range_end = full_length - 1

        let start = range_start else trap("unreachable")
        let end = range_end else trap("unreachable")

        # 8. Let slicedBlob be the result of invoking slice blob given blob, rangeStart, rangeEnd + 1, and type.
        let sliced_blob = file_api_blob_slice(blob, (i64)start, (i64)(end + 1), type_) else trap("MUST: Blob::slice")

        # 9. Let slicedBodyWithType be the result of safely extracting slicedBlob.
        let sliced_body_with_type = fetch_safely_extract_body_bytes(realm, file_api_blob_raw_bytes(sliced_blob))

        # 10. Set response’s body to slicedBodyWithType’s body.
        fetch_response_set_body(response, sliced_body_with_type.body)

        # 11. Let serializedSlicedLength be slicedBlob’s size, serialized and isomorphic encoded.
        let serialized_sliced_length = ak.string_number_u64(file_api_blob_size(sliced_blob))

        # 12. Let contentRange be the result of invoking build a content range given rangeStart, rangeEnd, and fullLength.
        let content_range = http_build_content_range(start, end, full_length)

        # 13. Set response’s status to 206.
        fetch_response_set_status(response, 206)

        # 14. Set response’s status message to `Partial Content`.
        fetch_response_set_status_message(response, ak.byte_string_from_str("Partial Content"))

        # 15. Set response’s header list to «

        # (`Content-Length`, serializedSlicedLength),
        let content_length_header = http_header_isomorphic_encode(ak.sv("Content-Length"), ak.string_bytes_as_string_view(&serialized_sliced_length))
        http_header_list_append(fetch_response_header_list(response), content_length_header)

        # (`Content-Type`, type),
        let content_type_header = http_header_isomorphic_encode(ak.sv("Content-Type"), ak.string_bytes_as_string_view(&type_))
        http_header_list_append(fetch_response_header_list(response), content_type_header)

        # (`Content-Range`, contentRange) ».
        let content_range_header = http_header_isomorphic_encode(ak.sv("Content-Range"), ak.byte_string_view(&content_range))
        http_header_list_append(fetch_response_header_list(response), content_range_header)

    # 15. Return response.
    return fetch_pending_response_create_fetch_response(vm, request, response)