136 lines
4.8 KiB
Rust
136 lines
4.8 KiB
Rust
use std::fmt::{self, Display};
|
|
use std::str::FromStr;
|
|
use unicase::UniCase;
|
|
|
|
header! {
|
|
#[doc="`Upgrade` header, defined in [RFC7230](http://tools.ietf.org/html/rfc7230#section-6.7)"]
|
|
#[doc=""]
|
|
#[doc="The `Upgrade` header field is intended to provide a simple mechanism"]
|
|
#[doc="for transitioning from HTTP/1.1 to some other protocol on the same"]
|
|
#[doc="connection. A client MAY send a list of protocols in the Upgrade"]
|
|
#[doc="header field of a request to invite the server to switch to one or"]
|
|
#[doc="more of those protocols, in order of descending preference, before"]
|
|
#[doc="sending the final response. A server MAY ignore a received Upgrade"]
|
|
#[doc="header field if it wishes to continue using the current protocol on"]
|
|
#[doc="that connection. Upgrade cannot be used to insist on a protocol"]
|
|
#[doc="change."]
|
|
#[doc=""]
|
|
#[doc="# ABNF"]
|
|
#[doc="```plain"]
|
|
#[doc="Upgrade = 1#protocol"]
|
|
#[doc=""]
|
|
#[doc="protocol = protocol-name [\"/\" protocol-version]"]
|
|
#[doc="protocol-name = token"]
|
|
#[doc="protocol-version = token"]
|
|
#[doc="```"]
|
|
#[doc=""]
|
|
#[doc="# Example values"]
|
|
#[doc="* `HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11`"]
|
|
(Upgrade, "Upgrade") => (Protocol)+
|
|
|
|
test_upgrade {
|
|
// Testcase from the RFC
|
|
test_header!(
|
|
test1,
|
|
vec![b"HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11"],
|
|
Some(Upgrade(vec![
|
|
Protocol::new(ProtocolName::Http, Some("2.0".to_owned())),
|
|
Protocol::new(ProtocolName::Unregistered("SHTTP".to_owned()), Some("1.3".to_owned())),
|
|
Protocol::new(ProtocolName::Unregistered("IRC".to_owned()), Some("6.9".to_owned())),
|
|
Protocol::new(ProtocolName::Unregistered("RTA".to_owned()), Some("x11".to_owned())),
|
|
])));
|
|
// Own tests
|
|
test_header!(
|
|
test2, vec![b"websocket"],
|
|
Some(Upgrade(vec![Protocol::new(ProtocolName::WebSocket, None)])));
|
|
#[test]
|
|
fn test3() {
|
|
let x: Option<Upgrade> = Header::parse_header(&[b"WEbSOCKet".to_vec()]);
|
|
assert_eq!(x, Some(Upgrade(vec![Protocol::new(ProtocolName::WebSocket, None)])));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A protocol name used to identify a spefic protocol. Names are case-sensitive
|
|
/// except for the `WebSocket` value.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub enum ProtocolName {
|
|
/// `HTTP` value, Hypertext Transfer Protocol
|
|
Http,
|
|
/// `TLS` value, Transport Layer Security [RFC2817](http://tools.ietf.org/html/rfc2817)
|
|
Tls,
|
|
/// `WebSocket` value, matched case insensitively,Web Socket Protocol
|
|
/// [RFC6455](http://tools.ietf.org/html/rfc6455)
|
|
WebSocket,
|
|
/// `h2c` value, HTTP/2 over cleartext TCP
|
|
H2c,
|
|
/// Any other protocol name not known to hyper
|
|
Unregistered(String),
|
|
}
|
|
|
|
impl FromStr for ProtocolName {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<ProtocolName, ()> {
|
|
Ok(match s {
|
|
"HTTP" => ProtocolName::Http,
|
|
"TLS" => ProtocolName::Tls,
|
|
"h2c" => ProtocolName::H2c,
|
|
_ => {
|
|
if UniCase(s) == UniCase("websocket") {
|
|
ProtocolName::WebSocket
|
|
} else {
|
|
ProtocolName::Unregistered(s.to_owned())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Display for ProtocolName {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
f.write_str(match *self {
|
|
ProtocolName::Http => "HTTP",
|
|
ProtocolName::Tls => "TLS",
|
|
ProtocolName::WebSocket => "websocket",
|
|
ProtocolName::H2c => "h2c",
|
|
ProtocolName::Unregistered(ref s) => s,
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Protocols that appear in the `Upgrade` header field
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub struct Protocol {
|
|
/// The protocol identifier
|
|
pub name: ProtocolName,
|
|
/// The optional version of the protocol, often in the format "DIGIT.DIGIT" (e.g.. "1.2")
|
|
pub version: Option<String>,
|
|
}
|
|
|
|
impl Protocol {
|
|
/// Creates a new Protocol with the given name and version
|
|
pub fn new(name: ProtocolName, version: Option<String>) -> Protocol {
|
|
Protocol { name: name, version: version }
|
|
}
|
|
}
|
|
|
|
impl FromStr for Protocol {
|
|
type Err =();
|
|
fn from_str(s: &str) -> Result<Protocol, ()> {
|
|
let mut parts = s.splitn(2, '/');
|
|
Ok(Protocol::new(try!(parts.next().unwrap().parse()), parts.next().map(|x| x.to_owned())))
|
|
}
|
|
}
|
|
|
|
impl Display for Protocol {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
try!(fmt::Display::fmt(&self.name, f));
|
|
if let Some(ref version) = self.version {
|
|
try!(write!(f, "/{}", version));
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
bench_header!(bench, Upgrade, { vec![b"HTTP/2.0, RTA/x11, websocket".to_vec()] });
|