Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

convert script crate to use hyper

Browse source
This commit is contained in:
Sean McArthur 2014-11-20 17:39:09 -08:00 • committed by Manish Goregaokar
parent 1dc67f0c76
commit 4ee8c3a60b
8 changed files with 382 additions and 260 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/net/resource_task.rs
View file

@ -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(),

4
components/script/Cargo.toml
View file

@ -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]

309
components/script/cors.rs
View file

@ -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<Option<CORSRequest>, ()> {
method: Method, headers: Headers) -> Result<Option<CORSRequest>, ()> {
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::<NetworkStream>::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::<Host>().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 => {}
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<String> {
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<String> = methods.filter(|s| s.len() > 0).map(|s| s.to_string()).collect();
let headers: Vec<String> = 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<Method> = 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())));
}
});
}
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<RequestHeader> = 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::<HeaderType>() 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<AccessControlRequestMethod>) -> &'static str {
"Access-Control-Request-Method"
}
fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlRequestMethod> {
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<String>);
impl Header for AccessControlRequestHeaders {
#[inline]
fn header_name(_: Option<AccessControlRequestHeaders>) -> &'static str {
"Access-Control-Request-Headers"
}
fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlRequestHeaders> {
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<Method>);
impl Header for AccessControlAllowMethods {
#[inline]
fn header_name(_: Option<AccessControlAllowMethods>) -> &'static str {
"Access-Control-Allow-Methods"
}
fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowMethods> {
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<String>);
impl Header for AccessControlAllowHeaders {
#[inline]
fn header_name(_: Option<AccessControlAllowHeaders>) -> &'static str {
"Access-Control-Allow-Headers"
}
fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowHeaders> {
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<AccessControlAllowOrigin>) -> &'static str {
"Access-Control-Allow-Origin"
}
fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowOrigin> {
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<AccessControlMaxAge>) -> &'static str {
"Access-Control-Max-Age"
}
fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlMaxAge> {
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::<AccessControlAllowOrigin>()
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
}
}

7
components/script/dom/bindings/trace.rs
View file

@ -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)

2
components/script/dom/htmlformelement.rs
View file

@ -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};

229
components/script/dom/xmlhttprequest.rs
View file

@ -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<ResponseHeaderCollection>, Option<Status>),
HeadersReceivedMsg(GenerationId, Option<Headers>, Option<RawStatus>),
/// 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<ByteString>,
response_type: Cell<XMLHttpRequestResponseType>,
response_xml: MutNullableJS<Document>,
response_headers: DOMRefCell<ResponseHeaderCollection>,
response_headers: DOMRefCell<Headers>,
// Associated concepts
request_method: DOMRefCell<Method>,
request_url: DOMRefCell<Option<Url>>,
request_headers: DOMRefCell<RequestHeaderCollection>,
request_headers: DOMRefCell<Headers>,
request_body_len: Cell<uint>,
sync: Cell<bool>,
upload_complete: Cell<bool>,
@ -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<Method> = 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<Header> = 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);
headers.set_raw(name_str.into_string(), vec![value.as_slice().to_vec()]);
Ok(())
},
None => Err(Syntax)
}
}
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 {
{
#[inline]
fn join_raw(a: &str, b: &str) -> Vec<u8> {
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::<ContentType>() {
// 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(_)) =>
Some(MediaType {
type_: String::from_str("text"),
subtype: String::from_str("plain"),
parameters: parameters
}),
request_headers.set_raw(n, vec![join_raw("text/plain", params)]),
Some(eURLSearchParams(_)) =>
Some(MediaType {
type_: String::from_str("application"),
subtype: String::from_str("x-www-form-urlencoded"),
parameters: parameters
}),
None => None
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::<Accept>() {
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<ByteString> {
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<Header> = 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<u64>) {
@ -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::<ContentLength>().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::<SetCookie2>()
#[deriving(Clone)]
struct SetCookie2;
impl Header for SetCookie2 {
fn header_name(_: Option<SetCookie2>) -> &'static str {
"set-cookie2"
}
fn parse_header(_: &[Vec<u8>]) -> Option<SetCookie2> {
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::<SetCookie>();
headers.remove::<SetCookie2>();
// XXXManishearth additional CORS filtering goes here
headers
}
}

2
components/script/lib.rs
View file

@ -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;

65
components/script/parse/html.rs
View file

@ -28,42 +28,59 @@ 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<LastModified>) -> &'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<u8>]) -> Option<LastModified> {
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<TrustedNodeAddress>) -> Temporary<Node>;
@ -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();