diff --git a/Cargo.toml b/Cargo.toml index e8994c2b..3e02adda 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,3 +31,5 @@ git = "https://github.com/carllerche/curl-rust" [dev-dependencies.http] git = "https://github.com/chris-morgan/rust-http" +[dependencies.cookie] +git = "https://github.com/alexcrichton/cookie-rs" diff --git a/src/header/common/cookie.rs b/src/header/common/cookie.rs new file mode 100644 index 00000000..53228131 --- /dev/null +++ b/src/header/common/cookie.rs @@ -0,0 +1,96 @@ +use header::{Header, HeaderFormat}; +use std::fmt::{mod, Show}; +use std::str::from_utf8; +use std::from_str::from_str; + +use cookie::Cookie; +use cookie::CookieJar; + +/// The `Cookie` header. Defined in [RFC6265](tools.ietf.org/html/rfc6265#section-5.4): +/// +/// > If the user agent does attach a Cookie header field to an HTTP +/// > request, the user agent must send the cookie-string +/// > as the value of the header field. +/// +/// > When the user agent generates an HTTP request, the user agent MUST NOT +/// > attach more than one Cookie header field. +#[deriving(Clone, PartialEq, Show)] +pub struct Cookies(pub Vec); + +impl Header for Cookies { + fn header_name(_: Option) -> &'static str { + "Cookie" + } + + fn parse_header(raw: &[Vec]) -> Option { + let mut cookies = Vec::with_capacity(raw.len()); + for cookies_raw in raw.iter() { + match from_utf8(cookies_raw[]) { + Some(cookies_str) => { + for cookie_str in cookies_str.split(';') { + match from_str(cookie_str.trim()) { + Some(cookie) => cookies.push(cookie), + None => return None + } + } + }, + None => return None + }; + } + + if !cookies.is_empty() { + Some(Cookies(cookies)) + } else { + None + } + } +} + +impl HeaderFormat for Cookies { + fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let cookies = &self.0; + let last = cookies.len() - 1; + for (i, cookie) in cookies.iter().enumerate() { + try!(cookie.pair().fmt(fmt)); + if i < last { + try!("; ".fmt(fmt)); + } + } + Ok(()) + } +} + +impl Cookies { + /// This method can be used to create CookieJar that can be used + /// to manipulate cookies and create a corresponding `SetCookie` header afterwards. + pub fn to_cookie_jar(&self, key: &[u8]) -> CookieJar<'static> { + let mut jar = CookieJar::new(key); + for cookie in self.0.iter() { + jar.add_original((*cookie).clone()); + } + jar + } +} + + +#[test] +fn test_parse() { + let h = Header::parse_header([b"foo=bar; baz=quux".to_vec()][]); + let c1 = Cookie::new("foo".to_string(), "bar".to_string()); + let c2 = Cookie::new("baz".to_string(), "quux".to_string()); + assert_eq!(h, Some(Cookies(vec![c1, c2]))); +} + +#[test] +fn test_fmt() { + use header::Headers; + + let mut cookie = Cookie::new("foo".to_string(), "bar".to_string()); + cookie.httponly = true; + cookie.path = Some("/p".to_string()); + let cookies = Cookies(vec![cookie, Cookie::new("baz".to_string(), "quux".to_string())]); + let mut headers = Headers::new(); + headers.set(cookies); + + assert_eq!(headers.to_string()[], "Cookie: foo=bar; baz=quux\r\n"); +} diff --git a/src/header/common/mod.rs b/src/header/common/mod.rs index d177903a..0120a776 100644 --- a/src/header/common/mod.rs +++ b/src/header/common/mod.rs @@ -8,6 +8,7 @@ pub use self::accept::Accept; pub use self::authorization::Authorization; +pub use self::cookie::Cookies; pub use self::connection::Connection; pub use self::content_length::ContentLength; pub use self::content_type::ContentType; @@ -18,6 +19,7 @@ pub use self::transfer_encoding::TransferEncoding; pub use self::upgrade::Upgrade; pub use self::user_agent::UserAgent; pub use self::server::Server; +pub use self::set_cookie::SetCookie; use std::fmt::{mod, Show}; use std::from_str::FromStr; @@ -25,6 +27,11 @@ use std::str::from_utf8; /// Exposes the Accept header. pub mod accept; +/// Exposes the Authorization header. +pub mod authorization; + +/// Exposes the Cookie header. +pub mod cookie; /// Exposes the Connection header. pub mod connection; @@ -41,9 +48,15 @@ pub mod date; /// Exposes the Host header. pub mod host; +/// Exposes the Location header. +pub mod location; + /// Exposes the Server header. pub mod server; +/// Exposes the Set-Cookie header. +pub mod set_cookie; + /// Exposes the TransferEncoding header. pub mod transfer_encoding; @@ -53,12 +66,7 @@ pub mod upgrade; /// Exposes the UserAgent header. pub mod user_agent; - -/// Exposes the Location header. -pub mod location; - -/// Exposes the Authorization header. -pub mod authorization; +pub mod util; fn from_comma_delimited(raw: &[Vec]) -> Option> { if raw.len() != 1 { @@ -86,4 +94,3 @@ fn fmt_comma_delimited(fmt: &mut fmt::Formatter, parts: &[T]) -> fmt::R } Ok(()) } -pub mod util; diff --git a/src/header/common/set_cookie.rs b/src/header/common/set_cookie.rs new file mode 100644 index 00000000..77f18a3e --- /dev/null +++ b/src/header/common/set_cookie.rs @@ -0,0 +1,88 @@ +use header::{Header, HeaderFormat}; +use std::fmt::{mod, Show}; +use std::str::from_utf8; + +use cookie::Cookie; +use cookie::CookieJar; + +/// The `Set-Cookie` header +/// +/// Informally, the Set-Cookie response header contains the header name +/// "Set-Cookie" followed by a ":" and a cookie. Each cookie begins with +/// a name-value-pair, followed by zero or more attribute-value pairs. +#[deriving(Clone, PartialEq, Show)] +pub struct SetCookie(pub Vec); + +impl Header for SetCookie { + fn header_name(_: Option) -> &'static str { + "Set-Cookie" + } + + fn parse_header(raw: &[Vec]) -> Option { + let mut set_cookies = Vec::with_capacity(raw.len()); + for set_cookies_raw in raw.iter() { + match from_utf8(set_cookies_raw[]) { + Some(s) if !s.is_empty() => { + match from_str(s) { + Some(cookie) => set_cookies.push(cookie), + None => () + } + }, + _ => () + }; + } + + if !set_cookies.is_empty() { + Some(SetCookie(set_cookies)) + } else { + None + } + } + +} + +impl HeaderFormat for SetCookie { + + fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result { + for (i, cookie) in self.0.iter().enumerate() { + if i != 0 { + try!(f.write(b"\r\nSet-Cookie: ")); + } + try!(cookie.fmt(f)); + } + Ok(()) + } +} + + +impl SetCookie { + /// Use this to create SetCookie header from CookieJar using + /// calculated delta. + pub fn from_cookie_jar(jar: &CookieJar) -> SetCookie { + SetCookie(jar.delta()) + } +} + + +#[test] +fn test_parse() { + let h = Header::parse_header([b"foo=bar; HttpOnly".to_vec()][]); + let mut c1 = Cookie::new("foo".to_string(), "bar".to_string()); + c1.httponly = true; + + assert_eq!(h, Some(SetCookie(vec![c1]))); +} + +#[test] +fn test_fmt() { + use header::Headers; + + let mut cookie = Cookie::new("foo".to_string(), "bar".to_string()); + cookie.httponly = true; + cookie.path = Some("/p".to_string()); + let cookies = SetCookie(vec![cookie, Cookie::new("baz".to_string(), "quux".to_string())]); + let mut headers = Headers::new(); + headers.set(cookies); + + assert_eq!(headers.to_string()[], "Set-Cookie: foo=bar; HttpOnly; Path=/p\r\nSet-Cookie: baz=quux; Path=/\r\n"); +} diff --git a/src/lib.rs b/src/lib.rs index f174a4b8..3e9c8f47 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -136,6 +136,7 @@ extern crate "unsafe-any" as uany; extern crate "move-acceptor" as macceptor; extern crate intertwine; extern crate typeable; +extern crate cookie; pub use std::io::net::ip::{SocketAddr, IpAddr, Ipv4Addr, Ipv6Addr, Port}; pub use mimewrapper::mime;