refactor(lib): rename internal http module to proto

src/proto/h1/date.rs

@@ -0,0 +1,59 @@
+use std::cell::RefCell;
+use std::fmt::{self, Write};
+use std::str;
+
+use time::{self, Duration};
+
+// "Sun, 06 Nov 1994 08:49:37 GMT".len()
+pub const DATE_VALUE_LENGTH: usize = 29;
+
+pub fn extend(dst: &mut Vec<u8>) {
+    CACHED.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        let now = time::get_time();
+        if now > cache.next_update {
+            cache.update(now);
+        }
+        dst.extend_from_slice(cache.buffer());
+    })
+}
+
+struct CachedDate {
+    bytes: [u8; DATE_VALUE_LENGTH],
+    pos: usize,
+    next_update: time::Timespec,
+}
+
+thread_local!(static CACHED: RefCell<CachedDate> = RefCell::new(CachedDate {
+    bytes: [0; DATE_VALUE_LENGTH],
+    pos: 0,
+    next_update: time::Timespec::new(0, 0),
+}));
+
+impl CachedDate {
+    fn buffer(&self) -> &[u8] {
+        &self.bytes[..]
+    }
+
+    fn update(&mut self, now: time::Timespec) {
+        self.pos = 0;
+        write!(self, "{}", time::at_utc(now).rfc822()).unwrap();
+        assert!(self.pos == DATE_VALUE_LENGTH);
+        self.next_update = now + Duration::seconds(1);
+        self.next_update.nsec = 0;
+    }
+}
+
+impl fmt::Write for CachedDate {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let len = s.len();
+        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
+        self.pos += len;
+        Ok(())
+    }
+}
+
+#[test]
+fn test_date_len() {
+    assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
+}

src/proto/h1/decode.rs

