diff --git a/components/net/resource_task.rs b/components/net/resource_task.rs index 60ad9c8578b..0c473d42676 100644 --- a/components/net/resource_task.rs +++ b/components/net/resource_task.rs @@ -221,7 +221,7 @@ impl ResourceManager { fn load(&self, load_data: LoadData) { let mut load_data = load_data; - self.user_agent.map(|ref ua| load_data.headers.set(UserAgent(ua.clone()))); + self.user_agent.as_ref().map(|ua| load_data.headers.set(UserAgent(ua.clone()))); let senders = ResponseSenders { immediate_consumer: self.sniffer_task.clone(), eventual_consumer: load_data.consumer.clone(), diff --git a/components/script/Cargo.toml b/components/script/Cargo.toml index f2adbed80c1..667aa76d7f9 100644 --- a/components/script/Cargo.toml +++ b/components/script/Cargo.toml @@ -52,8 +52,8 @@ branch = "servo" [dependencies.encoding] git = "https://github.com/lifthrasiir/rust-encoding" -[dependencies.http] -git = "https://github.com/servo/rust-http" +[dependencies.hyper] +git = "https://github.com/hyperium/hyper" branch = "servo" [dependencies.js] diff --git a/components/script/cors.rs b/components/script/cors.rs index 50e69ca333f..abd99af36d2 100644 --- a/components/script/cors.rs +++ b/components/script/cors.rs @@ -9,23 +9,21 @@ //! This library will eventually become the core of the Fetch crate //! with CORSRequest being expanded into FetchRequest (etc) -use std::ascii::{AsciiExt, OwnedAsciiExt}; -use std::from_str::FromStr; -use std::io::BufReader; +use std::ascii::AsciiExt; +use std::fmt::{mod, Show}; +use std::str::from_utf8; use time; use time::{now, Timespec}; -use http::headers::response::HeaderCollection as ResponseHeaderCollection; -use http::headers::request::HeaderCollection as RequestHeaderCollection; -use http::headers::request::Header as RequestHeader; +use hyper::header::{Headers, Header, HeaderFormat, HeaderView}; +use hyper::header::common::util as header_util; +use hyper::client::Request; +use hyper::mime::{mod, Mime}; +use hyper::header::common::{ContentType, Host}; +use hyper::method::{Method, Get, Head, Post, Options}; +use hyper::status::Success; -use http::client::{RequestWriter, NetworkStream}; -use http::headers::{HeaderConvertible, HeaderEnum, HeaderValueByteIterator}; -use http::headers::content_type::MediaType; -use http::headers::request::{Accept, AcceptLanguage, ContentLanguage, ContentType}; -use http::method::{Method, Get, Head, Post, Options}; - -use url::{RelativeSchemeData, Url, UrlParser}; +use url::{RelativeSchemeData, Url}; #[deriving(Clone)] pub struct CORSRequest { @@ -33,7 +31,7 @@ pub struct CORSRequest { pub destination: Url, pub mode: RequestMode, pub method: Method, - pub headers: RequestHeaderCollection, + pub headers: Headers, /// CORS preflight flag (http://fetch.spec.whatwg.org/#concept-http-fetch) /// Indicates that a CORS preflight request and/or cache check is to be performed pub preflight_flag: bool @@ -51,7 +49,7 @@ pub enum RequestMode { impl CORSRequest { /// Creates a CORS request if necessary. Will return an error when fetching is forbidden pub fn maybe_new(referer: Url, destination: Url, mode: RequestMode, - method: Method, headers: RequestHeaderCollection) -> Result, ()> { + method: Method, headers: Headers) -> Result, ()> { if referer.scheme == destination.scheme && referer.host() == destination.host() && referer.port() == destination.port() { @@ -73,7 +71,7 @@ impl CORSRequest { } fn new(mut referer: Url, destination: Url, mode: RequestMode, method: Method, - headers: RequestHeaderCollection) -> CORSRequest { + headers: Headers) -> CORSRequest { match referer.scheme_data { RelativeSchemeData(ref mut data) => data.path = vec!(), _ => {} @@ -104,7 +102,7 @@ impl CORSRequest { let cache = &mut CORSCache(vec!()); // XXXManishearth Should come from user agent if self.preflight_flag && !cache.match_method(self, &self.method) && - !self.headers.iter().all(|h| is_simple_header(&h) && cache.match_header(self, h.header_name().as_slice())) { + !self.headers.iter().all(|h| is_simple_header(&h) && cache.match_header(self, h.name())) { if !is_simple_method(&self.method) || self.mode == ForcedPreflightMode { return self.preflight_fetch(); // Everything after this is part of XHR::fetch() @@ -121,69 +119,63 @@ impl CORSRequest { let mut preflight = self.clone(); // Step 1 preflight.method = Options; // Step 2 - preflight.headers = RequestHeaderCollection::new(); // Step 3 + preflight.headers = Headers::new(); // Step 3 // Step 4 - preflight.insert_string_header("Access-Control-Request-Method".to_string(), self.method.http_value()); + preflight.headers.set(AccessControlRequestMethod(self.method.clone())); // Step 5 - 7 let mut header_names = vec!(); for header in self.headers.iter() { - header_names.push(header.header_name().into_ascii_lower()); + header_names.push(header.name().to_ascii_lower()); } header_names.sort(); - let header_list = header_names.connect(", "); // 0x2C 0x20 - preflight.insert_string_header("Access-Control-Request-Headers".to_string(), header_list); + preflight.headers.set(AccessControlRequestHeaders(header_names)); // Step 8 unnecessary, we don't use the request body // Step 9, 10 unnecessary, we're writing our own fetch code // Step 11 - let preflight_request = RequestWriter::::new(preflight.method, preflight.destination); - let mut writer = match preflight_request { - Ok(w) => box w, + let preflight_request = Request::new(preflight.method, preflight.destination); + let mut req = match preflight_request { + Ok(req) => req, Err(_) => return error }; - let host = writer.headers.host.clone(); - writer.headers = preflight.headers.clone(); - writer.headers.host = host; - let response = match writer.read_response() { + let host = req.headers().get::().unwrap().clone(); + *req.headers_mut() = preflight.headers.clone(); + req.headers_mut().set(host); + let stream = match req.start() { + Ok(s) => s, + Err(_) => return error + }; + let response = match stream.send() { Ok(r) => r, Err(_) => return error }; // Step 12 - match response.status.code() { - 200 ... 299 => {} - _ => return error + match response.status.class() { + Success => {} + _ => return error } cors_response.headers = response.headers.clone(); // Substeps 1-3 (parsing rules: http://fetch.spec.whatwg.org/#http-new-header-syntax) - fn find_header(headers: &ResponseHeaderCollection, name: &str) -> Option { - headers.iter().find(|h| h.header_name().as_slice() - .eq_ignore_ascii_case(name)) - .map(|h| h.header_value()) - } - let methods_string = match find_header(&response.headers, "Access-Control-Allow-Methods") { - Some(s) => s, + let mut methods = match response.headers.get() { + Some(&AccessControlAllowMethods(ref v)) => v.as_slice(), _ => return error }; - let methods = methods_string.as_slice().split(','); - let headers_string = match find_header(&response.headers, "Access-Control-Allow-Headers") { - Some(s) => s, + let headers = match response.headers.get() { + Some(&AccessControlAllowHeaders(ref h)) => h, _ => return error }; - let headers = headers_string.as_slice().split(0x2Cu8 as char); - // The ABNF # rule will consider consecutive delimeters as a single delimeter - let mut methods: Vec = methods.filter(|s| s.len() > 0).map(|s| s.to_string()).collect(); - let headers: Vec = headers.filter(|s| s.len() > 0).map(|s| s.to_string()).collect(); // Substep 4 + let methods_substep4 = [self.method.clone()]; if methods.len() == 0 || preflight.mode == ForcedPreflightMode { - methods = vec!(self.method.http_value()); + methods = methods_substep4.as_slice(); } // Substep 5 if !is_simple_method(&self.method) && - !methods.iter().any(|ref m| self.method.http_value().as_slice().eq_ignore_ascii_case(m.as_slice())) { + !methods.iter().any(|m| m == &self.method) { return error; } // Substep 6 @@ -191,30 +183,29 @@ impl CORSRequest { if is_simple_header(&h) { continue; } - if !headers.iter().any(|ref h2| h.header_name().as_slice().eq_ignore_ascii_case(h2.as_slice())) { + if !headers.iter().any(|ref h2| h.name().eq_ignore_ascii_case(h2.as_slice())) { return error; } } // Substep 7, 8 - let max_age: uint = find_header(&response.headers, "Access-Control-Max-Age") - .and_then(|h| FromStr::from_str(h.as_slice())).unwrap_or(0); + let max_age = match response.headers.get() { + Some(&AccessControlMaxAge(num)) => num, + None => 0 + }; // Substep 9: Impose restrictions on max-age, if any (unimplemented) // Substeps 10-12: Add a cache (partially implemented, XXXManishearth) // This cache should come from the user agent, creating a new one here to check // for compile time errors let cache = &mut CORSCache(vec!()); for m in methods.iter() { - let maybe_method: Option = FromStr::from_str(m.as_slice()); - maybe_method.map(|ref m| { - let cache_match = cache.match_method_and_update(self, m, max_age); - if !cache_match { - cache.insert(CORSCacheEntry::new(self.origin.clone(), self.destination.clone(), - max_age, false, MethodData(m.clone()))); - } - }); + let cache_match = cache.match_method_and_update(self, m, max_age); + if !cache_match { + cache.insert(CORSCacheEntry::new(self.origin.clone(), self.destination.clone(), + max_age, false, MethodData(m.clone()))); + } } - for h in headers.iter() { - let cache_match = cache.match_header_and_update(self, h.as_slice(), max_age); + for h in response.headers.iter() { + let cache_match = cache.match_header_and_update(self, h.name(), max_age); if !cache_match { cache.insert(CORSCacheEntry::new(self.origin.clone(), self.destination.clone(), max_age, false, HeaderData(h.to_string()))); @@ -222,35 +213,26 @@ impl CORSRequest { } cors_response } - - fn insert_string_header(&mut self, name: String, value: String) { - let value_bytes = value.into_bytes(); - let mut reader = BufReader::new(value_bytes.as_slice()); - let maybe_header: Option = HeaderEnum::value_from_stream( - String::from_str(name.as_slice()), - &mut HeaderValueByteIterator::new(&mut reader)); - self.headers.insert(maybe_header.unwrap()); - } } pub struct CORSResponse { pub network_error: bool, - pub headers: ResponseHeaderCollection + pub headers: Headers } impl CORSResponse { fn new() -> CORSResponse { CORSResponse { network_error: false, - headers: ResponseHeaderCollection::new() + headers: Headers::new() } } fn new_error() -> CORSResponse { CORSResponse { network_error: true, - headers: ResponseHeaderCollection::new() + headers: Headers::new() } } } @@ -290,14 +272,14 @@ impl HeaderOrMethod { pub struct CORSCacheEntry { pub origin: Url, pub url: Url, - pub max_age: uint, + pub max_age: u32, pub credentials: bool, pub header_or_method: HeaderOrMethod, created: Timespec } impl CORSCacheEntry { - fn new (origin:Url, url: Url, max_age: uint, credentials: bool, header_or_method: HeaderOrMethod) -> CORSCacheEntry { + fn new (origin:Url, url: Url, max_age: u32, credentials: bool, header_or_method: HeaderOrMethod) -> CORSCacheEntry { CORSCacheEntry { origin: origin, url: url, @@ -343,7 +325,7 @@ impl CORSCache { self.find_entry_by_header(request, header_name).is_some() } - fn match_header_and_update(&mut self, request: &CORSRequest, header_name: &str, new_max_age: uint) -> bool { + fn match_header_and_update(&mut self, request: &CORSRequest, header_name: &str, new_max_age: u32) -> bool { self.find_entry_by_header(request, header_name).map(|e| e.max_age = new_max_age).is_some() } @@ -365,7 +347,7 @@ impl CORSCache { self.find_entry_by_method(request, method).is_some() } - fn match_method_and_update(&mut self, request: &CORSRequest, method: &Method, new_max_age: uint) -> bool { + fn match_method_and_update(&mut self, request: &CORSRequest, method: &Method, new_max_age: u32) -> bool { self.find_entry_by_method(request, method).map(|e| e.max_age = new_max_age).is_some() } @@ -376,12 +358,18 @@ impl CORSCache { } } -fn is_simple_header(h: &RequestHeader) -> bool { - match *h { - Accept(_) | AcceptLanguage(_) | ContentLanguage(_) => true, - ContentType(MediaType {type_: ref t, subtype: ref s, ..}) => match (t.as_slice(), s.as_slice()) { - ("text", "plain") | ("application", "x-www-form-urlencoded") | ("multipart", "form-data") => true, +fn is_simple_header(h: &HeaderView) -> bool { + //FIXME: use h.is::() when AcceptLanguage and + //ContentLanguage headers exist + match h.name().to_ascii_lower().as_slice() { + "accept" | "accept-language" | "content-language" => true, + "content-type" => match h.value() { + Some(&ContentType(Mime(mime::Text, mime::Plain, _))) | + Some(&ContentType(Mime(mime::Application, mime::WwwFormUrlEncoded, _))) | + Some(&ContentType(Mime(mime::Multipart, mime::FormData, _))) => true, + _ => false + }, _ => false } @@ -394,25 +382,160 @@ fn is_simple_method(m: &Method) -> bool { } } +//XXX(seanmonstar): worth uplifting to Hyper? +#[deriving(Clone)] +struct AccessControlRequestMethod(pub Method); + +impl Header for AccessControlRequestMethod { + #[inline] + fn header_name(_: Option) -> &'static str { + "Access-Control-Request-Method" + } + + fn parse_header(raw: &[Vec]) -> Option { + header_util::from_one_raw_str(raw).map(AccessControlRequestMethod) + } +} + +impl HeaderFormat for AccessControlRequestMethod { + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + let AccessControlRequestMethod(ref method) = *self; + method.fmt(f) + } +} + +#[deriving(Clone)] +struct AccessControlRequestHeaders(pub Vec); + +impl Header for AccessControlRequestHeaders { + #[inline] + fn header_name(_: Option) -> &'static str { + "Access-Control-Request-Headers" + } + + fn parse_header(raw: &[Vec]) -> Option { + header_util::from_comma_delimited(raw).map(AccessControlRequestHeaders) + } +} + +impl HeaderFormat for AccessControlRequestHeaders { + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + let AccessControlRequestHeaders(ref parts) = *self; + header_util::fmt_comma_delimited(f, parts.as_slice()) + } +} + +#[deriving(Clone)] +struct AccessControlAllowMethods(pub Vec); + +impl Header for AccessControlAllowMethods { + #[inline] + fn header_name(_: Option) -> &'static str { + "Access-Control-Allow-Methods" + } + + fn parse_header(raw: &[Vec]) -> Option { + header_util::from_comma_delimited(raw).map(AccessControlAllowMethods) + } +} + +impl HeaderFormat for AccessControlAllowMethods { + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + let AccessControlAllowMethods(ref parts) = *self; + header_util::fmt_comma_delimited(f, parts.as_slice()) + } +} + +#[deriving(Clone)] +struct AccessControlAllowHeaders(pub Vec); + +impl Header for AccessControlAllowHeaders { + #[inline] + fn header_name(_: Option) -> &'static str { + "Access-Control-Allow-Headers" + } + + fn parse_header(raw: &[Vec]) -> Option { + header_util::from_comma_delimited(raw).map(AccessControlAllowHeaders) + } +} + +impl HeaderFormat for AccessControlAllowHeaders { + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + let AccessControlAllowHeaders(ref parts) = *self; + header_util::fmt_comma_delimited(f, parts.as_slice()) + } +} + +#[deriving(Clone)] +enum AccessControlAllowOrigin { + AllowStar, + AllowOrigin(Url), +} + + +impl Header for AccessControlAllowOrigin { + #[inline] + fn header_name(_: Option) -> &'static str { + "Access-Control-Allow-Origin" + } + + fn parse_header(raw: &[Vec]) -> Option { + if raw.len() == 1 { + from_utf8(raw[0].as_slice()).and_then(|s| { + if s == "*" { + Some(AllowStar) + } else { + Url::parse(s).ok().map(|url| AllowOrigin(url)) + } + }) + } else { + None + } + } +} + +impl HeaderFormat for AccessControlAllowOrigin { + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + AllowStar => "*".fmt(f), + AllowOrigin(ref url) => url.fmt(f) + } + } +} + +#[deriving(Clone)] +struct AccessControlMaxAge(pub u32); + +impl Header for AccessControlMaxAge { + #[inline] + fn header_name(_: Option) -> &'static str { + "Access-Control-Max-Age" + } + + fn parse_header(raw: &[Vec]) -> Option { + header_util::from_one_raw_str(raw).map(AccessControlMaxAge) + } +} + +impl HeaderFormat for AccessControlMaxAge { + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + let AccessControlMaxAge(ref num) = *self; + num.fmt(f) + } +} + + /// Perform a CORS check on a header list and CORS request /// http://fetch.spec.whatwg.org/#cors-check -pub fn allow_cross_origin_request(req: &CORSRequest, headers: &ResponseHeaderCollection) -> bool { - let allow_cross_origin_request = headers.iter().find(|h| h.header_name() - .as_slice() - .eq_ignore_ascii_case("Access-Control-Allow-Origin")); - match allow_cross_origin_request { - Some(h) => { - let origin_str = h.header_value(); - if origin_str.as_slice() == "*" { - return true; // Not always true, depends on credentials mode - } - match UrlParser::new().parse(origin_str.as_slice()) { - Ok(parsed) => parsed.scheme == req.origin.scheme && - parsed.host() == req.origin.host() && - parsed.port() == req.origin.port(), - _ => false - } - }, +pub fn allow_cross_origin_request(req: &CORSRequest, headers: &Headers) -> bool { + //FIXME(seanmonstar): use req.headers.get::() + match headers.get() { + Some(&AllowStar) => true, // Not always true, depends on credentials mode + Some(&AllowOrigin(ref url)) => + url.scheme == req.origin.scheme && + url.host() == req.origin.host() && + url.port() == req.origin.port(), None => false } } diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs index a6362baa71c..afd329137c0 100644 --- a/components/script/dom/bindings/trace.rs +++ b/components/script/dom/bindings/trace.rs @@ -34,9 +34,8 @@ use dom::node::{Node, TrustedNodeAddress}; use collections::hash::{Hash, Hasher}; use geom::rect::Rect; use html5ever::tree_builder::QuirksMode; -use http::headers::request::HeaderCollection as RequestHeaderCollection; -use http::headers::response::HeaderCollection as ResponseHeaderCollection; -use http::method::Method; +use hyper::header::Headers; +use hyper::method::Method; use js::jsapi::{JSObject, JSTracer, JS_CallTracer, JSTRACE_OBJECT}; use js::jsval::JSVal; use js::rust::Cx; @@ -209,7 +208,7 @@ no_jsmanaged_fields!(PropertyDeclarationBlock) no_jsmanaged_fields!(SubpageId, WindowSizeData, PipelineId) no_jsmanaged_fields!(QuirksMode) no_jsmanaged_fields!(Cx) -no_jsmanaged_fields!(ResponseHeaderCollection, RequestHeaderCollection, Method) +no_jsmanaged_fields!(Headers, Method) no_jsmanaged_fields!(ConstellationChan) no_jsmanaged_fields!(LayoutChan) no_jsmanaged_fields!(WindowProxyHandler) diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs index 699b1c9f8b0..a8461618db9 100644 --- a/components/script/dom/htmlformelement.rs +++ b/components/script/dom/htmlformelement.rs @@ -20,7 +20,7 @@ use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::htmlelement::HTMLElement; use dom::htmlinputelement::HTMLInputElement; use dom::node::{Node, NodeHelpers, ElementNodeTypeId, document_from_node, window_from_node}; -use http::method::Post; +use hyper::method::Post; use servo_msg::constellation_msg::LoadData; use servo_util::str::DOMString; use script_task::{ScriptChan, TriggerLoadMsg}; diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs index d93bff9ab90..7d2d31efebb 100644 --- a/components/script/dom/xmlhttprequest.rs +++ b/components/script/dom/xmlhttprequest.rs @@ -29,13 +29,11 @@ use encoding::all::UTF_8; use encoding::label::encoding_from_whatwg_label; use encoding::types::{DecodeReplace, Encoding, EncodingRef, EncodeReplace}; -use http::headers::response::HeaderCollection as ResponseHeaderCollection; -use http::headers::request::HeaderCollection as RequestHeaderCollection; -use http::headers::content_type::MediaType; -use http::headers::{HeaderEnum, HeaderValueByteIterator}; -use http::headers::request::Header; -use http::method::{Method, Get, Head, Connect, Trace, ExtensionMethod}; -use http::status::Status; +use hyper::header::Headers; +use hyper::header::common::{Accept, ContentLength, ContentType}; +use hyper::http::RawStatus; +use hyper::mime::{mod, Mime}; +use hyper::method::{Method, Get, Head, Connect, Trace, Extension}; use js::jsapi::{JS_AddObjectRoot, JS_ParseJSON, JS_RemoveObjectRoot, JSContext}; use js::jsapi::JS_ClearPendingException; @@ -54,7 +52,7 @@ use std::ascii::AsciiExt; use std::cell::Cell; use std::comm::{Sender, Receiver, channel}; use std::default::Default; -use std::io::{BufReader, MemWriter, Timer}; +use std::io::Timer; use std::from_str::FromStr; use std::time::duration::Duration; use std::num::Zero; @@ -88,7 +86,7 @@ pub struct GenerationId(uint); pub enum XHRProgress { /// Notify that headers have been received - HeadersReceivedMsg(GenerationId, Option, Option), + HeadersReceivedMsg(GenerationId, Option, Option), /// Partial progress (after receiving headers), containing portion of the response LoadingMsg(GenerationId, ByteString), /// Loading is done @@ -131,12 +129,12 @@ pub struct XMLHttpRequest { response: DOMRefCell, response_type: Cell, response_xml: MutNullableJS, - response_headers: DOMRefCell, + response_headers: DOMRefCell, // Associated concepts request_method: DOMRefCell, request_url: DOMRefCell>, - request_headers: DOMRefCell, + request_headers: DOMRefCell, request_body_len: Cell, sync: Cell, upload_complete: Cell, @@ -165,11 +163,11 @@ impl XMLHttpRequest { response: DOMRefCell::new(ByteString::new(vec!())), response_type: Cell::new(_empty), response_xml: Default::default(), - response_headers: DOMRefCell::new(ResponseHeaderCollection::new()), + response_headers: DOMRefCell::new(Headers::new()), request_method: DOMRefCell::new(Get), request_url: DOMRefCell::new(None), - request_headers: DOMRefCell::new(RequestHeaderCollection::new()), + request_headers: DOMRefCell::new(Headers::new()), request_body_len: Cell::new(0), sync: Cell::new(false), send_flag: Cell::new(false), @@ -345,28 +343,26 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { } fn Open(self, method: ByteString, url: DOMString) -> ErrorResult { - let uppercase_method = method.as_str().map(|s| { - let upper = s.to_ascii_upper(); - match upper.as_slice() { - "DELETE" | "GET" | "HEAD" | "OPTIONS" | - "POST" | "PUT" | "CONNECT" | "TRACE" | - "TRACK" => upper, - _ => s.to_string() - } - }); - let maybe_method: Option = uppercase_method.and_then(|s| { - // Note: rust-http tests against the uppercase versions + //FIXME(seanmonstar): use a Trie instead? + let maybe_method = method.as_str().and_then(|s| { + // Note: hyper tests against the uppercase versions // Since we want to pass methods not belonging to the short list above // without changing capitalization, this will actually sidestep rust-http's type system // since methods like "patch" or "PaTcH" will be considered extension methods // despite the there being a rust-http method variant for them - Method::from_str_or_new(s.as_slice()) + let upper = s.to_ascii_upper(); + match upper.as_slice() { + "DELETE" | "GET" | "HEAD" | "OPTIONS" | + "POST" | "PUT" | "CONNECT" | "TRACE" | + "TRACK" => from_str(upper.as_slice()), + _ => from_str(s) + } }); // Step 2 match maybe_method { // Step 4 Some(Connect) | Some(Trace) => Err(Security), - Some(ExtensionMethod(ref t)) if t.as_slice() == "TRACK" => Err(Security), + Some(Extension(ref t)) if t.as_slice() == "TRACK" => Err(Security), Some(_) if method.is_token() => { *self.request_method.borrow_mut() = maybe_method.unwrap(); @@ -389,7 +385,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { // Step 12 *self.request_url.borrow_mut() = Some(parsed_url); - *self.request_headers.borrow_mut() = RequestHeaderCollection::new(); + *self.request_headers.borrow_mut() = Headers::new(); self.send_flag.set(false); *self.status_text.borrow_mut() = ByteString::new(vec!()); self.status.set(0); @@ -417,7 +413,8 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { if !name.is_token() || !value.is_field_value() { return Err(Syntax); // Step 3, 4 } - let name_str = match name.to_lower().as_str() { + let name_lower = name.to_lower(); + let name_str = match name_lower.as_str() { Some(s) => { match s { // Disallowed headers @@ -431,48 +428,31 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { "upgrade" | "user-agent" | "via" => { return Ok(()); // Step 5 }, - _ => String::from_str(s) + _ => s } }, None => return Err(Syntax) }; - let mut collection = self.request_headers.borrow_mut(); + + debug!("SetRequestHeader: name={}, value={}", name.as_str(), value.as_str()); + let mut headers = self.request_headers.borrow_mut(); // Steps 6,7 - let old_header = collection.iter().find(|ref h| -> bool { - // XXXManishearth following line waiting on the rust upgrade: - ByteString::new(h.header_name().into_bytes()).eq_ignore_case(&value) - }); - match old_header { - Some(h) => { - unsafe { - // By step 4, the value is a subset of valid utf8 - // So this unsafe block should never fail - - let mut buf = h.header_value(); - buf.as_mut_vec().push_all(&[0x2C, 0x20]); - buf.as_mut_vec().push_all(value.as_slice()); - value = ByteString::new(buf.into_bytes()); - - } + match headers.get_raw(name_str) { + Some(raw) => { + debug!("SetRequestHeader: old value = {}", raw[0]); + let mut buf = raw[0].clone(); + buf.push_all(b", "); + buf.push_all(value.as_slice()); + debug!("SetRequestHeader: new value = {}", buf); + value = ByteString::new(buf); }, None => {} } - let mut reader = BufReader::new(value.as_slice()); - let maybe_header: Option
= HeaderEnum::value_from_stream( - name_str, - &mut HeaderValueByteIterator::new(&mut reader)); - match maybe_header { - Some(h) => { - // Overwrites existing headers, which we want since we have - // prepended the new header value with the old one already - collection.insert(h); - Ok(()) - }, - None => Err(Syntax) - } + headers.set_raw(name_str.into_string(), vec![value.as_slice().to_vec()]); + Ok(()) } fn Timeout(self) -> u32 { self.timeout.get() @@ -562,29 +542,37 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { load_data.data = extracted; // Default headers - let ref request_headers = self.request_headers; - if request_headers.borrow().content_type.is_none() { - let parameters = vec!((String::from_str("charset"), String::from_str("UTF-8"))); - request_headers.borrow_mut().content_type = match data { - Some(eString(_)) => - Some(MediaType { - type_: String::from_str("text"), - subtype: String::from_str("plain"), - parameters: parameters - }), - Some(eURLSearchParams(_)) => - Some(MediaType { - type_: String::from_str("application"), - subtype: String::from_str("x-www-form-urlencoded"), - parameters: parameters - }), - None => None + { + #[inline] + fn join_raw(a: &str, b: &str) -> Vec { + let len = a.len() + b.len(); + let mut vec = Vec::with_capacity(len); + vec.push_all(a.as_bytes()); + vec.push_all(b.as_bytes()); + vec + } + let ref mut request_headers = self.request_headers.borrow_mut(); + if !request_headers.has::() { + // XHR spec differs from http, and says UTF-8 should be in capitals, + // instead of "utf-8", which is what Hyper defaults to. + let params = ";charset=UTF-8"; + let n = "content-type"; + match data { + Some(eString(_)) => + request_headers.set_raw(n, vec![join_raw("text/plain", params)]), + Some(eURLSearchParams(_)) => + request_headers.set_raw( + n, vec![join_raw("application/x-www-form-urlencoded", params)]), + None => () + } } - } - if request_headers.borrow().accept.is_none() { - request_headers.borrow_mut().accept = Some(String::from_str("*/*")) - } + + if !request_headers.has::() { + request_headers.set( + Accept(vec![Mime(mime::TopStar, mime::SubStar, vec![])])); + } + } // drops the borrow_mut load_data.headers = (*self.request_headers.borrow()).clone(); load_data.method = (*self.request_method.borrow()).clone(); @@ -611,13 +599,15 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { buf.push_str(format!("{:u}", p).as_slice()); }); referer_url.serialize_path().map(|ref h| buf.push_str(h.as_slice())); - self.request_headers.borrow_mut().referer = Some(buf); + self.request_headers.borrow_mut().set_raw("Referer".to_string(), vec![buf.into_bytes()]); }, Ok(Some(ref req)) => self.insert_trusted_header("origin".to_string(), format!("{}", req.origin)), _ => {} } + debug!("request_headers = {}", *self.request_headers.borrow()); + let gen_id = self.generation_id.get(); if self.sync.get() { return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data, @@ -678,22 +668,13 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { } fn GetResponseHeader(self, name: ByteString) -> Option { self.filter_response_headers().iter().find(|h| { - name.eq_ignore_case(&FromStr::from_str(h.header_name().as_slice()).unwrap()) + name.eq_ignore_case(&FromStr::from_str(h.name()).unwrap()) }).map(|h| { - // rust-http doesn't decode properly, we'll convert it back to bytes here - ByteString::new(h.header_value().as_slice().chars().map(|c| { assert!(c <= '\u00FF'); c as u8 }).collect()) + ByteString::new(h.value_string().into_bytes()) }) } fn GetAllResponseHeaders(self) -> ByteString { - let mut writer = MemWriter::new(); - self.filter_response_headers().write_all(&mut writer).ok().expect("Writing response headers failed"); - let mut vec = writer.unwrap(); - - // rust-http appends an extra "\r\n" when using write_all - vec.pop(); - vec.pop(); - - ByteString::new(vec) + ByteString::new(self.filter_response_headers().to_string().into_bytes()) } fn ResponseType(self) -> XMLHttpRequestResponseType { self.response_type.get() @@ -797,7 +778,7 @@ trait PrivateXMLHttpRequestHelpers { fn text_response(self) -> DOMString; fn set_timeout(self, timeout:u32); fn cancel_timeout(self); - fn filter_response_headers(self) -> ResponseHeaderCollection; + fn filter_response_headers(self) -> Headers; } impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { @@ -876,17 +857,12 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { // Part of step 13, send() (processing response) // XXXManishearth handle errors, if any (substep 1) // Substep 2 - let status_text = status.as_ref().map_or(vec![], |s| s.reason().into_bytes()); - let status_code = status.as_ref().map_or(0, |s| s.code()); + status.map(|RawStatus(code, reason)| { + self.status.set(code); + *self.status_text.borrow_mut() = ByteString::new(reason.into_bytes()); + }); + headers.as_ref().map(|h| *self.response_headers.borrow_mut() = h.clone()); - *self.status_text.borrow_mut() = ByteString::new(status_text); - self.status.set(status_code); - match headers { - Some(ref h) => { - *self.response_headers.borrow_mut() = h.clone(); - } - None => {} - }; // Substep 3 if !self.sync.get() { self.change_ready_state(HeadersReceived); @@ -965,13 +941,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { fn insert_trusted_header(self, name: String, value: String) { // Insert a header without checking spec-compliance // Use for hardcoded headers - let mut collection = self.request_headers.borrow_mut(); - let value_bytes = value.into_bytes(); - let mut reader = BufReader::new(value_bytes.as_slice()); - let maybe_header: Option
= HeaderEnum::value_from_stream( - String::from_str(name.as_slice()), - &mut HeaderValueByteIterator::new(&mut reader)); - collection.insert(maybe_header.unwrap()); + self.request_headers.borrow_mut().set_raw(name, vec![value.into_bytes()]); } fn dispatch_progress_event(self, upload: bool, type_: DOMString, loaded: u64, total: Option) { @@ -999,7 +969,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { fn dispatch_response_progress_event(self, type_: DOMString) { let len = self.response.borrow().len() as u64; - let total = self.response_headers.borrow().content_length.map(|x| {x as u64}); + let total = self.response_headers.borrow().get::().map(|x| {x.len() as u64}); self.dispatch_progress_event(false, type_, len, total); } fn set_timeout(self, timeout: u32) { @@ -1030,30 +1000,49 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { fn text_response(self) -> DOMString { let mut encoding = UTF_8 as EncodingRef; - match self.response_headers.borrow().content_type { - Some(ref x) => { - for &(ref name, ref value) in x.parameters.iter() { - if name.as_slice().eq_ignore_ascii_case("charset") { - encoding = encoding_from_whatwg_label(value.as_slice()).unwrap_or(encoding); + match self.response_headers.borrow().get() { + Some(&ContentType(mime::Mime(_, _, ref params))) => { + for &(ref name, ref value) in params.iter() { + if name == &mime::Charset { + encoding = encoding_from_whatwg_label(value.to_string().as_slice()).unwrap_or(encoding); } } }, None => {} } + // According to Simon, decode() should never return an error, so unwrap()ing // the result should be fine. XXXManishearth have a closer look at this later encoding.decode(self.response.borrow().as_slice(), DecodeReplace).unwrap().to_string() } - fn filter_response_headers(self) -> ResponseHeaderCollection { + fn filter_response_headers(self) -> Headers { // http://fetch.spec.whatwg.org/#concept-response-header-list - let mut headers = ResponseHeaderCollection::new(); - for header in self.response_headers.borrow().iter() { - match header.header_name().as_slice().to_ascii_lower().as_slice() { - "set-cookie" | "set-cookie2" => {}, - // XXXManishearth additional CORS filtering goes here - _ => headers.insert(header) - }; + use std::fmt; + use hyper::header::{Header, HeaderFormat}; + use hyper::header::common::SetCookie; + + // a dummy header so we can use headers.remove::() + #[deriving(Clone)] + struct SetCookie2; + impl Header for SetCookie2 { + fn header_name(_: Option) -> &'static str { + "set-cookie2" + } + + fn parse_header(_: &[Vec]) -> Option { + unimplemented!() + } } + impl HeaderFormat for SetCookie2 { + fn fmt_header(&self, _f: &mut fmt::Formatter) -> fmt::Result { + unimplemented!() + } + } + + let mut headers = self.response_headers.borrow().clone(); + headers.remove::(); + headers.remove::(); + // XXXManishearth additional CORS filtering goes here headers } } diff --git a/components/script/lib.rs b/components/script/lib.rs index 3470cd63652..6699ff49d5d 100644 --- a/components/script/lib.rs +++ b/components/script/lib.rs @@ -22,7 +22,7 @@ extern crate collections; extern crate geom; extern crate html5ever; extern crate encoding; -extern crate http; +extern crate hyper; extern crate js; extern crate libc; extern crate msg; diff --git a/components/script/parse/html.rs b/components/script/parse/html.rs index 53a54e11f66..70ffc76e6d9 100644 --- a/components/script/parse/html.rs +++ b/components/script/parse/html.rs @@ -28,43 +28,60 @@ use servo_util::task_state; use servo_util::task_state::IN_HTML_PARSER; use std::ascii::AsciiExt; use std::comm::channel; +use std::fmt::{mod, Show}; use std::str::MaybeOwned; use url::Url; -use http::headers::HeaderEnum; -use time; +use time::{Tm, strptime}; use html5ever::Attribute; use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText}; use string_cache::QualName; +use hyper::header::{Header, HeaderFormat}; +use hyper::header::common::util as header_util; pub enum HTMLInput { InputString(String), InputUrl(Url), } -// Parses an RFC 2616 compliant date/time string, and returns a localized -// date/time string in a format suitable for document.lastModified. -fn parse_last_modified(timestamp: &str) -> String { - let format = "%m/%d/%Y %H:%M:%S"; +//FIXME(seanmonstar): uplift to Hyper +#[deriving(Clone)] +struct LastModified(pub Tm); - // RFC 822, updated by RFC 1123 - match time::strptime(timestamp, "%a, %d %b %Y %T %Z") { - Ok(t) => return t.to_local().strftime(format).unwrap(), - Err(_) => () +impl Header for LastModified { + #[inline] + fn header_name(_: Option) -> &'static str { + "Last-Modified" } - // RFC 850, obsoleted by RFC 1036 - match time::strptime(timestamp, "%A, %d-%b-%y %T %Z") { - Ok(t) => return t.to_local().strftime(format).unwrap(), - Err(_) => () + // Parses an RFC 2616 compliant date/time string, + fn parse_header(raw: &[Vec]) -> Option { + header_util::from_one_raw_str(raw).and_then(|s: String| { + let s = s.as_slice(); + strptime(s, "%a, %d %b %Y %T %Z").or_else(|_| { + strptime(s, "%A, %d-%b-%y %T %Z") + }).or_else(|_| { + strptime(s, "%c") + }).ok().map(|tm| LastModified(tm)) + }) } +} - // ANSI C's asctime() format - match time::strptime(timestamp, "%c") { - Ok(t) => t.to_local().strftime(format).unwrap(), - Err(_) => String::from_str("") +impl HeaderFormat for LastModified { + // a localized date/time string in a format suitable + // for document.lastModified. + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + let LastModified(ref tm) = *self; + match tm.tm_gmtoff { + 0 => tm.rfc822().fmt(f), + _ => tm.to_utc().rfc822().fmt(f) + } } } +fn dom_last_modified(tm: &Tm) -> String { + tm.to_local().strftime("%m/%d/%Y %H:%M:%S").unwrap() +} + trait SinkHelpers { fn get_or_create(&self, child: NodeOrText) -> Temporary; } @@ -211,15 +228,9 @@ pub fn parse_html(page: &Page, let load_response = input_port.recv(); load_response.metadata.headers.as_ref().map(|headers| { - let header = headers.iter().find(|h| - h.header_name().as_slice().to_ascii_lower() == "last-modified".to_string() - ); - - match header { - Some(h) => document.set_last_modified( - parse_last_modified(h.header_value().as_slice())), - None => {}, - }; + headers.get().map(|&LastModified(ref tm)| { + document.set_last_modified(dom_last_modified(tm)); + }); }); let base_url = load_response.metadata.final_url.clone();