| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ |
| |
| //! Liberally derived from the [Firefox JS implementation](http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/webconsole.js). |
| //! Handles interaction with the remote web console on network events (HTTP requests, responses) in Servo. |
| |
| use std::time::{Duration, SystemTime, UNIX_EPOCH}; |
| |
| use base64::engine::Engine; |
| use base64::engine::general_purpose::STANDARD; |
| use chrono::{Local, LocalResult, TimeZone}; |
| use devtools_traits::{HttpRequest as DevtoolsHttpRequest, HttpResponse as DevtoolsHttpResponse}; |
| use headers::{ContentLength, ContentType, Cookie, HeaderMapExt}; |
| use http::{HeaderMap, Method}; |
| use net::cookie::ServoCookie; |
| use net_traits::CookieSource; |
| use net_traits::request::Destination as RequestDestination; |
| use serde::Serialize; |
| use serde_json::{Map, Value}; |
| use servo_url::ServoUrl; |
| |
| use crate::StreamId; |
| use crate::actor::{Actor, ActorError, ActorRegistry}; |
| use crate::actors::long_string::LongStringActor; |
| use crate::network_handler::Cause; |
| use crate::protocol::ClientRequest; |
| |
| pub struct NetworkEventActor { |
| pub name: String, |
| pub resource_id: u64, |
| pub is_xhr: bool, |
| pub request_url: String, |
| pub request_method: Method, |
| pub request_started: SystemTime, |
| pub request_time_stamp: i64, |
| pub request_destination: RequestDestination, |
| pub request_headers_raw: Option<HeaderMap>, |
| pub request_body: Option<Vec<u8>>, |
| pub request_cookies: Option<RequestCookiesMsg>, |
| pub request_headers: Option<RequestHeadersMsg>, |
| pub response_headers_raw: Option<HeaderMap>, |
| pub response_body: Option<Vec<u8>>, |
| pub response_content: Option<ResponseContentMsg>, |
| pub response_start: Option<ResponseStartMsg>, |
| pub response_cookies: Option<ResponseCookiesMsg>, |
| pub response_headers: Option<ResponseHeadersMsg>, |
| pub total_time: Duration, |
| pub security_state: String, |
| pub event_timing: Option<Timings>, |
| pub watcher_name: String, |
| } |
| |
| #[derive(Clone, Serialize)] |
| #[serde(rename_all = "camelCase")] |
| pub struct NetworkEventResource { |
| pub resource_id: u64, |
| pub resource_updates: Map<String, Value>, |
| pub browsing_context_id: u64, |
| pub inner_window_id: u64, |
| } |
| |
| #[derive(Clone, Serialize)] |
| #[serde(rename_all = "camelCase")] |
| pub struct EventActor { |
| pub actor: String, |
| pub resource_id: u64, |
| pub url: String, |
| pub method: String, |
| pub started_date_time: String, |
| pub time_stamp: i64, |
| #[serde(rename = "isXHR")] |
| pub is_xhr: bool, |
| pub private: bool, |
| pub cause: Cause, |
| } |
| |
| #[derive(Serialize)] |
| pub struct ResponseCookiesMsg { |
| pub cookies: Vec<ResponseCookieObj>, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| pub struct ResponseStartMsg { |
| pub http_version: String, |
| pub remote_address: String, |
| pub remote_port: u32, |
| pub status: String, |
| pub status_text: String, |
| pub headers_size: usize, |
| pub discard_response_body: bool, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| pub struct ResponseContentMsg { |
| pub mime_type: String, |
| pub content_size: u32, |
| pub transferred_size: u32, |
| pub discard_response_body: bool, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| pub struct ResponseHeadersMsg { |
| pub headers: usize, |
| pub headers_size: usize, |
| } |
| |
| #[derive(Serialize)] |
| pub struct RequestCookiesMsg { |
| pub cookies: Vec<RequestCookieObj>, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| pub struct RequestHeadersMsg { |
| headers: usize, |
| headers_size: usize, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| struct GetRequestHeadersReply { |
| from: String, |
| headers: Vec<Header>, |
| header_size: usize, |
| raw_headers: String, |
| } |
| |
| #[derive(Serialize)] |
| struct Header { |
| name: String, |
| value: String, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| struct GetResponseHeadersReply { |
| from: String, |
| headers: Vec<Header>, |
| header_size: usize, |
| raw_headers: String, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| struct GetResponseContentReply { |
| from: String, |
| content: Option<ResponseContentObj>, |
| content_discarded: bool, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| struct GetRequestPostDataReply { |
| from: String, |
| post_data: Option<Vec<u8>>, |
| post_data_discarded: bool, |
| } |
| |
| #[derive(Serialize)] |
| struct GetRequestCookiesReply { |
| from: String, |
| cookies: Vec<RequestCookieObj>, |
| } |
| |
| #[derive(Serialize)] |
| struct GetResponseCookiesReply { |
| from: String, |
| cookies: Vec<ResponseCookieObj>, |
| } |
| #[derive(Clone, Serialize)] |
| pub struct ResponseCookieObj { |
| pub name: String, |
| pub value: String, |
| pub path: Option<String>, |
| pub domain: Option<String>, |
| pub expires: Option<String>, |
| #[serde(rename = "httpOnly")] |
| pub http_only: Option<bool>, |
| pub secure: Option<bool>, |
| #[serde(rename = "sameSite")] |
| pub same_site: Option<String>, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| struct ResponseContentObj { |
| mime_type: String, |
| text: Value, |
| body_size: usize, |
| decoded_body_size: usize, |
| size: usize, |
| headers_size: usize, |
| transferred_size: usize, |
| #[serde(skip_serializing_if = "Option::is_none")] |
| encoding: Option<String>, |
| } |
| |
| #[derive(Clone, Serialize)] |
| pub struct RequestCookieObj { |
| pub name: String, |
| pub value: String, |
| } |
| |
| #[derive(Clone, Default, Serialize)] |
| pub struct Timings { |
| blocked: u32, |
| dns: u32, |
| connect: u64, |
| send: u64, |
| wait: u32, |
| receive: u32, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| struct GetEventTimingsReply { |
| from: String, |
| timings: Timings, |
| total_time: u64, |
| } |
| |
| #[derive(Serialize)] |
| struct SecurityInfo { |
| state: String, |
| } |
| |
| #[derive(Serialize)] |
| #[serde(rename_all = "camelCase")] |
| struct GetSecurityInfoReply { |
| from: String, |
| security_info: SecurityInfo, |
| } |
| |
| impl Actor for NetworkEventActor { |
| fn name(&self) -> String { |
| self.name.clone() |
| } |
| |
| fn handle_message( |
| &self, |
| request: ClientRequest, |
| registry: &ActorRegistry, |
| msg_type: &str, |
| _msg: &Map<String, Value>, |
| _id: StreamId, |
| ) -> Result<(), ActorError> { |
| match msg_type { |
| "getRequestHeaders" => { |
| let mut headers = Vec::new(); |
| let mut raw_headers_string = "".to_owned(); |
| let mut headers_size = 0; |
| if let Some(ref headers_map) = self.request_headers_raw { |
| for (name, value) in headers_map.iter() { |
| let value = &value.to_str().unwrap().to_string(); |
| raw_headers_string = |
| raw_headers_string + name.as_str() + ":" + value + "\r\n"; |
| headers_size += name.as_str().len() + value.len(); |
| headers.push(Header { |
| name: name.as_str().to_owned(), |
| value: value.to_owned(), |
| }); |
| } |
| } |
| |
| let msg = GetRequestHeadersReply { |
| from: self.name(), |
| headers, |
| header_size: headers_size, |
| raw_headers: raw_headers_string, |
| }; |
| request.reply_final(&msg)? |
| }, |
| "getRequestCookies" => { |
| let cookies = self |
| .request_cookies |
| .as_ref() |
| .map(|msg| msg.cookies.clone()) |
| .unwrap_or_default(); |
| let msg = GetRequestCookiesReply { |
| from: self.name(), |
| cookies, |
| }; |
| request.reply_final(&msg)? |
| }, |
| "getRequestPostData" => { |
| let msg = GetRequestPostDataReply { |
| from: self.name(), |
| post_data: self.request_body.clone(), |
| post_data_discarded: self.request_body.is_none(), |
| }; |
| request.reply_final(&msg)? |
| }, |
| "getResponseHeaders" => { |
| if let Some(ref response_headers) = self.response_headers_raw { |
| let mut headers = vec![]; |
| let mut raw_headers_string = "".to_owned(); |
| let mut headers_size = 0; |
| for (name, value) in response_headers.iter() { |
| headers.push(Header { |
| name: name.as_str().to_owned(), |
| value: value.to_str().unwrap().to_owned(), |
| }); |
| headers_size += name.as_str().len() + value.len(); |
| raw_headers_string.push_str(name.as_str()); |
| raw_headers_string.push(':'); |
| raw_headers_string.push_str(value.to_str().unwrap()); |
| raw_headers_string.push_str("\r\n"); |
| } |
| let msg = GetResponseHeadersReply { |
| from: self.name(), |
| headers, |
| header_size: headers_size, |
| raw_headers: raw_headers_string, |
| }; |
| request.reply_final(&msg)?; |
| } else { |
| // FIXME: what happens when there are no response headers? |
| return Err(ActorError::Internal); |
| } |
| }, |
| "getResponseCookies" => { |
| let cookies = self |
| .response_cookies |
| .as_ref() |
| .map(|msg| msg.cookies.clone()) |
| .unwrap_or_default(); |
| let msg = GetResponseCookiesReply { |
| from: self.name(), |
| cookies, |
| }; |
| request.reply_final(&msg)? |
| }, |
| "getResponseContent" => { |
| let content_obj = self.response_body.as_ref().map(|body| { |
| let mime_type = self |
| .response_content |
| .as_ref() |
| .map(|c| c.mime_type.clone()) |
| .unwrap_or_default(); |
| let headers_size = self |
| .response_headers |
| .as_ref() |
| .map(|h| h.headers_size) |
| .unwrap_or(0); |
| let transferred_size = self |
| .response_content |
| .as_ref() |
| .map(|c| c.transferred_size as usize) |
| .unwrap_or(0); |
| let body_size = body.len(); |
| let decoded_body_size = body.len(); |
| let size = body.len(); |
| |
| if Self::is_text_mime(&mime_type) { |
| let full_str = String::from_utf8_lossy(body).to_string(); |
| |
| // Queue a LongStringActor for this body |
| let long_string_actor = LongStringActor::new(registry, full_str); |
| let long_string_obj = long_string_actor.long_string_obj(); |
| registry.register_later(Box::new(long_string_actor)); |
| |
| ResponseContentObj { |
| mime_type, |
| text: serde_json::to_value(long_string_obj).unwrap(), |
| body_size, |
| decoded_body_size, |
| size, |
| headers_size, |
| transferred_size, |
| encoding: None, |
| } |
| } else { |
| let b64 = STANDARD.encode(body); |
| ResponseContentObj { |
| mime_type, |
| text: serde_json::to_value(b64).unwrap(), |
| body_size, |
| decoded_body_size, |
| size, |
| headers_size, |
| transferred_size, |
| encoding: Some("base64".to_string()), |
| } |
| } |
| }); |
| let msg = GetResponseContentReply { |
| from: self.name(), |
| content: content_obj, |
| content_discarded: self.response_body.is_none(), |
| }; |
| request.reply_final(&msg)? |
| }, |
| "getEventTimings" => { |
| // TODO: This is a fake timings msg |
| let timings_obj = self.event_timing.clone().unwrap_or_default(); |
| // Might use the one on self |
| let total = timings_obj.connect + timings_obj.send; |
| // TODO: Send the correct values for all these fields. |
| let msg = GetEventTimingsReply { |
| from: self.name(), |
| timings: timings_obj, |
| total_time: total, |
| }; |
| request.reply_final(&msg)? |
| }, |
| "getSecurityInfo" => { |
| // TODO: Send the correct values for securityInfo. |
| let msg = GetSecurityInfoReply { |
| from: self.name(), |
| security_info: SecurityInfo { |
| state: "insecure".to_owned(), |
| }, |
| }; |
| request.reply_final(&msg)? |
| }, |
| _ => return Err(ActorError::UnrecognizedPacketType), |
| }; |
| Ok(()) |
| } |
| } |
| |
| impl NetworkEventActor { |
| pub fn new(name: String, resource_id: u64, watcher_name: String) -> NetworkEventActor { |
| NetworkEventActor { |
| name, |
| resource_id, |
| is_xhr: false, |
| request_url: String::new(), |
| request_method: Method::GET, |
| request_started: SystemTime::now(), |
| request_time_stamp: SystemTime::now() |
| .duration_since(UNIX_EPOCH) |
| .unwrap_or_default() |
| .as_secs() as i64, |
| request_destination: RequestDestination::None, |
| request_headers_raw: None, |
| request_body: None, |
| request_cookies: None, |
| request_headers: None, |
| response_headers_raw: None, |
| response_body: None, |
| response_content: None, |
| response_start: None, |
| response_cookies: None, |
| response_headers: None, |
| total_time: Duration::ZERO, |
| security_state: "insecure".to_owned(), |
| event_timing: None, |
| watcher_name, |
| } |
| } |
| |
| pub fn add_request(&mut self, request: DevtoolsHttpRequest) { |
| self.is_xhr = request.is_xhr; |
| self.request_cookies = Self::request_cookies(&request); |
| self.request_headers = Some(Self::request_headers(&request)); |
| self.total_time = Self::total_time(&request); |
| self.event_timing = Some(Self::event_timing(&request)); |
| self.request_url = request.url.to_string(); |
| self.request_method = request.method; |
| self.request_started = request.started_date_time; |
| self.request_time_stamp = request.time_stamp; |
| self.request_destination = request.destination; |
| self.request_body = request.body.clone(); |
| self.request_headers_raw = Some(request.headers.clone()); |
| } |
| |
| pub fn add_response(&mut self, response: DevtoolsHttpResponse) { |
| self.response_headers = Some(Self::response_headers(&response)); |
| self.response_cookies = ServoUrl::parse(&self.request_url) |
| .ok() |
| .as_ref() |
| .and_then(|url| Self::response_cookies(&response, url)); |
| self.response_start = Some(Self::response_start(&response)); |
| if let Some(response_content) = Self::response_content(self, &response) { |
| self.response_content = Some(response_content); |
| } |
| self.response_headers_raw = response.headers.clone(); |
| } |
| |
| pub fn event_actor(&self) -> EventActor { |
| // TODO: Send the correct values for startedDateTime, isXHR, private |
| |
| let started_datetime_rfc3339 = match Local.timestamp_millis_opt( |
| self.request_started |
| .duration_since(UNIX_EPOCH) |
| .unwrap_or_default() |
| .as_millis() as i64, |
| ) { |
| LocalResult::None => "".to_owned(), |
| LocalResult::Single(date_time) => date_time.to_rfc3339().to_string(), |
| LocalResult::Ambiguous(date_time, _) => date_time.to_rfc3339().to_string(), |
| }; |
| |
| EventActor { |
| actor: self.name(), |
| resource_id: self.resource_id, |
| url: self.request_url.clone(), |
| method: format!("{}", self.request_method), |
| started_date_time: started_datetime_rfc3339, |
| time_stamp: self.request_time_stamp, |
| is_xhr: self.is_xhr, |
| private: false, |
| cause: Cause { |
| type_: self.request_destination.as_str().to_string(), |
| loading_document_uri: None, // Set if available |
| }, |
| } |
| } |
| |
| pub fn response_start(response: &DevtoolsHttpResponse) -> ResponseStartMsg { |
| // TODO: Send the correct values for all these fields. |
| let h_size = response.headers.as_ref().map(|h| h.len()).unwrap_or(0); |
| let status = &response.status; |
| |
| // TODO: Send the correct values for remoteAddress and remotePort and http_version |
| ResponseStartMsg { |
| http_version: "HTTP/1.1".to_owned(), |
| remote_address: "63.245.217.43".to_owned(), |
| remote_port: 443, |
| status: status.code().to_string(), |
| status_text: String::from_utf8_lossy(status.message()).to_string(), |
| headers_size: h_size, |
| discard_response_body: false, |
| } |
| } |
| |
| pub fn response_content( |
| &mut self, |
| response: &DevtoolsHttpResponse, |
| ) -> Option<ResponseContentMsg> { |
| let body = response.body.as_ref()?; |
| self.response_body = Some(body.clone()); |
| |
| let mime_type = response |
| .headers |
| .as_ref() |
| .and_then(|h| h.typed_get::<ContentType>()) |
| .map(|ct| ct.to_string()) |
| .unwrap_or_default(); |
| |
| let transferred_size = response |
| .headers |
| .as_ref() |
| .and_then(|hdrs| hdrs.typed_get::<ContentLength>()) |
| .map(|cl| cl.0); |
| |
| let content_size = response.body.as_ref().map(|body| body.len() as u64); |
| |
| Some(ResponseContentMsg { |
| mime_type, |
| content_size: content_size.unwrap_or(0) as u32, |
| transferred_size: transferred_size.unwrap_or(0) as u32, |
| discard_response_body: false, |
| }) |
| } |
| |
| pub fn response_cookies( |
| response: &DevtoolsHttpResponse, |
| url: &ServoUrl, |
| ) -> Option<ResponseCookiesMsg> { |
| let headers = response.headers.as_ref()?; |
| let cookies = headers |
| .get_all("set-cookie") |
| .iter() |
| .filter_map(|cookie| { |
| let cookie_str = String::from_utf8(cookie.as_bytes().to_vec()).ok()?; |
| ServoCookie::from_cookie_string(cookie_str, url, CookieSource::HTTP) |
| }) |
| .map(|servo_cookie| { |
| let c = &servo_cookie.cookie; |
| ResponseCookieObj { |
| name: c.name().to_string(), |
| value: c.value().to_string(), |
| path: c.path().map(|p| p.to_string()), |
| domain: c.domain().map(|d| d.to_string()), |
| expires: c.expires().map(|dt| format!("{:?}", dt)), |
| http_only: c.http_only(), |
| secure: c.secure(), |
| same_site: c.same_site().map(|s| s.to_string()), |
| } |
| }) |
| .collect::<Vec<_>>(); |
| Some(ResponseCookiesMsg { cookies }) |
| } |
| |
| pub fn response_headers(response: &DevtoolsHttpResponse) -> ResponseHeadersMsg { |
| let mut header_size = 0; |
| let mut headers_byte_count = 0; |
| if let Some(ref headers) = response.headers { |
| for (name, value) in headers.iter() { |
| header_size += 1; |
| headers_byte_count += name.as_str().len() + value.len(); |
| } |
| } |
| ResponseHeadersMsg { |
| headers: header_size, |
| headers_size: headers_byte_count, |
| } |
| } |
| |
| pub fn request_headers(request: &DevtoolsHttpRequest) -> RequestHeadersMsg { |
| let size = request.headers.iter().fold(0, |acc, (name, value)| { |
| acc + name.as_str().len() + value.len() |
| }); |
| RequestHeadersMsg { |
| headers: request.headers.len(), |
| headers_size: size, |
| } |
| } |
| |
| pub fn request_cookies(request: &DevtoolsHttpRequest) -> Option<RequestCookiesMsg> { |
| let header_value = request.headers.typed_get::<Cookie>()?; |
| let cookies = header_value |
| .iter() |
| .map(|cookie| RequestCookieObj { |
| name: cookie.0.to_string(), |
| value: cookie.1.to_string(), |
| }) |
| .collect::<Vec<_>>(); |
| Some(RequestCookiesMsg { cookies }) |
| } |
| |
| pub fn total_time(request: &DevtoolsHttpRequest) -> Duration { |
| request.connect_time + request.send_time |
| } |
| |
| pub fn event_timing(request: &DevtoolsHttpRequest) -> Timings { |
| Timings { |
| blocked: 0, |
| dns: 0, |
| connect: request.connect_time.as_millis() as u64, |
| send: request.send_time.as_millis() as u64, |
| wait: 0, |
| receive: 0, |
| } |
| } |
| |
| pub fn is_text_mime(mime: &str) -> bool { |
| let lower = mime.to_ascii_lowercase(); |
| lower.starts_with("text/") || |
| lower.contains("json") || |
| lower.contains("javascript") || |
| lower.contains("xml") || |
| lower.contains("csv") || |
| lower.contains("html") |
| } |
| |
| fn insert_serialized_map<T: Serialize>(map: &mut Map<String, Value>, obj: &Option<T>) { |
| if let Some(value) = obj { |
| if let Ok(Value::Object(serialized)) = serde_json::to_value(value) { |
| for (key, val) in serialized { |
| map.insert(key, val); |
| } |
| } |
| } |
| } |
| |
| pub fn resource_updates(&self) -> NetworkEventResource { |
| let mut resource_updates = Map::new(); |
| |
| resource_updates.insert( |
| "requestCookiesAvailable".to_owned(), |
| Value::Bool(self.request_cookies.is_some()), |
| ); |
| |
| resource_updates.insert( |
| "requestHeadersAvailable".to_owned(), |
| Value::Bool(self.request_headers.is_some()), |
| ); |
| |
| resource_updates.insert( |
| "responseHeadersAvailable".to_owned(), |
| Value::Bool(self.response_headers.is_some()), |
| ); |
| resource_updates.insert( |
| "responseCookiesAvailable".to_owned(), |
| Value::Bool(self.response_cookies.is_some()), |
| ); |
| resource_updates.insert( |
| "responseStartAvailable".to_owned(), |
| Value::Bool(self.response_start.is_some()), |
| ); |
| resource_updates.insert( |
| "responseContentAvailable".to_owned(), |
| Value::Bool(self.response_content.is_some()), |
| ); |
| |
| resource_updates.insert( |
| "totalTime".to_string(), |
| Value::from(self.total_time.as_secs_f64()), |
| ); |
| |
| resource_updates.insert( |
| "securityState".to_string(), |
| Value::String(self.security_state.clone()), |
| ); |
| resource_updates.insert( |
| "eventTimingsAvailable".to_owned(), |
| Value::Bool(self.event_timing.is_some()), |
| ); |
| |
| Self::insert_serialized_map(&mut resource_updates, &self.response_content); |
| Self::insert_serialized_map(&mut resource_updates, &self.response_headers); |
| Self::insert_serialized_map(&mut resource_updates, &self.response_cookies); |
| Self::insert_serialized_map(&mut resource_updates, &self.request_headers); |
| Self::insert_serialized_map(&mut resource_updates, &self.request_cookies); |
| Self::insert_serialized_map(&mut resource_updates, &self.response_start); |
| Self::insert_serialized_map(&mut resource_updates, &self.event_timing); |
| |
| // TODO: Set the correct values for these fields |
| NetworkEventResource { |
| resource_id: self.resource_id, |
| resource_updates, |
| browsing_context_id: 0, |
| inner_window_id: 0, |
| } |
| } |
| } |
