mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(network): preserve window referrers in XHR and EventSource
This commit is contained in:
@@ -2,11 +2,13 @@ use super::*;
|
||||
use crate::native_bridge::{JsContextHost, throw_dom_exception};
|
||||
use crate::network_host::{
|
||||
BLOCKED_BY_CLIENT_ERROR_TEXT, active_subresource_network_partition_key,
|
||||
effective_subresource_policy_context, local_url_response, merge_subresource_request_headers,
|
||||
effective_subresource_policy_context, effective_subresource_referrer_policy,
|
||||
local_url_response, merge_subresource_request_headers,
|
||||
observe_subresource_request_cookie_report, resolve_context_url, spawn_async_subresource_fetch,
|
||||
};
|
||||
use crate::service_worker_runtime::{
|
||||
ServiceWorkerFetchDispatch, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination,
|
||||
ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination,
|
||||
service_worker_fetch_request_metadata,
|
||||
};
|
||||
use crate::types::{
|
||||
PendingSubresourceFetchInfo, SubresourceNetworkRecord, SubresourceResourceType,
|
||||
@@ -44,6 +46,8 @@ struct PreparedEventSourceRequest {
|
||||
owner: crate::native_bridge::OwnerDispatchScope,
|
||||
resource_loader: crate::network::context::DocumentResourceLoader,
|
||||
document_url: url::Url,
|
||||
referrer_source: Option<url::Url>,
|
||||
document_referrer_policy: Option<String>,
|
||||
request_origin: moli_url::WebOrigin,
|
||||
resolved_url: url::Url,
|
||||
request_headers: moli_fetch::RequestHeaders,
|
||||
@@ -399,6 +403,8 @@ fn prepare_event_source_request<'s>(
|
||||
owner,
|
||||
resource_loader,
|
||||
document_url,
|
||||
referrer_source: host.document_client_referrer_source(owner),
|
||||
document_referrer_policy: effective_subresource_referrer_policy(host, owner),
|
||||
request_origin,
|
||||
resolved_url,
|
||||
request_headers,
|
||||
@@ -425,6 +431,7 @@ fn dispatch_service_worker_event_source<'s>(
|
||||
&prepared.document_url,
|
||||
&prepared.resolved_url,
|
||||
)?;
|
||||
let native_request = build_event_source_request(prepared).ok()?;
|
||||
|
||||
let cancel_handle = FetchCancelHandle::new();
|
||||
let registered = register_event_source_request(
|
||||
@@ -446,11 +453,7 @@ fn dispatch_service_worker_event_source<'s>(
|
||||
prepared.credentials_mode,
|
||||
RequestRedirectMode::Follow,
|
||||
None,
|
||||
ServiceWorkerFetchRequestMetadata {
|
||||
mixed_content_policy: Default::default(),
|
||||
cache: "no-store".to_owned(),
|
||||
..ServiceWorkerFetchRequestMetadata::default()
|
||||
},
|
||||
service_worker_fetch_request_metadata(&native_request),
|
||||
);
|
||||
let dispatch = ServiceWorkerFetchDispatch {
|
||||
request_body_owner: None,
|
||||
@@ -492,26 +495,35 @@ fn dispatch_service_worker_event_source<'s>(
|
||||
}
|
||||
|
||||
fn build_event_source_request(prepared: &PreparedEventSourceRequest) -> Result<Request, String> {
|
||||
Request::new(
|
||||
let request = Request::new(
|
||||
"GET",
|
||||
prepared.resolved_url.as_str(),
|
||||
None,
|
||||
prepared.request_headers.clone(),
|
||||
)
|
||||
.map_err(|error| error.to_string())
|
||||
.map(|request| {
|
||||
request
|
||||
.with_initiator_url(&prepared.document_url)
|
||||
.with_request_origin(prepared.request_origin.clone())
|
||||
.with_request_mode(RequestMode::Cors)
|
||||
.with_credentials_mode(prepared.credentials_mode)
|
||||
.with_network_partition_key(prepared.network_partition_key.clone())
|
||||
.with_redirect_mode(RequestRedirectMode::Follow)
|
||||
.with_cache_mode(RequestCacheMode::NoStore)
|
||||
.with_browser_request_metadata(BrowserRequestMetadata::EventSource)
|
||||
.with_subframe_context(prepared.frame_id.is_some())
|
||||
.without_request_timeout()
|
||||
})
|
||||
.map_err(|error| error.to_string())?
|
||||
.with_fetch_referrer(
|
||||
prepared
|
||||
.referrer_source
|
||||
.as_ref()
|
||||
.map_or("", url::Url::as_str),
|
||||
)
|
||||
.map_err(|error| error.to_string())?;
|
||||
Ok(request
|
||||
.with_initiator_url(&prepared.document_url)
|
||||
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
|
||||
document_referrer_policy: prepared.document_referrer_policy.clone(),
|
||||
..Default::default()
|
||||
})
|
||||
.with_request_origin(prepared.request_origin.clone())
|
||||
.with_request_mode(RequestMode::Cors)
|
||||
.with_credentials_mode(prepared.credentials_mode)
|
||||
.with_network_partition_key(prepared.network_partition_key.clone())
|
||||
.with_redirect_mode(RequestRedirectMode::Follow)
|
||||
.with_cache_mode(RequestCacheMode::NoStore)
|
||||
.with_browser_request_metadata(BrowserRequestMetadata::EventSource)
|
||||
.with_subframe_context(prepared.frame_id.is_some())
|
||||
.without_request_timeout())
|
||||
}
|
||||
|
||||
struct RegisteredEventSourceRequest {
|
||||
|
||||
@@ -26,7 +26,7 @@ use super::events::{
|
||||
use super::*;
|
||||
use crate::runtime::RendererPageContextCancelReason;
|
||||
use crossbeam_channel::{after, bounded, never};
|
||||
use moli_fetch::{BrowserRequestMetadata, FetchCancelHandle, RequestMode};
|
||||
use moli_fetch::{FetchCancelHandle, RequestMode};
|
||||
use std::{thread, time::Duration};
|
||||
|
||||
pub(super) fn xhr_send_callback<'s>(
|
||||
@@ -298,24 +298,7 @@ fn send_synchronous_network_xhr(
|
||||
timing.capture_window_initiator(scope, host);
|
||||
let csp = crate::network_host::WindowCspRequestContext::capture(scope, host, prepared.owner)
|
||||
.expect("synchronous XHR prepared a live Document request authority");
|
||||
let mut request = Request::new_bytes(
|
||||
&prepared.method,
|
||||
prepared.resolved_url.as_str(),
|
||||
prepared.send_body.clone(),
|
||||
prepared.request_headers.clone(),
|
||||
)
|
||||
.expect("xhr request url was already resolved")
|
||||
.with_page_network_policy()
|
||||
.with_initiator_url(&prepared.document_url)
|
||||
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
|
||||
document_referrer_policy: prepared.document_referrer_policy.clone(),
|
||||
..Default::default()
|
||||
})
|
||||
.with_request_origin(prepared.request_origin.clone())
|
||||
.with_credentials_mode(prepared.credentials_mode)
|
||||
.with_network_partition_key(prepared.network_partition_key.clone())
|
||||
.with_browser_request_metadata(BrowserRequestMetadata::Xhr)
|
||||
.with_use_cors_preflight(prepared.use_cors_preflight);
|
||||
let mut request = prepared.request().with_page_network_policy();
|
||||
if let Some(check) = csp.redirect_check(
|
||||
scope,
|
||||
&prepared.document_url,
|
||||
|
||||
@@ -2,11 +2,11 @@ use super::super::delivery::{queue_xhr_failure_delivery, queue_xhr_response_deli
|
||||
use super::super::*;
|
||||
use super::request::PreparedXhrSendRequest;
|
||||
use crate::service_worker_runtime::{
|
||||
ServiceWorkerFetchDispatch, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination,
|
||||
ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination,
|
||||
service_worker_fetch_request_metadata,
|
||||
};
|
||||
use moli_fetch::{
|
||||
BrowserRequestMetadata, FetchCancelHandle, RequestRedirectMode,
|
||||
should_request_be_blocked_due_to_bad_port,
|
||||
FetchCancelHandle, RequestRedirectMode, should_request_be_blocked_due_to_bad_port,
|
||||
};
|
||||
|
||||
pub(super) fn record_intercepted_xhr(
|
||||
@@ -122,11 +122,7 @@ pub(super) fn dispatch_service_worker_xhr(
|
||||
prepared.credentials_mode,
|
||||
RequestRedirectMode::Follow,
|
||||
None,
|
||||
ServiceWorkerFetchRequestMetadata {
|
||||
mixed_content_policy: Default::default(),
|
||||
use_cors_preflight: prepared.use_cors_preflight,
|
||||
..ServiceWorkerFetchRequestMetadata::default()
|
||||
},
|
||||
service_worker_fetch_request_metadata(&prepared.request()),
|
||||
);
|
||||
let dispatch = ServiceWorkerFetchDispatch {
|
||||
request_body_owner: None,
|
||||
@@ -313,24 +309,9 @@ pub(super) fn spawn_network_xhr_fetch(
|
||||
prepared: PreparedXhrSendRequest,
|
||||
request_client: ResourceRequestClient,
|
||||
) -> u64 {
|
||||
let mut request = Request::new_bytes(
|
||||
&prepared.method,
|
||||
prepared.resolved_url.as_str(),
|
||||
prepared.send_body.clone(),
|
||||
prepared.request_headers.clone(),
|
||||
)
|
||||
.expect("xhr request url was already resolved")
|
||||
.with_initiator_url(&prepared.document_url)
|
||||
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
|
||||
document_referrer_policy: prepared.document_referrer_policy.clone(),
|
||||
..Default::default()
|
||||
})
|
||||
.with_request_origin(prepared.request_origin.clone())
|
||||
.with_credentials_mode(prepared.credentials_mode)
|
||||
.with_network_partition_key(prepared.network_partition_key.clone())
|
||||
.with_browser_request_metadata(BrowserRequestMetadata::Xhr)
|
||||
.with_use_cors_preflight(prepared.use_cors_preflight)
|
||||
.with_subframe_context(prepared.frame_id.is_some());
|
||||
let mut request = prepared
|
||||
.request()
|
||||
.with_subframe_context(prepared.frame_id.is_some());
|
||||
|
||||
let request_cookie_report = observe_subresource_request_cookie_report(
|
||||
prepared.resource_loader.request_client(),
|
||||
|
||||
@@ -19,6 +19,7 @@ pub(super) struct PreparedXhrSendRequest {
|
||||
pub(super) resource_loader: crate::network::context::DocumentResourceLoader,
|
||||
pub(super) document_url: url::Url,
|
||||
pub(super) document_referrer_policy: Option<String>,
|
||||
referrer_source: Option<url::Url>,
|
||||
pub(super) request_origin: moli_url::WebOrigin,
|
||||
pub(super) network_partition_key: Option<String>,
|
||||
pub(super) policy_context: crate::types::SubresourcePolicyContext,
|
||||
@@ -32,6 +33,32 @@ pub(super) struct PreparedXhrSendRequest {
|
||||
pub(super) use_cors_preflight: bool,
|
||||
}
|
||||
|
||||
impl PreparedXhrSendRequest {
|
||||
pub(super) fn request(&self) -> moli_fetch::Request {
|
||||
// Network dispatch and Service Worker metadata share the captured
|
||||
// client's referrer without rebinding its cookie or request origin.
|
||||
moli_fetch::Request::new_bytes(
|
||||
&self.method,
|
||||
self.resolved_url.as_str(),
|
||||
self.send_body.clone(),
|
||||
self.request_headers.clone(),
|
||||
)
|
||||
.expect("xhr request url was already resolved")
|
||||
.with_fetch_referrer(self.referrer_source.as_ref().map_or("", url::Url::as_str))
|
||||
.expect("XHR referrer source is a captured Document URL")
|
||||
.with_initiator_url(&self.document_url)
|
||||
.with_subresource_request_metadata(moli_fetch::SubresourceRequestMetadata {
|
||||
document_referrer_policy: self.document_referrer_policy.clone(),
|
||||
..Default::default()
|
||||
})
|
||||
.with_request_origin(self.request_origin.clone())
|
||||
.with_credentials_mode(self.credentials_mode)
|
||||
.with_network_partition_key(self.network_partition_key.clone())
|
||||
.with_browser_request_metadata(moli_fetch::BrowserRequestMetadata::Xhr)
|
||||
.with_use_cors_preflight(self.use_cors_preflight)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) enum XhrSendPrepareError {
|
||||
ExecutionContext,
|
||||
Url(ResolveContextUrlError),
|
||||
@@ -105,6 +132,7 @@ pub(super) fn prepare_xhr_send_request<'s>(
|
||||
request_origin,
|
||||
network_partition_key,
|
||||
document_referrer_policy,
|
||||
referrer_source: host.document_client_referrer_source(owner),
|
||||
policy_context,
|
||||
resolved_url,
|
||||
blob_url_entry: blob_url_entry(scope, xhr)
|
||||
|
||||
@@ -2534,6 +2534,7 @@ mod audio_worklet_and_message_ports;
|
||||
mod blob_storage_key;
|
||||
mod message_port_transfer_semantics;
|
||||
mod service_and_shared_worker_lifecycle;
|
||||
mod window_request_referrer;
|
||||
mod window_service_worker_response_policy;
|
||||
mod worker_messages_and_service_workers;
|
||||
mod worker_security_and_audio_worklets;
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
use super::*;
|
||||
|
||||
const CLIENT: &str =
|
||||
include_str!("../../../../../tests/fixtures/window-request-referrer-client.js");
|
||||
const SERVICE_WORKER: &str =
|
||||
include_str!("../../../../../tests/fixtures/window-request-referrer-sw.js");
|
||||
|
||||
async fn check_window_request_referrer(policy: &'static str) {
|
||||
for controlled in [false, true] {
|
||||
run_page_vm_async_test(async move {
|
||||
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
listener.set_nonblocking(true).unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let origin = format!("http://{address}");
|
||||
let cross = format!("http://localhost:{}", address.port());
|
||||
let server_origin = origin.clone();
|
||||
let server_cross = cross.clone();
|
||||
let (requests, mut received) = tokio::sync::mpsc::unbounded_channel();
|
||||
let (stop, mut stopped) = tokio::sync::oneshot::channel::<()>();
|
||||
let server = std::thread::spawn(move || {
|
||||
tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async move {
|
||||
let listener = TcpListener::from_std(listener).unwrap();
|
||||
loop {
|
||||
let accepted = tokio::select! {
|
||||
result = listener.accept() => result.ok(),
|
||||
_ = &mut stopped => None,
|
||||
_ = tokio::time::sleep(Duration::from_secs(30)) => None,
|
||||
};
|
||||
let Some((mut stream, _)) = accepted else { break };
|
||||
let head = read_http_request_head(&mut stream).await.unwrap();
|
||||
let path = head.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
let url = Url::parse(&format!("{server_origin}{path}")).unwrap();
|
||||
let referrer = head.lines().find_map(|line| {
|
||||
let (name, value) = line.split_once(':')?;
|
||||
name.eq_ignore_ascii_case("referer").then(|| value.trim().to_owned())
|
||||
});
|
||||
requests.send((path.to_owned(), referrer.clone())).unwrap();
|
||||
let api = url.query_pairs().find(|(key, _)| key == "api").map(|(_, value)| value.into_owned());
|
||||
let mut status = "200 OK";
|
||||
let mut extra = String::new();
|
||||
let (body, content_type) = if head.starts_with("OPTIONS ") {
|
||||
(String::new(), "text/plain")
|
||||
} else if url.path() == "/app/sw.js" {
|
||||
(format!("const CROSS = {};\n{SERVICE_WORKER}", serde_json::to_string(&server_cross).unwrap()), "text/javascript")
|
||||
} else if url.path() == "/app/network-redirect" {
|
||||
status = "307 Temporary Redirect";
|
||||
extra = format!("Location: {server_cross}/network?api={}\r\nReferrer-Policy: no-referrer\r\n", api.as_deref().unwrap());
|
||||
(String::new(), "text/plain")
|
||||
} else {
|
||||
let value = serde_json::json!({"source":"network","referrer":referrer}).to_string();
|
||||
if api.as_deref() == Some("eventsource") {
|
||||
(format!("data: {value}\n\n"), "text/event-stream")
|
||||
} else { (value, "application/json") }
|
||||
};
|
||||
let response = format!("HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\nAccess-Control-Allow-Origin: {server_origin}\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Allow-Methods: GET, OPTIONS\r\nAccess-Control-Allow-Headers: cache-control, last-event-id\r\n{extra}\r\n{body}", body.len());
|
||||
stream.write_all(response.as_bytes()).await.unwrap();
|
||||
}
|
||||
});
|
||||
});
|
||||
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap();
|
||||
let mut hooks = PageVmRuntimeHooks::standalone_without_owner_reservation_for_test();
|
||||
hooks.resource_task_runner = Some(loader.browser_resource_runtime().resource_task_runner());
|
||||
let document_url = Url::parse(&format!("{origin}/app/page.html?policy={policy}&marker=private#fragment")).unwrap();
|
||||
let mut page = test_page_vm_with_loader_document_url_and_hooks(&loader, Vec::new(), document_url.clone(), hooks);
|
||||
page.retain_standalone_request_client_owner_for_test(loader);
|
||||
let headers = if policy == "default" { Vec::new() } else {
|
||||
vec![("Referrer-Policy".to_owned(), if policy == "meta-no-referrer" { b"unsafe-url".to_vec() } else { policy.as_bytes().to_vec() })]
|
||||
};
|
||||
page.vm_mut().set_main_navigation_policy_container(
|
||||
crate::document_runtime::DocumentPolicyContainer::from_navigation_response_headers(&headers, &document_url),
|
||||
);
|
||||
let mut full_referrer = document_url.clone();
|
||||
full_referrer.set_fragment(None);
|
||||
let local = page.local_executor.clone();
|
||||
local.run(async move {
|
||||
let meta = if policy == "meta-no-referrer" { "document.head.appendChild(Object.assign(document.createElement('meta'), {name: 'referrer', content: 'no-referrer'}));" } else { "" };
|
||||
let source = format!("const ORIGIN = {}, CROSS = {}, CONTROLLED = {controlled};\ndocument.head.appendChild(Object.assign(document.createElement('base'), {{href: ORIGIN + '/unrelated-base/'}}));\n{meta}\n{CLIENT}", serde_json::to_string(&origin).unwrap(), serde_json::to_string(&cross).unwrap());
|
||||
page.vm_mut().eval(&source)?;
|
||||
drive_service_worker_page_vm_until_done(&mut page, "String(referrerResult !== null || referrerError !== null)", "Window XHR and EventSource must preserve the requesting Document referrer across SW dispatch and fallback").await?;
|
||||
assert_eq!(page.vm_mut().eval("String(referrerError)")?, "null");
|
||||
let result: serde_json::Value = serde_json::from_str(&page.vm_mut().eval("JSON.stringify(referrerResult)")?)?;
|
||||
let rows = result["rows"].as_array().unwrap();
|
||||
assert_eq!(rows.len(), 27);
|
||||
let effective_policy = match policy { "default" => "strict-origin-when-cross-origin", "meta-no-referrer" => "no-referrer", other => other };
|
||||
for row in rows {
|
||||
assert!(row.get("error").is_none(), "{policy}/{controlled}: {row}");
|
||||
let route = row["route"].as_str().unwrap();
|
||||
let synthetic = controlled && matches!(route, "synthetic-same" | "synthetic-cross");
|
||||
let is_cross = route.ends_with("-cross") || (controlled && route == "synthetic-redirect");
|
||||
let expected = if route == "network-policy-redirect" || effective_policy == "no-referrer" || (effective_policy == "same-origin" && is_cross) {
|
||||
None
|
||||
} else if effective_policy == "origin" || (effective_policy == "strict-origin-when-cross-origin" && is_cross) {
|
||||
Some(format!("{origin}/"))
|
||||
} else { Some(full_referrer.to_string()) };
|
||||
let data = &row["data"];
|
||||
if synthetic {
|
||||
assert_eq!(data["source"], "serviceworker");
|
||||
assert_eq!(data["referrer"], expected.as_deref().unwrap_or(""), "{policy}/{controlled}: {row}");
|
||||
assert_eq!(data["referrerPolicy"], effective_policy);
|
||||
assert_eq!(data["cache"], if row["kind"] == "eventsource" { "no-store" } else { "default" });
|
||||
} else {
|
||||
assert_eq!(data["source"], "network");
|
||||
assert_eq!(data["referrer"], serde_json::to_value(expected)?, "{policy}/{controlled}: {row}");
|
||||
}
|
||||
}
|
||||
anyhow::Ok(())
|
||||
}).await.unwrap();
|
||||
let _ = stop.send(());
|
||||
server.join().unwrap();
|
||||
let mut observed = Vec::new();
|
||||
while let Ok(request) = received.try_recv() { observed.push(request); }
|
||||
assert_eq!(observed.iter().filter(|(path, _)| path == "/app/sw.js").count(), usize::from(controlled));
|
||||
assert!(observed.iter().any(|(path, _)| path.starts_with("/app/network?api=xhr")));
|
||||
assert!(observed.iter().any(|(path, _)| path.starts_with("/app/network?api=eventsource")));
|
||||
if matches!(policy, "no-referrer" | "meta-no-referrer") {
|
||||
assert!(observed.iter().filter(|(path, _)| path != "/app/sw.js").all(|(_, referrer)| referrer.is_none()));
|
||||
}
|
||||
}).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn window_request_referrer_default_policy() {
|
||||
check_window_request_referrer("default").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn window_request_referrer_no_referrer_policy() {
|
||||
check_window_request_referrer("no-referrer").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn window_request_referrer_origin_policy() {
|
||||
check_window_request_referrer("origin").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn window_request_referrer_same_origin_policy() {
|
||||
check_window_request_referrer("same-origin").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn window_request_referrer_unsafe_url_policy() {
|
||||
check_window_request_referrer("unsafe-url").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn window_request_referrer_meta_no_referrer_policy() {
|
||||
check_window_request_referrer("meta-no-referrer").await;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
|
||||
globalThis.referrerResult = null;
|
||||
globalThis.referrerError = null;
|
||||
(async () => {
|
||||
if (CONTROLLED) {
|
||||
await navigator.serviceWorker.register('/app/sw.js', {scope: '/app/'});
|
||||
await navigator.serviceWorker.ready;
|
||||
if (!navigator.serviceWorker.controller) await new Promise(resolve =>
|
||||
navigator.serviceWorker.addEventListener('controllerchange', resolve, {once: true}));
|
||||
}
|
||||
function take(kind, url) {
|
||||
if (kind === 'fetch') return fetch(url).then(response => response.json());
|
||||
if (kind === 'eventsource') return new Promise((resolve, reject) => {
|
||||
const source = new EventSource(url);
|
||||
source.onmessage = event => {source.close(); resolve(JSON.parse(event.data));};
|
||||
source.onerror = () => {source.close(); reject(new Error('EventSource failed: ' + url));};
|
||||
});
|
||||
if (kind === 'syncxhr') {
|
||||
const xhr = new XMLHttpRequest(); xhr.open('GET', url, false); xhr.send();
|
||||
if (xhr.status !== 200) throw new Error('sync XHR status ' + xhr.status);
|
||||
return Promise.resolve(JSON.parse(xhr.responseText));
|
||||
}
|
||||
return new Promise((resolve, reject) => {
|
||||
const xhr = new XMLHttpRequest(); xhr.open('GET', url, true);
|
||||
xhr.onload = () => xhr.status === 200 ? resolve(JSON.parse(xhr.responseText)) : reject(new Error('XHR status ' + xhr.status));
|
||||
xhr.onerror = () => reject(new Error('XHR failed: ' + url)); xhr.send();
|
||||
});
|
||||
}
|
||||
const routes = [
|
||||
['synthetic-same', ORIGIN + '/app/echo'], ['synthetic-cross', CROSS + '/echo'],
|
||||
['forward-same', ORIGIN + '/app/forward'], ['forward-cross', CROSS + '/forward'],
|
||||
['fallback-same', ORIGIN + '/app/network'], ['fallback-cross', CROSS + '/network'],
|
||||
['synthetic-redirect', ORIGIN + '/app/sw-redirect'],
|
||||
['network-policy-redirect', ORIGIN + '/app/network-redirect']
|
||||
];
|
||||
const rows = [];
|
||||
for (const kind of ['xhr', 'syncxhr', 'eventsource', 'fetch']) {
|
||||
for (const [route, url] of routes) {
|
||||
if (kind === 'syncxhr' && !route.startsWith('synthetic-')) continue;
|
||||
try { rows.push({kind, route, data: await take(kind, url + '?api=' + kind)}); }
|
||||
catch (error) { rows.push({kind, route, error: String(error)}); }
|
||||
}
|
||||
}
|
||||
referrerResult = {url: location.href, documentReferrerPolicy: document.referrerPolicy, rows};
|
||||
})().catch(error => referrerError = String(error)); void 0;
|
||||
@@ -0,0 +1,21 @@
|
||||
|
||||
self.oninstall = event => event.waitUntil(self.skipWaiting());
|
||||
self.onactivate = event => event.waitUntil(self.clients.claim());
|
||||
self.onfetch = event => {
|
||||
const url = new URL(event.request.url), path = url.pathname;
|
||||
const kind = url.searchParams.get('api');
|
||||
if (path.endsWith('/echo')) {
|
||||
const result = {source: 'serviceworker', referrer: event.request.referrer,
|
||||
referrerPolicy: event.request.referrerPolicy, cache: event.request.cache,
|
||||
method: event.request.method, mode: event.request.mode,
|
||||
credentials: event.request.credentials, destination: event.request.destination,
|
||||
bodyIsNull: event.request.body === null, clientId: event.clientId,
|
||||
resultingClientId: event.resultingClientId};
|
||||
event.respondWith(new Response(kind === 'eventsource' ? 'data: ' + JSON.stringify(result) + '\n\n' : JSON.stringify(result),
|
||||
{headers: {'Content-Type': kind === 'eventsource' ? 'text/event-stream' : 'application/json'}}));
|
||||
} else if (path.endsWith('/forward')) {
|
||||
event.respondWith(fetch(event.request));
|
||||
} else if (path.endsWith('/sw-redirect')) {
|
||||
event.respondWith(Response.redirect(CROSS + '/network?api=' + kind, 307));
|
||||
}
|
||||
};
|
||||
Reference in New Issue
Block a user