@@ -0,0 +1,499 @@
+use std::usize;
+use std::io;
+
+use futures::{Async, Poll};
+use bytes::Bytes;
+use proto::io::MemRead;
+
+use self::Kind::{Length, Chunked, Eof};
+
+/// Decoders to handle different Transfer-Encodings.
+///
+/// If a message body does not include a Transfer-Encoding, it *should*
+/// include a Content-Length header.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Decoder {
+    kind: Kind,
+}
+
+impl Decoder {
+    pub fn length(x: u64) -> Decoder {
+        Decoder { kind: Kind::Length(x) }
+    }
+
+    pub fn chunked() -> Decoder {
+        Decoder { kind: Kind::Chunked(ChunkedState::Size, 0) }
+    }
+
+    pub fn eof() -> Decoder {
+        Decoder { kind: Kind::Eof(false) }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum Kind {
+    /// A Reader used when a Content-Length header is passed with a positive integer.
+    Length(u64),
+    /// A Reader used when Transfer-Encoding is `chunked`.
+    Chunked(ChunkedState, u64),
+    /// A Reader used for responses that don't indicate a length or chunked.
+    ///
+    /// Note: This should only used for `Response`s. It is illegal for a
+    /// `Request` to be made with both `Content-Length` and
+    /// `Transfer-Encoding: chunked` missing, as explained from the spec:
+    ///
+    /// > If a Transfer-Encoding header field is present in a response and
+    /// > the chunked transfer coding is not the final encoding, the
+    /// > message body length is determined by reading the connection until
+    /// > it is closed by the server.  If a Transfer-Encoding header field
+    /// > is present in a request and the chunked transfer coding is not
+    /// > the final encoding, the message body length cannot be determined
+    /// > reliably; the server MUST respond with the 400 (Bad Request)
+    /// > status code and then close the connection.
+    Eof(bool),
+}
+
+#[derive(Debug, PartialEq, Clone)]
+enum ChunkedState {
+    Size,
+    SizeLws,
+    Extension,
+    SizeLf,
+    Body,
+    BodyCr,
+    BodyLf,
+    EndCr,
+    EndLf,
+    End,
+}
+
+impl Decoder {
+    pub fn is_eof(&self) -> bool {
+        trace!("is_eof? {:?}", self);
+        match self.kind {
+            Length(0) |
+            Chunked(ChunkedState::End, _) |
+            Eof(true) => true,
+            _ => false,
+        }
+    }
+}
+
+impl Decoder {
+    pub fn decode<R: MemRead>(&mut self, body: &mut R) -> Poll<Bytes, io::Error> {
+        match self.kind {
+            Length(ref mut remaining) => {
+                trace!("Sized read, remaining={:?}", remaining);
+                if *remaining == 0 {
+                    Ok(Async::Ready(Bytes::new()))
+                } else {
+                    let to_read = *remaining as usize;
+                    let buf = try_ready!(body.read_mem(to_read));
+                    let num = buf.as_ref().len() as u64;
+                    trace!("Length read: {}", num);
+                    if num > *remaining {
+                        *remaining = 0;
+                    } else if num == 0 {
+                        return Err(io::Error::new(io::ErrorKind::Other, "early eof"));
+                    } else {
+                        *remaining -= num;
+                    }
+                    Ok(Async::Ready(buf))
+                }
+            }
+            Chunked(ref mut state, ref mut size) => {
+                loop {
+                    let mut buf = None;
+                    // advances the chunked state
+                    *state = try_ready!(state.step(body, size, &mut buf));
+                    if *state == ChunkedState::End {
+                        trace!("end of chunked");
+                        return Ok(Async::Ready(Bytes::new()));
+                    }
+                    if let Some(buf) = buf {
+                        return Ok(Async::Ready(buf));
+                    }
+                }
+            }
+            Eof(ref mut is_eof) => {
+                if *is_eof {
+                    Ok(Async::Ready(Bytes::new()))
+                } else {
+                    // 8192 chosen because its about 2 packets, there probably
+                    // won't be that much available, so don't have MemReaders
+                    // allocate buffers to big
+                    let slice = try_ready!(body.read_mem(8192));
+                    *is_eof = slice.is_empty();
+                    Ok(Async::Ready(slice))
+                }
+            }
+        }
+    }
+}
+
+macro_rules! byte (
+    ($rdr:ident) => ({
+        let buf = try_ready!($rdr.read_mem(1));
+        if !buf.is_empty() {
+            buf[0]
+        } else {
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof,
+                                      "Unexpected eof during chunk size line"));
+        }
+    })
+);
+
+impl ChunkedState {
+    fn step<R: MemRead>(&self,
+                        body: &mut R,
+                        size: &mut u64,
+                        buf: &mut Option<Bytes>)
+                        -> Poll<ChunkedState, io::Error> {
+        use self::ChunkedState::*;
+        match *self {
+            Size => ChunkedState::read_size(body, size),
+            SizeLws => ChunkedState::read_size_lws(body),
+            Extension => ChunkedState::read_extension(body),
+            SizeLf => ChunkedState::read_size_lf(body, size),
+            Body => ChunkedState::read_body(body, size, buf),
+            BodyCr => ChunkedState::read_body_cr(body),
+            BodyLf => ChunkedState::read_body_lf(body),
+            EndCr => ChunkedState::read_end_cr(body),
+            EndLf => ChunkedState::read_end_lf(body),
+            End => Ok(Async::Ready(ChunkedState::End)),
+        }
+    }
+    fn read_size<R: MemRead>(rdr: &mut R, size: &mut u64) -> Poll<ChunkedState, io::Error> {
+        trace!("Read chunk hex size");
+        let radix = 16;
+        match byte!(rdr) {
+            b @ b'0'...b'9' => {
+                *size *= radix;
+                *size += (b - b'0') as u64;
+            }
+            b @ b'a'...b'f' => {
+                *size *= radix;
+                *size += (b + 10 - b'a') as u64;
+            }
+            b @ b'A'...b'F' => {
+                *size *= radix;
+                *size += (b + 10 - b'A') as u64;
+            }
+            b'\t' | b' ' => return Ok(Async::Ready(ChunkedState::SizeLws)),
+            b';' => return Ok(Async::Ready(ChunkedState::Extension)),
+            b'\r' => return Ok(Async::Ready(ChunkedState::SizeLf)),
+            _ => {
+                return Err(io::Error::new(io::ErrorKind::InvalidInput,
+                                          "Invalid chunk size line: Invalid Size"));
+            }
+        }
+        Ok(Async::Ready(ChunkedState::Size))
+    }
+    fn read_size_lws<R: MemRead>(rdr: &mut R) -> Poll<ChunkedState, io::Error> {
+        trace!("read_size_lws");
+        match byte!(rdr) {
+            // LWS can follow the chunk size, but no more digits can come
+            b'\t' | b' ' => Ok(Async::Ready(ChunkedState::SizeLws)),
+            b';' => Ok(Async::Ready(ChunkedState::Extension)),
+            b'\r' => Ok(Async::Ready(ChunkedState::SizeLf)),
+            _ => {
+                Err(io::Error::new(io::ErrorKind::InvalidInput,
+                                   "Invalid chunk size linear white space"))
+            }
+        }
+    }
+    fn read_extension<R: MemRead>(rdr: &mut R) -> Poll<ChunkedState, io::Error> {
+        trace!("read_extension");
+        match byte!(rdr) {
+            b'\r' => Ok(Async::Ready(ChunkedState::SizeLf)),
+            _ => Ok(Async::Ready(ChunkedState::Extension)), // no supported extensions
+        }
+    }
+    fn read_size_lf<R: MemRead>(rdr: &mut R, size: &mut u64) -> Poll<ChunkedState, io::Error> {
+        trace!("Chunk size is {:?}", size);
+        match byte!(rdr) {
+            b'\n' if *size > 0 => Ok(Async::Ready(ChunkedState::Body)),
+            b'\n' if *size == 0 => Ok(Async::Ready(ChunkedState::EndCr)),
+            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk size LF")),
+        }
+    }
+
+    fn read_body<R: MemRead>(rdr: &mut R,
+                          rem: &mut u64,
+                          buf: &mut Option<Bytes>)
+                          -> Poll<ChunkedState, io::Error> {
+        trace!("Chunked read, remaining={:?}", rem);
+
+        // cap remaining bytes at the max capacity of usize
+        let rem_cap = match *rem {
+            r if r > usize::MAX as u64 => usize::MAX,
+            r => r as usize,
+        };
+
+        let to_read = rem_cap;
+        let slice = try_ready!(rdr.read_mem(to_read));
+        let count = slice.len();
+
+        if count == 0 {
+            *rem = 0;
+            return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "early eof"));
+        }
+        *buf = Some(slice);
+        *rem -= count as u64;
+
+        if *rem > 0 {
+            Ok(Async::Ready(ChunkedState::Body))
+        } else {
+            Ok(Async::Ready(ChunkedState::BodyCr))
+        }
+    }
+    fn read_body_cr<R: MemRead>(rdr: &mut R) -> Poll<ChunkedState, io::Error> {
+        match byte!(rdr) {
+            b'\r' => Ok(Async::Ready(ChunkedState::BodyLf)),
+            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk body CR")),
+        }
+    }
+    fn read_body_lf<R: MemRead>(rdr: &mut R) -> Poll<ChunkedState, io::Error> {
+        match byte!(rdr) {
+            b'\n' => Ok(Async::Ready(ChunkedState::Size)),
+            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk body LF")),
+        }
+    }
+
+    fn read_end_cr<R: MemRead>(rdr: &mut R) -> Poll<ChunkedState, io::Error> {
+        match byte!(rdr) {
+            b'\r' => Ok(Async::Ready(ChunkedState::EndLf)),
+            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk end CR")),
+        }
+    }
+    fn read_end_lf<R: MemRead>(rdr: &mut R) -> Poll<ChunkedState, io::Error> {
+        match byte!(rdr) {
+            b'\n' => Ok(Async::Ready(ChunkedState::End)),
+            _ => Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid chunk end LF")),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::error::Error;
+    use std::io;
+    use std::io::Write;
+    use super::Decoder;
+    use super::ChunkedState;
+    use proto::io::MemRead;
+    use futures::{Async, Poll};
+    use bytes::{BytesMut, Bytes};
+    use mock::AsyncIo;
+
+    impl<'a> MemRead for &'a [u8] {
+        fn read_mem(&mut self, len: usize) -> Poll<Bytes, io::Error> {
+            let n = ::std::cmp::min(len, self.len());
+            if n > 0 {
+                let (a, b) = self.split_at(n);
+                let mut buf = BytesMut::from(a);
+                *self = b;
+                Ok(Async::Ready(buf.split_to(n).freeze()))
+            } else {
+                Ok(Async::Ready(Bytes::new()))
+            }
+        }
+    }
+
+    trait HelpUnwrap<T> {
+        fn unwrap(self) -> T;
+    }
+    impl HelpUnwrap<Bytes> for Async<Bytes> {
+        fn unwrap(self) -> Bytes {
+            match self {
+                Async::Ready(bytes) => bytes,
+                Async::NotReady => panic!(),
+            }
+        }
+    }
+    impl HelpUnwrap<ChunkedState> for Async<ChunkedState> {
+        fn unwrap(self) -> ChunkedState {
+            match self {
+                Async::Ready(state) => state,
+                Async::NotReady => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn test_read_chunk_size() {
+        use std::io::ErrorKind::{UnexpectedEof, InvalidInput};
+
+        fn read(s: &str) -> u64 {
+            let mut state = ChunkedState::Size;
+            let rdr = &mut s.as_bytes();
+            let mut size = 0;
+            loop {
+                let result = state.step(rdr, &mut size, &mut None);
+                let desc = format!("read_size failed for {:?}", s);
+                state = result.expect(desc.as_str()).unwrap();
+                if state == ChunkedState::Body || state == ChunkedState::EndCr {
+                    break;
+                }
+            }
+            size
+        }
+
+        fn read_err(s: &str, expected_err: io::ErrorKind) {
+            let mut state = ChunkedState::Size;
+            let rdr = &mut s.as_bytes();
+            let mut size = 0;
+            loop {
+                let result = state.step(rdr, &mut size, &mut None);
+                state = match result {
+                    Ok(s) => s.unwrap(),
+                    Err(e) => {
+                        assert!(expected_err == e.kind(), "Reading {:?}, expected {:?}, but got {:?}",
+                                                          s, expected_err, e.kind());
+                        return;
+                    }
+                };
+                if state == ChunkedState::Body || state == ChunkedState::End {
+                    panic!(format!("Was Ok. Expected Err for {:?}", s));
+                }
+            }
+        }
+
+        assert_eq!(1, read("1\r\n"));
+        assert_eq!(1, read("01\r\n"));
+        assert_eq!(0, read("0\r\n"));
+        assert_eq!(0, read("00\r\n"));
+        assert_eq!(10, read("A\r\n"));
+        assert_eq!(10, read("a\r\n"));
+        assert_eq!(255, read("Ff\r\n"));
+        assert_eq!(255, read("Ff   \r\n"));
+        // Missing LF or CRLF
+        read_err("F\rF", InvalidInput);
+        read_err("F", UnexpectedEof);
+        // Invalid hex digit
+        read_err("X\r\n", InvalidInput);
+        read_err("1X\r\n", InvalidInput);
+        read_err("-\r\n", InvalidInput);
+        read_err("-1\r\n", InvalidInput);
+        // Acceptable (if not fully valid) extensions do not influence the size
+        assert_eq!(1, read("1;extension\r\n"));
+        assert_eq!(10, read("a;ext name=value\r\n"));
+        assert_eq!(1, read("1;extension;extension2\r\n"));
+        assert_eq!(1, read("1;;;  ;\r\n"));
+        assert_eq!(2, read("2; extension...\r\n"));
+        assert_eq!(3, read("3   ; extension=123\r\n"));
+        assert_eq!(3, read("3   ;\r\n"));
+        assert_eq!(3, read("3   ;   \r\n"));
+        // Invalid extensions cause an error
+        read_err("1 invalid extension\r\n", InvalidInput);
+        read_err("1 A\r\n", InvalidInput);
+        read_err("1;no CRLF", UnexpectedEof);
+    }
+
+    #[test]
+    fn test_read_sized_early_eof() {
+        let mut bytes = &b"foo bar"[..];
+        let mut decoder = Decoder::length(10);
+        assert_eq!(decoder.decode(&mut bytes).unwrap().unwrap().len(), 7);
+        let e = decoder.decode(&mut bytes).unwrap_err();
+        assert_eq!(e.kind(), io::ErrorKind::Other);
+        assert_eq!(e.description(), "early eof");
+    }
+
+    #[test]
+    fn test_read_chunked_early_eof() {
+        let mut bytes = &b"\
+            9\r\n\
+            foo bar\
+        "[..];
+        let mut decoder = Decoder::chunked();
+        assert_eq!(decoder.decode(&mut bytes).unwrap().unwrap().len(), 7);
+        let e = decoder.decode(&mut bytes).unwrap_err();
+        assert_eq!(e.kind(), io::ErrorKind::UnexpectedEof);
+        assert_eq!(e.description(), "early eof");
+    }
+
+    #[test]
+    fn test_read_chunked_single_read() {
+        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\n"[..];
+        let buf = Decoder::chunked().decode(&mut mock_buf).expect("decode").unwrap();
+        assert_eq!(16, buf.len());
+        let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
+        assert_eq!("1234567890abcdef", &result);
+    }
+
+    #[test]
+    fn test_read_chunked_after_eof() {
+        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\n\r\n"[..];
+        let mut decoder = Decoder::chunked();
+
+        // normal read
+        let buf = decoder.decode(&mut mock_buf).expect("decode").unwrap();
+        assert_eq!(16, buf.len());
+        let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
+        assert_eq!("1234567890abcdef", &result);
+
+        // eof read
+        let buf = decoder.decode(&mut mock_buf).expect("decode").unwrap();
+        assert_eq!(0, buf.len());
+
+        // ensure read after eof also returns eof
+        let buf = decoder.decode(&mut mock_buf).expect("decode").unwrap();
+        assert_eq!(0, buf.len());
+    }
+
+    // perform an async read using a custom buffer size and causing a blocking
+    // read at the specified byte
+    fn read_async(mut decoder: Decoder,
+                  content: &[u8],
+                  block_at: usize)
+                  -> String {
+        let content_len = content.len();
+        let mut ins = AsyncIo::new(content, block_at);
+        let mut outs = Vec::new();
+        loop {
+            match decoder.decode(&mut ins).expect("unexpected decode error: {}") {
+                Async::Ready(buf) => {
+                    if buf.is_empty() {
+                        break; // eof
+                    }
+                    outs.write(buf.as_ref()).expect("write buffer");
+                },
+                Async::NotReady => {
+                    ins.block_in(content_len); // we only block once
+                }
+            };
+        }
+        String::from_utf8(outs).expect("decode String")
+    }
+
+    // iterate over the different ways that this async read could go.
+    // tests blocking a read at each byte along the content - The shotgun approach
+    fn all_async_cases(content: &str, expected: &str, decoder: Decoder) {
+        let content_len = content.len();
+        for block_at in 0..content_len {
+            let actual = read_async(decoder.clone(), content.as_bytes(), block_at);
+            assert_eq!(expected, &actual) //, "Failed async. Blocking at {}", block_at);
+        }
+    }
+
+    #[test]
+    fn test_read_length_async() {
+        let content = "foobar";
+        all_async_cases(content, content, Decoder::length(content.len() as u64));
+    }
+
+    #[test]
+    fn test_read_chunked_async() {
+        let content = "3\r\nfoo\r\n3\r\nbar\r\n0\r\n\r\n";
+        let expected = "foobar";
+        all_async_cases(content, expected, Decoder::chunked());
+    }
+
+    #[test]
+    fn test_read_eof_async() {
+        let content = "foobar";
+        all_async_cases(content, content, Decoder::eof());
+    }
+
+}

src/proto/h1/encode.rs

@@ -0,0 +1,309 @@
+use std::cmp;
+use std::io::{self, Write};
+
+use proto::io::AtomicWrite;
+
+/// Encoders to handle different Transfer-Encodings.
+#[derive(Debug, Clone)]
+pub struct Encoder {
+    kind: Kind,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+enum Kind {
+    /// An Encoder for when Transfer-Encoding includes `chunked`.
+    Chunked(Chunked),
+    /// An Encoder for when Content-Length is set.
+    ///
+    /// Enforces that the body is not longer than the Content-Length header.
+    Length(u64),
+}
+
+impl Encoder {
+    pub fn chunked() -> Encoder {
+        Encoder {
+            kind: Kind::Chunked(Chunked::Init),
+        }
+    }
+
+    pub fn length(len: u64) -> Encoder {
+        Encoder {
+            kind: Kind::Length(len),
+        }
+    }
+
+    pub fn is_eof(&self) -> bool {
+        match self.kind {
+            Kind::Length(0) |
+            Kind::Chunked(Chunked::End) => true,
+            _ => false
+        }
+    }
+
+    pub fn eof(&self) -> Result<Option<&'static [u8]>, NotEof> {
+        match self.kind {
+            Kind::Length(0) => Ok(None),
+            Kind::Chunked(Chunked::Init) => Ok(Some(b"0\r\n\r\n")),
+            _ => Err(NotEof),
+        }
+    }
+
+    pub fn encode<W: AtomicWrite>(&mut self, w: &mut W, msg: &[u8]) -> io::Result<usize> {
+        match self.kind {
+            Kind::Chunked(ref mut chunked) => {
+                chunked.encode(w, msg)
+            },
+            Kind::Length(ref mut remaining) => {
+                if msg.is_empty() {
+                    return Ok(0);
+                }
+                let n = {
+                    let max = cmp::min(*remaining as usize, msg.len());
+                    trace!("sized write = {}", max);
+                    let slice = &msg[..max];
+
+                    try!(w.write_atomic(&[slice]))
+                };
+
+                if n == 0 {
+                    return Err(io::Error::new(io::ErrorKind::WriteZero, "write zero"));
+                }
+
+                *remaining -= n as u64;
+                trace!("encoded {} bytes, remaining = {}", n, remaining);
+                Ok(n)
+            },
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct NotEof;
+
+#[derive(Debug, PartialEq, Clone)]
+enum Chunked {
+    Init,
+    Size(ChunkSize),
+    SizeCr,
+    SizeLf,
+    Body(usize),
+    BodyCr,
+    BodyLf,
+    End,
+}
+
+impl Chunked {
+    fn encode<W: AtomicWrite>(&mut self, w: &mut W, msg: &[u8]) -> io::Result<usize> {
+        match *self {
+            Chunked::Init => {
+                let mut size = ChunkSize {
+                    bytes: [0; CHUNK_SIZE_MAX_BYTES],
+                    pos: 0,
+                    len: 0,
+                };
+                trace!("chunked write, size = {:?}", msg.len());
+                write!(&mut size, "{:X}", msg.len())
+                    .expect("CHUNK_SIZE_MAX_BYTES should fit any usize");
+                *self = Chunked::Size(size);
+            }
+            Chunked::End => return Ok(0),
+            _ => {}
+        }
+        let mut n = {
+            let pieces = match *self {
+                Chunked::Init => unreachable!("Chunked::Init should have become Chunked::Size"),
+                Chunked::Size(ref size) => [
+                    &size.bytes[size.pos.into() .. size.len.into()],
+                    &b"\r\n"[..],
+                    msg,
+                    &b"\r\n"[..],
+                ],
+                Chunked::SizeCr => [
+                    &b""[..],
+                    &b"\r\n"[..],
+                    msg,
+                    &b"\r\n"[..],
+                ],
+                Chunked::SizeLf => [
+                    &b""[..],
+                    &b"\n"[..],
+                    msg,
+                    &b"\r\n"[..],
+                ],
+                Chunked::Body(pos) => [
+                    &b""[..],
+                    &b""[..],
+                    &msg[pos..],
+                    &b"\r\n"[..],
+                ],
+                Chunked::BodyCr => [
+                    &b""[..],
+                    &b""[..],
+                    &b""[..],
+                    &b"\r\n"[..],
+                ],
+                Chunked::BodyLf => [
+                    &b""[..],
+                    &b""[..],
+                    &b""[..],
+                    &b"\n"[..],
+                ],
+                Chunked::End => unreachable!("Chunked::End shouldn't write more")
+            };
+            try!(w.write_atomic(&pieces))
+        };
+
+        while n > 0 {
+            match *self {
+                Chunked::Init => unreachable!("Chunked::Init should have become Chunked::Size"),
+                Chunked::Size(mut size) => {
+                    n = size.update(n);
+                    if size.len == 0 {
+                        *self = Chunked::SizeCr;
+                    } else {
+                        *self = Chunked::Size(size);
+                    }
+                },
+                Chunked::SizeCr => {
+                    *self = Chunked::SizeLf;
+                    n -= 1;
+                }
+                Chunked::SizeLf => {
+                    *self = Chunked::Body(0);
+                    n -= 1;
+                }
+                Chunked::Body(pos) => {
+                    let left = msg.len() - pos;
+                    if n >= left {
+                        *self = Chunked::BodyCr;
+                        n -= left;
+                    } else {
+                        *self = Chunked::Body(pos + n);
+                        n = 0;
+                    }
+                }
+                Chunked::BodyCr => {
+                    *self = Chunked::BodyLf;
+                    n -= 1;
+                }
+                Chunked::BodyLf => {
+                    assert!(n == 1);
+                    *self = if msg.len() == 0 {
+                        Chunked::End
+                    } else {
+                        Chunked::Init
+                    };
+                    n = 0;
+                },
+                Chunked::End => unreachable!("Chunked::End shouldn't have any to write")
+            }
+        }
+
+        match *self {
+            Chunked::Init |
+            Chunked::End => Ok(msg.len()),
+            _ => Err(io::ErrorKind::WouldBlock.into())
+        }
+    }
+}
+
+#[cfg(target_pointer_width = "32")]
+const USIZE_BYTES: usize = 4;
+
+#[cfg(target_pointer_width = "64")]
+const USIZE_BYTES: usize = 8;
+
+// each byte will become 2 hex
+const CHUNK_SIZE_MAX_BYTES: usize = USIZE_BYTES * 2;
+
+#[derive(Clone, Copy)]
+struct ChunkSize {
+    bytes: [u8; CHUNK_SIZE_MAX_BYTES],
+    pos: u8,
+    len: u8,
+}
+
+impl ChunkSize {
+    fn update(&mut self, n: usize) -> usize {
+        let diff = (self.len - self.pos).into();
+        if n >= diff {
+            self.pos = 0;
+            self.len = 0;
+            n - diff
+        } else {
+            self.pos += n as u8; // just verified it was a small usize
+            0
+        }
+    }
+}
+
+impl ::std::fmt::Debug for ChunkSize {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        f.debug_struct("ChunkSize")
+            .field("bytes", &&self.bytes[..self.len.into()])
+            .field("pos", &self.pos)
+            .finish()
+    }
+}
+
+impl ::std::cmp::PartialEq for ChunkSize {
+    fn eq(&self, other: &ChunkSize) -> bool {
+        self.len == other.len &&
+            self.pos == other.pos &&
+            (&self.bytes[..]) == (&other.bytes[..])
+    }
+}
+
+impl io::Write for ChunkSize {
+    fn write(&mut self, msg: &[u8]) -> io::Result<usize> {
+        let n = (&mut self.bytes[self.len.into() ..]).write(msg)
+            .expect("&mut [u8].write() cannot error");
+        self.len += n as u8; // safe because bytes is never bigger than 256
+        Ok(n)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Encoder;
+    use mock::{AsyncIo, Buf};
+
+    #[test]
+    fn test_chunked_encode_sync() {
+        let mut dst = Buf::new();
+        let mut encoder = Encoder::chunked();
+
+        encoder.encode(&mut dst, b"foo bar").unwrap();
+        encoder.encode(&mut dst, b"baz quux herp").unwrap();
+        encoder.encode(&mut dst, b"").unwrap();
+        assert_eq!(&dst[..], &b"7\r\nfoo bar\r\nD\r\nbaz quux herp\r\n0\r\n\r\n"[..]);
+    }
+
+    #[test]
+    fn test_chunked_encode_async() {
+        let mut dst = AsyncIo::new(Buf::new(), 7);
+        let mut encoder = Encoder::chunked();
+
+        assert!(encoder.encode(&mut dst, b"foo bar").is_err());
+        dst.block_in(6);
+        assert_eq!(7, encoder.encode(&mut dst, b"foo bar").unwrap());
+        dst.block_in(30);
+        assert_eq!(13, encoder.encode(&mut dst, b"baz quux herp").unwrap());
+        encoder.encode(&mut dst, b"").unwrap();
+        assert_eq!(&dst[..], &b"7\r\nfoo bar\r\nD\r\nbaz quux herp\r\n0\r\n\r\n"[..]);
+    }
+
+    #[test]
+    fn test_sized_encode() {
+        let mut dst = Buf::new();
+        let mut encoder = Encoder::length(8);
+        encoder.encode(&mut dst, b"foo bar").unwrap();
+        assert_eq!(encoder.encode(&mut dst, b"baz").unwrap(), 1);
+
+        assert_eq!(dst, b"foo barb");
+    }
+}

src/proto/h1/mod.rs

@@ -0,0 +1,8 @@
+pub use self::decode::Decoder;
+pub use self::encode::Encoder;
+
+mod date;
+mod decode;
+mod encode;
+pub mod parse;
+

src/proto/h1/parse.rs

@@ -0,0 +1,585 @@
+use std::borrow::Cow;
+use std::fmt::{self, Write};
+
+use httparse;
+use bytes::{BytesMut, Bytes};
+
+use header::{self, Headers, ContentLength, TransferEncoding};
+use proto::{MessageHead, RawStatus, Http1Transaction, ParseResult,
+           ServerTransaction, ClientTransaction, RequestLine, RequestHead};
+use proto::h1::{Encoder, Decoder, date};
+use method::Method;
+use status::StatusCode;
+use version::HttpVersion::{Http10, Http11};
+
+const MAX_HEADERS: usize = 100;
+const AVERAGE_HEADER_SIZE: usize = 30; // totally scientific
+
+impl Http1Transaction for ServerTransaction {
+    type Incoming = RequestLine;
+    type Outgoing = StatusCode;
+
+    fn parse(buf: &mut BytesMut) -> ParseResult<RequestLine> {
+        if buf.len() == 0 {
+            return Ok(None);
+        }
+        let mut headers_indices = [HeaderIndices {
+            name: (0, 0),
+            value: (0, 0)
+        }; MAX_HEADERS];
+        let (len, method, path, version, headers_len) = {
+            let mut headers = [httparse::EMPTY_HEADER; MAX_HEADERS];
+            trace!("Request.parse([Header; {}], [u8; {}])", headers.len(), buf.len());
+            let mut req = httparse::Request::new(&mut headers);
+            match try!(req.parse(&buf)) {
+                httparse::Status::Complete(len) => {
+                    trace!("Request.parse Complete({})", len);
+                    let method = try!(req.method.unwrap().parse());
+                    let path = req.path.unwrap();
+                    let bytes_ptr = buf.as_ref().as_ptr() as usize;
+                    let path_start = path.as_ptr() as usize - bytes_ptr;
+                    let path_end = path_start + path.len();
+                    let path = (path_start, path_end);
+                    let version = if req.version.unwrap() == 1 { Http11 } else { Http10 };
+
+                    record_header_indices(buf.as_ref(), &req.headers, &mut headers_indices);
+                    let headers_len = req.headers.len();
+                    (len, method, path, version, headers_len)
+                }
+                httparse::Status::Partial => return Ok(None),
+            }
+        };
+
+        let mut headers = Headers::with_capacity(headers_len);
+        let slice = buf.split_to(len).freeze();
+        let path = slice.slice(path.0, path.1);
+        // path was found to be utf8 by httparse
+        let path = try!(unsafe { ::uri::from_utf8_unchecked(path) });
+        let subject = RequestLine(
+            method,
+            path,
+        );
+
+        headers.extend(HeadersAsBytesIter {
+            headers: headers_indices[..headers_len].iter(),
+            slice: slice,
+        });
+
+        Ok(Some((MessageHead {
+            version: version,
+            subject: subject,
+            headers: headers,
+        }, len)))
+    }
+
+    fn decoder(head: &MessageHead<Self::Incoming>, method: &mut Option<Method>) -> ::Result<Decoder> {
+        use ::header;
+
+        *method = Some(head.subject.0.clone());
+
+        // According to https://tools.ietf.org/html/rfc7230#section-3.3.3
+        // 1. (irrelevant to Request)
+        // 2. (irrelevant to Request)
+        // 3. Transfer-Encoding: chunked has a chunked body.
+        // 4. If multiple differing Content-Length headers or invalid, close connection.
+        // 5. Content-Length header has a sized body.
+        // 6. Length 0.
+        // 7. (irrelevant to Request)
+
+        if let Some(&header::TransferEncoding(ref encodings)) = head.headers.get() {
+            // https://tools.ietf.org/html/rfc7230#section-3.3.3
+            // If Transfer-Encoding header is present, and 'chunked' is
+            // not the final encoding, and this is a Request, then it is
+            // mal-formed. A server should responsed with 400 Bad Request.
+            if encodings.last() == Some(&header::Encoding::Chunked) {
+                Ok(Decoder::chunked())
+            } else {
+                debug!("request with transfer-encoding header, but not chunked, bad request");
+                Err(::Error::Header)
+            }
+        } else if let Some(&header::ContentLength(len)) = head.headers.get() {
+            Ok(Decoder::length(len))
+        } else if head.headers.has::<header::ContentLength>() {
+            debug!("illegal Content-Length: {:?}", head.headers.get_raw("Content-Length"));
+            Err(::Error::Header)
+        } else {
+            Ok(Decoder::length(0))
+        }
+    }
+
+
+    fn encode(mut head: MessageHead<Self::Outgoing>, has_body: bool, method: &mut Option<Method>, dst: &mut Vec<u8>) -> Encoder {
+        trace!("ServerTransaction::encode has_body={}, method={:?}", has_body, method);
+
+        let body = ServerTransaction::set_length(&mut head, has_body, method.as_ref());
+
+        let init_cap = 30 + head.headers.len() * AVERAGE_HEADER_SIZE;
+        dst.reserve(init_cap);
+        if head.version == ::HttpVersion::Http11 && head.subject == ::StatusCode::Ok {
+            extend(dst, b"HTTP/1.1 200 OK\r\n");
+            let _ = write!(FastWrite(dst), "{}", head.headers);
+        } else {
+            let _ = write!(FastWrite(dst), "{} {}\r\n{}", head.version, head.subject, head.headers);
+        }
+        // using http::h1::date is quite a lot faster than generating a unique Date header each time
+        // like req/s goes up about 10%
+        if !head.headers.has::<header::Date>() {
+            dst.reserve(date::DATE_VALUE_LENGTH + 8);
+            extend(dst, b"Date: ");
+            date::extend(dst);
+            extend(dst, b"\r\n");
+        }
+        extend(dst, b"\r\n");
+        body
+    }
+}
+
+impl ServerTransaction {
+    fn set_length(head: &mut MessageHead<StatusCode>, has_body: bool, method: Option<&Method>) -> Encoder {
+        // these are here thanks to borrowck
+        // `if method == Some(&Method::Get)` says the RHS doesnt live long enough
+        const HEAD: Option<&'static Method> = Some(&Method::Head);
+        const CONNECT: Option<&'static Method> = Some(&Method::Connect);
+
+        let can_have_body = {
+            if method == HEAD {
+                false
+            } else if method == CONNECT && head.subject.is_success() {
+                false
+            } else {
+                match head.subject {
+                    // TODO: support for 1xx codes needs improvement everywhere
+                    // would be 100...199 => false
+                    StatusCode::NoContent |
+                    StatusCode::NotModified => false,
+                    _ => true,
+                }
+            }
+        };
+
+        if has_body && can_have_body {
+            set_length(&mut head.headers)
+        } else {
+            head.headers.remove::<TransferEncoding>();
+            if can_have_body {
+                head.headers.set(ContentLength(0));
+            }
+            Encoder::length(0)
+        }
+    }
+}
+
+impl Http1Transaction for ClientTransaction {
+    type Incoming = RawStatus;
+    type Outgoing = RequestLine;
+
+    fn parse(buf: &mut BytesMut) -> ParseResult<RawStatus> {
+        if buf.len() == 0 {
+            return Ok(None);
+        }
+        let mut headers_indices = [HeaderIndices {
+            name: (0, 0),
+            value: (0, 0)
+        }; MAX_HEADERS];
+        let (len, code, reason, version, headers_len) = {
+            let mut headers = [httparse::EMPTY_HEADER; MAX_HEADERS];
+            trace!("Response.parse([Header; {}], [u8; {}])", headers.len(), buf.len());
+            let mut res = httparse::Response::new(&mut headers);
+            let bytes = buf.as_ref();
+            match try!(res.parse(bytes)) {
+                httparse::Status::Complete(len) => {
+                    trace!("Response.parse Complete({})", len);
+                    let code = res.code.unwrap();
+                    let status = try!(StatusCode::try_from(code).map_err(|_| ::Error::Status));
+                    let reason = match status.canonical_reason() {
+                        Some(reason) if reason == res.reason.unwrap() => Cow::Borrowed(reason),
+                        _ => Cow::Owned(res.reason.unwrap().to_owned())
+                    };
+                    let version = if res.version.unwrap() == 1 { Http11 } else { Http10 };
+                    record_header_indices(bytes, &res.headers, &mut headers_indices);
+                    let headers_len = res.headers.len();
+                    (len, code, reason, version, headers_len)
+                },
+                httparse::Status::Partial => return Ok(None),
+            }
+        };
+
+        let mut headers = Headers::with_capacity(headers_len);
+        let slice = buf.split_to(len).freeze();
+        headers.extend(HeadersAsBytesIter {
+            headers: headers_indices[..headers_len].iter(),
+            slice: slice,
+        });
+        Ok(Some((MessageHead {
+            version: version,
+            subject: RawStatus(code, reason),
+            headers: headers,
+        }, len)))
+    }
+
+    fn decoder(inc: &MessageHead<Self::Incoming>, method: &mut Option<Method>) -> ::Result<Decoder> {
+        // According to https://tools.ietf.org/html/rfc7230#section-3.3.3
+        // 1. HEAD responses, and Status 1xx, 204, and 304 cannot have a body.
+        // 2. Status 2xx to a CONNECT cannot have a body.
+        // 3. Transfer-Encoding: chunked has a chunked body.
+        // 4. If multiple differing Content-Length headers or invalid, close connection.
+        // 5. Content-Length header has a sized body.
+        // 6. (irrelevant to Response)
+        // 7. Read till EOF.
+
+        match *method {
+            Some(Method::Head) => {
+                return Ok(Decoder::length(0));
+            }
+            Some(Method::Connect) => match inc.subject.0 {
+                200...299 => {
+                    return Ok(Decoder::length(0));
+                },
+                _ => {},
+            },
+            Some(_) => {},
+            None => {
+                trace!("ClientTransaction::decoder is missing the Method");
+            }
+        }
+
+        match inc.subject.0 {
+            100...199 |
+            204 |
+            304 => return Ok(Decoder::length(0)),
+            _ => (),
+        }
+
+        if let Some(&header::TransferEncoding(ref codings)) = inc.headers.get() {
+            if codings.last() == Some(&header::Encoding::Chunked) {
+                Ok(Decoder::chunked())
+            } else {
+                trace!("not chunked. read till eof");
+                Ok(Decoder::eof())
+            }
+        } else if let Some(&header::ContentLength(len)) = inc.headers.get() {
+            Ok(Decoder::length(len))
+        } else if inc.headers.has::<header::ContentLength>() {
+            debug!("illegal Content-Length: {:?}", inc.headers.get_raw("Content-Length"));
+            Err(::Error::Header)
+        } else {
+            trace!("neither Transfer-Encoding nor Content-Length");
+            Ok(Decoder::eof())
+        }
+    }
+
+    fn encode(mut head: MessageHead<Self::Outgoing>, has_body: bool, method: &mut Option<Method>, dst: &mut Vec<u8>) -> Encoder {
+        trace!("ClientTransaction::encode has_body={}, method={:?}", has_body, method);
+
+        *method = Some(head.subject.0.clone());
+
+        let body = ClientTransaction::set_length(&mut head, has_body);
+
+        let init_cap = 30 + head.headers.len() * AVERAGE_HEADER_SIZE;
+        dst.reserve(init_cap);
+        let _ = write!(FastWrite(dst), "{} {}\r\n{}\r\n", head.subject, head.version, head.headers);
+
+        body
+    }
+}
+
+impl ClientTransaction {
+    fn set_length(head: &mut RequestHead, has_body: bool) -> Encoder {
+        if has_body {
+            set_length(&mut head.headers)
+        } else {
+            head.headers.remove::<ContentLength>();
+            head.headers.remove::<TransferEncoding>();
+            Encoder::length(0)
+        }
+    }
+}
+
+fn set_length(headers: &mut Headers) -> Encoder {
+    let len = headers.get::<header::ContentLength>().map(|n| **n);
+
+    if let Some(len) = len {
+        Encoder::length(len)
+    } else {
+        let encodings = match headers.get_mut::<header::TransferEncoding>() {
+            Some(&mut header::TransferEncoding(ref mut encodings)) => {
+                if encodings.last() != Some(&header::Encoding::Chunked) {
+                    encodings.push(header::Encoding::Chunked);
+                }
+                false
+            },
+            None => true
+        };
+
+        if encodings {
+            headers.set(header::TransferEncoding(vec![header::Encoding::Chunked]));
+        }
+        Encoder::chunked()
+    }
+}
+
+#[derive(Clone, Copy)]
+struct HeaderIndices {
+    name: (usize, usize),
+    value: (usize, usize),
+}
+
+fn record_header_indices(bytes: &[u8], headers: &[httparse::Header], indices: &mut [HeaderIndices]) {
+    let bytes_ptr = bytes.as_ptr() as usize;
+    for (header, indices) in headers.iter().zip(indices.iter_mut()) {
+        let name_start = header.name.as_ptr() as usize - bytes_ptr;
+        let name_end = name_start + header.name.len();
+        indices.name = (name_start, name_end);
+        let value_start = header.value.as_ptr() as usize - bytes_ptr;
+        let value_end = value_start + header.value.len();
+        indices.value = (value_start, value_end);
+    }
+}
+
+struct HeadersAsBytesIter<'a> {
+    headers: ::std::slice::Iter<'a, HeaderIndices>,
+    slice: Bytes,
+}
+
+impl<'a> Iterator for HeadersAsBytesIter<'a> {
+    type Item = (&'a str, Bytes);
+    fn next(&mut self) -> Option<Self::Item> {
+        self.headers.next().map(|header| {
+            let name = unsafe {
+                let bytes = ::std::slice::from_raw_parts(
+                    self.slice.as_ref().as_ptr().offset(header.name.0 as isize),
+                    header.name.1 - header.name.0
+                );
+                ::std::str::from_utf8_unchecked(bytes)
+            };
+            (name, self.slice.slice(header.value.0, header.value.1))
+        })
+    }
+}
+
+struct FastWrite<'a>(&'a mut Vec<u8>);
+
+impl<'a> fmt::Write for FastWrite<'a> {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        extend(self.0, s.as_bytes());
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+        fmt::write(self, args)
+    }
+}
+
+#[inline]
+fn extend(dst: &mut Vec<u8>, data: &[u8]) {
+    dst.extend_from_slice(data);
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::BytesMut;
+
+    use proto::{MessageHead, ServerTransaction, ClientTransaction, Http1Transaction};
+    use header::{ContentLength, TransferEncoding};
+
+    #[test]
+    fn test_parse_request() {
+        extern crate pretty_env_logger;
+        let _ = pretty_env_logger::init();
+        let mut raw = BytesMut::from(b"GET /echo HTTP/1.1\r\nHost: hyper.rs\r\n\r\n".to_vec());
+        let expected_len = raw.len();
+        let (req, len) = ServerTransaction::parse(&mut raw).unwrap().unwrap();
+        assert_eq!(len, expected_len);
+        assert_eq!(req.subject.0, ::Method::Get);
+        assert_eq!(req.subject.1, "/echo");
+        assert_eq!(req.version, ::HttpVersion::Http11);
+        assert_eq!(req.headers.len(), 1);
+        assert_eq!(req.headers.get_raw("Host").map(|raw| &raw[0]), Some(b"hyper.rs".as_ref()));
+    }
+
+
+    #[test]
+    fn test_parse_response() {
+        extern crate pretty_env_logger;
+        let _ = pretty_env_logger::init();
+        let mut raw = BytesMut::from(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n".to_vec());
+        let expected_len = raw.len();
+        let (req, len) = ClientTransaction::parse(&mut raw).unwrap().unwrap();
+        assert_eq!(len, expected_len);
+        assert_eq!(req.subject.0, 200);
+        assert_eq!(req.subject.1, "OK");
+        assert_eq!(req.version, ::HttpVersion::Http11);
+        assert_eq!(req.headers.len(), 1);
+        assert_eq!(req.headers.get_raw("Content-Length").map(|raw| &raw[0]), Some(b"0".as_ref()));
+    }
+
+    #[test]
+    fn test_parse_request_errors() {
+        let mut raw = BytesMut::from(b"GET htt:p// HTTP/1.1\r\nHost: hyper.rs\r\n\r\n".to_vec());
+        ServerTransaction::parse(&mut raw).unwrap_err();
+    }
+
+    #[test]
+    fn test_parse_raw_status() {
+        let mut raw = BytesMut::from(b"HTTP/1.1 200 OK\r\n\r\n".to_vec());
+        let (res, _) = ClientTransaction::parse(&mut raw).unwrap().unwrap();
+        assert_eq!(res.subject.1, "OK");
+
+        let mut raw = BytesMut::from(b"HTTP/1.1 200 Howdy\r\n\r\n".to_vec());
+        let (res, _) = ClientTransaction::parse(&mut raw).unwrap().unwrap();
+        assert_eq!(res.subject.1, "Howdy");
+    }
+
+
+    #[test]
+    fn test_decoder_request() {
+        use super::Decoder;
+
+        let method = &mut None;
+        let mut head = MessageHead::<::proto::RequestLine>::default();
+
+        head.subject.0 = ::Method::Get;
+        assert_eq!(Decoder::length(0), ServerTransaction::decoder(&head, method).unwrap());
+        assert_eq!(*method, Some(::Method::Get));
+
+        head.subject.0 = ::Method::Post;
+        assert_eq!(Decoder::length(0), ServerTransaction::decoder(&head, method).unwrap());
+        assert_eq!(*method, Some(::Method::Post));
+
+        head.headers.set(TransferEncoding::chunked());
+        assert_eq!(Decoder::chunked(), ServerTransaction::decoder(&head, method).unwrap());
+        // transfer-encoding and content-length = chunked
+        head.headers.set(ContentLength(10));
+        assert_eq!(Decoder::chunked(), ServerTransaction::decoder(&head, method).unwrap());
+
+        head.headers.remove::<TransferEncoding>();
+        assert_eq!(Decoder::length(10), ServerTransaction::decoder(&head, method).unwrap());
+
+        head.headers.set_raw("Content-Length", vec![b"5".to_vec(), b"5".to_vec()]);
+        assert_eq!(Decoder::length(5), ServerTransaction::decoder(&head, method).unwrap());
+
+        head.headers.set_raw("Content-Length", vec![b"10".to_vec(), b"11".to_vec()]);
+        ServerTransaction::decoder(&head, method).unwrap_err();
+
+        head.headers.remove::<ContentLength>();
+
+        head.headers.set_raw("Transfer-Encoding", "gzip");
+        ServerTransaction::decoder(&head, method).unwrap_err();
+    }
+
+    #[test]
+    fn test_decoder_response() {
+        use super::Decoder;
+
+        let method = &mut Some(::Method::Get);
+        let mut head = MessageHead::<::proto::RawStatus>::default();
+
+        head.subject.0 = 204;
+        assert_eq!(Decoder::length(0), ClientTransaction::decoder(&head, method).unwrap());
+        head.subject.0 = 304;
+        assert_eq!(Decoder::length(0), ClientTransaction::decoder(&head, method).unwrap());
+
+        head.subject.0 = 200;
+        assert_eq!(Decoder::eof(), ClientTransaction::decoder(&head, method).unwrap());
+
+        *method = Some(::Method::Head);
+        assert_eq!(Decoder::length(0), ClientTransaction::decoder(&head, method).unwrap());
+
+        *method = Some(::Method::Connect);
+        assert_eq!(Decoder::length(0), ClientTransaction::decoder(&head, method).unwrap());
+
+
+        // CONNECT receiving non 200 can have a body
+        head.subject.0 = 404;
+        head.headers.set(ContentLength(10));
+        assert_eq!(Decoder::length(10), ClientTransaction::decoder(&head, method).unwrap());
+        head.headers.remove::<ContentLength>();
+
+
+        *method = Some(::Method::Get);
+        head.headers.set(TransferEncoding::chunked());
+        assert_eq!(Decoder::chunked(), ClientTransaction::decoder(&head, method).unwrap());
+
+        // transfer-encoding and content-length = chunked
+        head.headers.set(ContentLength(10));
+        assert_eq!(Decoder::chunked(), ClientTransaction::decoder(&head, method).unwrap());
+
+        head.headers.remove::<TransferEncoding>();
+        assert_eq!(Decoder::length(10), ClientTransaction::decoder(&head, method).unwrap());
+
+        head.headers.set_raw("Content-Length", vec![b"5".to_vec(), b"5".to_vec()]);
+        assert_eq!(Decoder::length(5), ClientTransaction::decoder(&head, method).unwrap());
+
+        head.headers.set_raw("Content-Length", vec![b"10".to_vec(), b"11".to_vec()]);
+        ClientTransaction::decoder(&head, method).unwrap_err();
+    }
+
+    #[cfg(feature = "nightly")]
+    use test::Bencher;
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_parse_incoming(b: &mut Bencher) {
+        let mut raw = BytesMut::from(
+            b"GET /super_long_uri/and_whatever?what_should_we_talk_about/\
+            I_wonder/Hard_to_write_in_an_uri_after_all/you_have_to_make\
+            _up_the_punctuation_yourself/how_fun_is_that?test=foo&test1=\
+            foo1&test2=foo2&test3=foo3&test4=foo4 HTTP/1.1\r\nHost: \
+            hyper.rs\r\nAccept: a lot of things\r\nAccept-Charset: \
+            utf8\r\nAccept-Encoding: *\r\nAccess-Control-Allow-\
+            Credentials: None\r\nAccess-Control-Allow-Origin: None\r\n\
+            Access-Control-Allow-Methods: None\r\nAccess-Control-Allow-\
+            Headers: None\r\nContent-Encoding: utf8\r\nContent-Security-\
+            Policy: None\r\nContent-Type: text/html\r\nOrigin: hyper\
+            \r\nSec-Websocket-Extensions: It looks super important!\r\n\
+            Sec-Websocket-Origin: hyper\r\nSec-Websocket-Version: 4.3\r\
+            \nStrict-Transport-Security: None\r\nUser-Agent: hyper\r\n\
+            X-Content-Duration: None\r\nX-Content-Security-Policy: None\
+            \r\nX-DNSPrefetch-Control: None\r\nX-Frame-Options: \
+            Something important obviously\r\nX-Requested-With: Nothing\
+            \r\n\r\n".to_vec()
+        );
+        let len = raw.len();
+
+        b.bytes = len as u64;
+        b.iter(|| {
+            ServerTransaction::parse(&mut raw).unwrap();
+            restart(&mut raw, len);
+        });
+
+
+        fn restart(b: &mut BytesMut, len: usize) {
+            b.reserve(1);
+            unsafe {
+                b.set_len(len);
+            }
+        }
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_server_transaction_encode(b: &mut Bencher) {
+        use header::{Headers, ContentLength, ContentType};
+        use ::{StatusCode, HttpVersion};
+
+        let len = 108;
+        b.bytes = len as u64;
+
+        let mut head = MessageHead {
+            subject: StatusCode::Ok,
+            headers: Headers::new(),
+            version: HttpVersion::Http11,
+        };
+        head.headers.set(ContentLength(10));
+        head.headers.set(ContentType::json());
+
+        b.iter(|| {
+            let mut vec = Vec::new();
+            ServerTransaction::encode(head.clone(), true, &mut None, &mut vec);
+            assert_eq!(vec.len(), len);
+            ::test::black_box(vec);
+        })
+    }
+}