2019-09-01 19:24:04 +00:00
|
|
|
//! Navigator backend for web
|
2020-01-12 22:06:27 +00:00
|
|
|
use js_sys::{Array, ArrayBuffer, Uint8Array};
|
2020-01-18 04:11:09 +00:00
|
|
|
use ruffle_core::backend::navigator::{
|
2020-07-23 22:30:39 +00:00
|
|
|
url_from_relative_url, NavigationMethod, NavigatorBackend, OwnedFuture, RequestOptions,
|
2022-04-08 12:40:11 +00:00
|
|
|
Response,
|
2020-01-18 04:11:09 +00:00
|
|
|
};
|
2020-08-28 17:16:13 +00:00
|
|
|
use ruffle_core::indexmap::IndexMap;
|
2020-06-18 08:36:04 +00:00
|
|
|
use ruffle_core::loader::Error;
|
2020-07-23 04:00:41 +00:00
|
|
|
use std::borrow::Cow;
|
2020-12-11 11:41:44 +00:00
|
|
|
use url::Url;
|
2019-09-04 02:15:03 +00:00
|
|
|
use wasm_bindgen::JsCast;
|
2019-11-09 02:10:21 +00:00
|
|
|
use wasm_bindgen_futures::{spawn_local, JsFuture};
|
2022-04-08 12:40:11 +00:00
|
|
|
use web_sys::{
|
|
|
|
window, Blob, BlobPropertyBag, Document, Request, RequestInit, Response as WebResponse,
|
|
|
|
};
|
2019-09-01 19:24:04 +00:00
|
|
|
|
2020-03-29 05:28:07 +00:00
|
|
|
pub struct WebNavigatorBackend {
|
2021-01-11 09:35:45 +00:00
|
|
|
allow_script_access: bool,
|
2020-12-11 11:41:44 +00:00
|
|
|
upgrade_to_https: bool,
|
2021-08-08 20:38:55 +00:00
|
|
|
base_url: Option<String>,
|
2020-03-29 05:28:07 +00:00
|
|
|
}
|
2019-09-01 19:24:04 +00:00
|
|
|
|
|
|
|
impl WebNavigatorBackend {
|
2021-08-08 20:38:55 +00:00
|
|
|
pub fn new(
|
|
|
|
allow_script_access: bool,
|
|
|
|
upgrade_to_https: bool,
|
2021-09-07 04:44:24 +00:00
|
|
|
mut base_url: Option<String>,
|
2021-08-08 20:38:55 +00:00
|
|
|
) -> Self {
|
2020-03-29 05:28:07 +00:00
|
|
|
let window = web_sys::window().expect("window()");
|
|
|
|
|
2021-09-12 15:00:36 +00:00
|
|
|
// Upgrade to HTTPS takes effect if the current page is hosted on HTTPS.
|
2021-01-06 09:08:47 +00:00
|
|
|
let upgrade_to_https =
|
|
|
|
upgrade_to_https && window.location().protocol().unwrap_or_default() == "https:";
|
|
|
|
|
2021-09-12 15:00:36 +00:00
|
|
|
if let Some(base) = &mut base_url {
|
|
|
|
// Adding trailing slash so url::parse will not drop last part
|
|
|
|
if !base.ends_with('/') {
|
|
|
|
base.push('/');
|
|
|
|
}
|
|
|
|
|
2021-09-07 04:44:24 +00:00
|
|
|
if Url::parse(base).is_err() {
|
|
|
|
let document = window.document().expect("Could not get document");
|
|
|
|
if let Ok(Some(doc_base_uri)) = document.base_uri() {
|
|
|
|
let doc_url =
|
|
|
|
Url::parse(&doc_base_uri).expect("Could not parse document base uri");
|
|
|
|
|
|
|
|
if let Ok(joined_url) = doc_url.join(base) {
|
|
|
|
base_url = Some(joined_url.into());
|
|
|
|
} else {
|
|
|
|
log::error!("Bad base directory {}", base);
|
|
|
|
base_url = None;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
log::error!("Could not get document base_uri for base directory inference");
|
|
|
|
base_url = None;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-16 14:09:26 +00:00
|
|
|
Self {
|
2021-01-11 09:35:45 +00:00
|
|
|
allow_script_access,
|
2020-12-11 11:41:44 +00:00
|
|
|
upgrade_to_https,
|
2021-08-08 20:38:55 +00:00
|
|
|
base_url,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn base_uri(&self, document: &Document) -> Option<String> {
|
|
|
|
if let Some(base_url) = self.base_url.clone() {
|
|
|
|
Some(base_url)
|
|
|
|
} else if let Ok(Some(base_uri)) = document.base_uri() {
|
|
|
|
Some(base_uri)
|
|
|
|
} else {
|
|
|
|
None
|
2020-03-29 05:28:07 +00:00
|
|
|
}
|
2019-09-01 19:24:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl NavigatorBackend for WebNavigatorBackend {
|
2019-09-17 03:37:11 +00:00
|
|
|
fn navigate_to_url(
|
|
|
|
&self,
|
|
|
|
url: String,
|
|
|
|
window_spec: Option<String>,
|
2020-08-28 17:16:13 +00:00
|
|
|
vars_method: Option<(NavigationMethod, IndexMap<String, String>)>,
|
2019-09-17 03:37:11 +00:00
|
|
|
) {
|
2021-03-21 06:02:57 +00:00
|
|
|
// If the URL is empty, we ignore the request
|
|
|
|
if url.is_empty() {
|
|
|
|
return;
|
|
|
|
}
|
2021-02-07 08:24:48 +00:00
|
|
|
|
2019-09-01 19:24:04 +00:00
|
|
|
if let Some(window) = window() {
|
2021-03-21 06:02:57 +00:00
|
|
|
let document = window.document().expect("Could not get document");
|
2021-08-08 20:38:55 +00:00
|
|
|
|
|
|
|
let base_uri = match self.base_uri(&document) {
|
|
|
|
Some(base_uri) => base_uri,
|
|
|
|
_ => return,
|
|
|
|
};
|
|
|
|
|
|
|
|
let url = if let Ok(new_url) = url_from_relative_url(&base_uri, &url) {
|
|
|
|
new_url
|
2021-01-09 23:28:40 +00:00
|
|
|
} else {
|
2021-03-21 06:02:57 +00:00
|
|
|
return;
|
2021-02-07 08:24:48 +00:00
|
|
|
};
|
|
|
|
|
2021-03-21 06:02:57 +00:00
|
|
|
// If allowScriptAccess is disabled, we should reject the javascript scheme
|
|
|
|
if !self.allow_script_access && url.scheme() == "javascript" {
|
|
|
|
log::warn!("SWF tried to run a script, but script access is not allowed");
|
|
|
|
return;
|
|
|
|
}
|
2021-02-07 08:24:48 +00:00
|
|
|
|
|
|
|
//TODO: Should we return a result for failed opens? Does Flash care?
|
|
|
|
match (vars_method, window_spec) {
|
|
|
|
(Some((navmethod, formvars)), window_spec) => {
|
2021-03-21 06:02:57 +00:00
|
|
|
let form_url = self.pre_process_url(url).to_string();
|
|
|
|
|
2021-02-07 08:24:48 +00:00
|
|
|
let body = match document.body() {
|
|
|
|
Some(body) => body,
|
|
|
|
None => return,
|
|
|
|
};
|
|
|
|
|
|
|
|
let form = document
|
|
|
|
.create_element("form")
|
|
|
|
.unwrap()
|
|
|
|
.dyn_into::<web_sys::HtmlFormElement>()
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let _ = form.set_attribute(
|
|
|
|
"method",
|
|
|
|
match navmethod {
|
2021-02-12 13:03:17 +00:00
|
|
|
NavigationMethod::Get => "get",
|
|
|
|
NavigationMethod::Post => "post",
|
2021-02-07 08:24:48 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
|
|
|
|
let _ = form.set_attribute("action", &form_url);
|
|
|
|
|
|
|
|
if let Some(target) = window_spec {
|
|
|
|
let _ = form.set_attribute("target", &target);
|
2021-01-09 23:28:40 +00:00
|
|
|
}
|
2019-11-07 19:34:38 +00:00
|
|
|
|
2021-02-07 08:24:48 +00:00
|
|
|
for (k, v) in formvars.iter() {
|
|
|
|
let hidden = document.create_element("input").unwrap();
|
2021-01-10 14:04:31 +00:00
|
|
|
|
2021-02-07 08:24:48 +00:00
|
|
|
let _ = hidden.set_attribute("type", "hidden");
|
|
|
|
let _ = hidden.set_attribute("name", k);
|
|
|
|
let _ = hidden.set_attribute("value", v);
|
2021-01-10 14:04:31 +00:00
|
|
|
|
2021-02-07 08:24:48 +00:00
|
|
|
let _ = form.append_child(&hidden);
|
|
|
|
}
|
|
|
|
|
|
|
|
let _ = body.append_child(&form);
|
|
|
|
let _ = form.submit();
|
|
|
|
}
|
|
|
|
(_, Some(ref window_name)) if !window_name.is_empty() => {
|
2021-03-21 06:02:57 +00:00
|
|
|
let _ = window.open_with_url_and_target(url.as_str(), window_name);
|
2021-02-07 08:24:48 +00:00
|
|
|
}
|
|
|
|
_ => {
|
2021-03-21 06:02:57 +00:00
|
|
|
let _ = window.location().assign(url.as_str());
|
2021-02-07 08:24:48 +00:00
|
|
|
}
|
|
|
|
};
|
2021-01-10 14:04:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-08 12:40:11 +00:00
|
|
|
fn fetch(&self, url: &str, options: RequestOptions) -> OwnedFuture<Response, Error> {
|
2020-12-11 11:41:44 +00:00
|
|
|
let url = if let Ok(parsed_url) = Url::parse(url) {
|
|
|
|
self.pre_process_url(parsed_url).to_string()
|
|
|
|
} else {
|
2021-09-07 04:44:24 +00:00
|
|
|
self.resolve_relative_url(url).to_string()
|
2020-12-11 11:41:44 +00:00
|
|
|
};
|
|
|
|
|
2019-11-09 02:10:21 +00:00
|
|
|
Box::pin(async move {
|
2020-01-12 22:06:27 +00:00
|
|
|
let mut init = RequestInit::new();
|
|
|
|
|
|
|
|
init.method(match options.method() {
|
2021-02-12 13:03:17 +00:00
|
|
|
NavigationMethod::Get => "GET",
|
|
|
|
NavigationMethod::Post => "POST",
|
2020-01-12 22:06:27 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
if let Some((data, mime)) = options.body() {
|
|
|
|
let arraydata = ArrayBuffer::new(data.len() as u32);
|
|
|
|
let u8data = Uint8Array::new(&arraydata);
|
|
|
|
|
|
|
|
for (i, byte) in data.iter().enumerate() {
|
|
|
|
u8data.fill(*byte, i as u32, i as u32 + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
let blobparts = Array::new();
|
|
|
|
blobparts.push(&arraydata);
|
|
|
|
|
|
|
|
let mut blobprops = BlobPropertyBag::new();
|
|
|
|
blobprops.type_(mime);
|
|
|
|
|
|
|
|
let datablob =
|
|
|
|
Blob::new_with_buffer_source_sequence_and_options(&blobparts, &blobprops)
|
|
|
|
.unwrap()
|
|
|
|
.dyn_into()
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
init.body(Some(&datablob));
|
|
|
|
}
|
|
|
|
|
2021-01-01 00:02:26 +00:00
|
|
|
let request = Request::new_with_str_and_init(&url, &init)
|
|
|
|
.map_err(|_| Error::FetchError(format!("Unable to create request for {}", url)))?;
|
2020-01-12 22:06:27 +00:00
|
|
|
|
2019-11-09 02:10:21 +00:00
|
|
|
let window = web_sys::window().unwrap();
|
2022-03-17 23:38:31 +00:00
|
|
|
let fetchval = JsFuture::from(window.fetch_with_request(&request))
|
|
|
|
.await
|
|
|
|
.map_err(|_| Error::FetchError("Got JS error".to_string()))?;
|
2021-03-27 19:43:43 +00:00
|
|
|
|
2022-04-08 12:40:11 +00:00
|
|
|
let response: WebResponse = fetchval.dyn_into().unwrap();
|
|
|
|
if !response.ok() {
|
2021-03-27 19:43:43 +00:00
|
|
|
return Err(Error::FetchError(format!(
|
|
|
|
"HTTP status is not ok, got {}",
|
2022-04-08 12:40:11 +00:00
|
|
|
response.status_text()
|
2021-03-27 19:43:43 +00:00
|
|
|
)));
|
2021-03-26 01:07:50 +00:00
|
|
|
}
|
2021-03-27 19:43:43 +00:00
|
|
|
|
2022-04-08 12:40:11 +00:00
|
|
|
let body: ArrayBuffer = JsFuture::from(response.array_buffer().unwrap())
|
2019-11-09 02:10:21 +00:00
|
|
|
.await
|
2021-08-25 10:32:55 +00:00
|
|
|
.map_err(|_| {
|
|
|
|
Error::FetchError("Could not allocate array buffer for response".to_string())
|
|
|
|
})?
|
2019-11-09 02:10:21 +00:00
|
|
|
.dyn_into()
|
|
|
|
.unwrap();
|
2022-04-08 12:40:11 +00:00
|
|
|
let body = Uint8Array::new(&body).to_vec();
|
2021-08-25 10:32:55 +00:00
|
|
|
|
2022-04-08 12:40:11 +00:00
|
|
|
Ok(Response { body })
|
2019-11-09 02:10:21 +00:00
|
|
|
})
|
2019-11-07 19:34:38 +00:00
|
|
|
}
|
|
|
|
|
2020-06-18 08:36:04 +00:00
|
|
|
fn spawn_future(&mut self, future: OwnedFuture<(), Error>) {
|
2019-11-14 19:52:13 +00:00
|
|
|
spawn_local(async move {
|
|
|
|
if let Err(e) = future.await {
|
2020-09-19 14:27:24 +00:00
|
|
|
log::error!("Asynchronous error occurred: {}", e);
|
2019-11-14 19:52:13 +00:00
|
|
|
}
|
|
|
|
})
|
2019-11-07 19:34:38 +00:00
|
|
|
}
|
2020-07-23 04:00:41 +00:00
|
|
|
|
2021-09-07 04:44:24 +00:00
|
|
|
fn resolve_relative_url<'a>(&self, url: &'a str) -> Cow<'a, str> {
|
2020-07-23 22:30:39 +00:00
|
|
|
let window = web_sys::window().expect("window()");
|
|
|
|
let document = window.document().expect("document()");
|
|
|
|
|
2021-08-08 20:38:55 +00:00
|
|
|
if let Some(base_uri) = self.base_uri(&document) {
|
2020-07-23 22:30:39 +00:00
|
|
|
if let Ok(new_url) = url_from_relative_url(&base_uri, url) {
|
2021-05-08 03:00:22 +00:00
|
|
|
return String::from(new_url).into();
|
2020-07-23 04:00:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
url.into()
|
|
|
|
}
|
2020-12-11 11:41:44 +00:00
|
|
|
|
|
|
|
fn pre_process_url(&self, mut url: Url) -> Url {
|
|
|
|
if self.upgrade_to_https && url.scheme() == "http" && url.set_scheme("https").is_err() {
|
|
|
|
log::error!("Url::set_scheme failed on: {}", url);
|
|
|
|
}
|
|
|
|
url
|
|
|
|
}
|
2019-09-17 03:37:11 +00:00
|
|
|
}
|