update test

Use Vec instead of HashMap to store sockets in HttpServer

.travis.yml

@@ -47,7 +47,7 @@ script:
        USE_SKEPTIC=1 cargo test --features=alpn
     else
        cargo clean
-       cargo test
+       cargo test -- --nocapture
        # --features=alpn
     fi
 
@@ -55,9 +55,11 @@ script:
     if [[ "$TRAVIS_RUST_VERSION" == "stable" ]]; then
       cd examples/basics && cargo check && cd ../..
       cd examples/hello-world && cargo check && cd ../..
+      cd examples/http-proxy && cargo check && cd ../..
       cd examples/multipart && cargo check && cd ../..
       cd examples/json && cargo check && cd ../..
       cd examples/juniper && cargo check && cd ../..
+      cd examples/protobuf && cargo check && cd ../..
       cd examples/state && cargo check && cd ../..
       cd examples/template_tera && cargo check && cd ../..
       cd examples/diesel && cargo check && cd ../..
@@ -65,6 +67,7 @@ script:
       cd examples/tls && cargo check && cd ../..
       cd examples/websocket-chat && cargo check && cd ../..
       cd examples/websocket && cargo check && cd ../..
+      cd examples/unix-socket && cargo check && cd ../..
     fi
   - |
     if [[ "$TRAVIS_RUST_VERSION" == "nightly" && $CLIPPY ]]; then
@@ -75,7 +78,7 @@ script:
 after_success:
   - |
     if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
-      cargo doc --features "alpn, tls" --no-deps &&
+      cargo doc --features "alpn, tls, session" --no-deps &&
       echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
       cargo install mdbook &&
       cd guide && mdbook build -d ../target/doc/guide && cd .. &&

CHANGES.md

@@ -1,5 +1,83 @@
 # Changes
 
+## 0.4.8 (2018-03-12)
+
+* Allow to set read buffer capacity for server request
+
+* Handle WouldBlock error for socket accept call
+
+
+## 0.4.7 (2018-03-11)
+
+* Fix panic on unknown content encoding
+
+* Fix connection get closed too early
+
+* Fix streaming response handling for http/2
+
+* Better sleep on error support
+
+
+## 0.4.6 (2018-03-10)
+
+* Fix client cookie handling
+
+* Fix json content type detection
+
+* Fix CORS middleware #117
+
+* Optimize websockets stream support
+
+
+## 0.4.5 (2018-03-07)
+
+* Fix compression #103 and #104
+
+* Fix client cookie handling #111
+
+* Non-blocking processing of a `NamedFile`
+
+* Enable compression support for `NamedFile`
+
+* Better support for `NamedFile` type
+
+* Add `ResponseError` impl for `SendRequestError`. This improves ergonomics of the client.
+  
+* Add native-tls support for client
+
+* Allow client connection timeout to be set #108
+
+* Allow to use std::net::TcpListener for HttpServer
+
+* Handle panics in worker threads
+
+
+## 0.4.4 (2018-03-04)
+
+* Allow to use Arc<Vec<u8>> as response/request body
+
+* Fix handling of requests with an encoded body with a length > 8192 #93
+
+## 0.4.3 (2018-03-03)
+
+* Fix request body read bug
+
+* Fix segmentation fault #79
+
+* Set reuse address before bind #90
+
+
+## 0.4.2 (2018-03-02)
+
+* Better naming for websockets implementation
+
+* Add `Pattern::with_prefix()`, make it more usable outside of actix
+
+* Add csrf middleware for filter for cross-site request forgery #89
+
+* Fix disconnect on idle connections
+
+
 ## 0.4.1 (2018-03-01)
 
 * Rename `Route::p()` to `Route::filter()`

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "actix-web"
-version = "0.4.1"
+version = "0.4.8"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix web is a small, pragmatic, extremely fast, web framework for Rust."
+description = "Actix web is a simple, pragmatic, extremely fast, web framework for Rust."
 readme = "README.md"
 keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://github.com/actix/actix-web"
@@ -27,7 +27,7 @@ name = "actix_web"
 path = "src/lib.rs"
 
 [features]
-default = []
+default = ["session"]
 
 # tls
 tls = ["native-tls", "tokio-tls"]
@@ -35,7 +35,12 @@ tls = ["native-tls", "tokio-tls"]
 # openssl
 alpn = ["openssl", "openssl/v102", "openssl/v110", "tokio-openssl"]
 
+# sessions
+session = ["cookie/secure"]
+
 [dependencies]
+actix = "^0.5.2"
+
 base64 = "0.9"
 bitflags = "1.0"
 brotli2 = "^0.3.2"
@@ -48,7 +53,7 @@ http-range = "0.1"
 libc = "0.2"
 log = "0.4"
 mime = "0.3"
-mime_guess = "1.8"
+mime_guess = "2.0.0-alpha"
 num_cpus = "1.0"
 percent-encoding = "1.0"
 rand = "0.4"
@@ -59,8 +64,9 @@ sha1 = "0.6"
 smallvec = "0.6"
 time = "0.1"
 encoding = "0.2"
+language-tags = "0.2"
 url = { version="1.7", features=["query_encoding"] }
-cookie = { version="0.10", features=["percent-encode", "secure"] }
+cookie = { version="0.10", features=["percent-encode"] }
 
 # io
 mio = "^0.6.13"
@@ -68,6 +74,7 @@ net2 = "0.2"
 bytes = "0.4"
 byteorder = "1"
 futures = "0.1"
+futures-cpupool = "0.1"
 tokio-io = "0.1"
 tokio-core = "0.1"
 trust-dns-resolver = "0.8"
@@ -80,9 +87,6 @@ tokio-tls = { version="0.1", optional = true }
 openssl = { version="0.10", optional = true }
 tokio-openssl = { version="0.2", optional = true }
 
-[dependencies.actix]
-version = "0.5"
-
 [dev-dependencies]
 env_logger = "0.5"
 skeptic = "0.13"
@@ -105,7 +109,9 @@ members = [
   "examples/diesel",
   "examples/r2d2",
   "examples/json",
+  "examples/protobuf",
   "examples/hello-world",
+  "examples/http-proxy",
   "examples/multipart",
   "examples/state",
   "examples/redis-session",
@@ -114,5 +120,6 @@ members = [
   "examples/websocket",
   "examples/websocket-chat",
   "examples/web-cors/backend",
+  "examples/unix-socket",
   "tools/wsload/",
 ]

README.md

@@ -1,6 +1,6 @@
 # Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](http://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Actix web is a small, pragmatic, extremely fast, web framework for Rust.
+Actix web is a simple, pragmatic, extremely fast, web framework for Rust.
 
 * Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.github.io/actix-web/guide/qs_13.html) protocols
 * Streaming and pipelining
@@ -10,12 +10,14 @@ Actix web is a small, pragmatic, extremely fast, web framework for Rust.
 * Configurable [request routing](https://actix.github.io/actix-web/guide/qs_5.html)
 * Graceful server shutdown
 * Multipart streams
+* Static assets
 * SSL support with openssl or native-tls
 * Middlewares ([Logger](https://actix.github.io/actix-web/guide/qs_10.html#logging),
   [Session](https://actix.github.io/actix-web/guide/qs_10.html#user-sessions),
   [Redis sessions](https://github.com/actix/actix-redis),
   [DefaultHeaders](https://actix.github.io/actix-web/guide/qs_10.html#default-headers),
-  [CORS](https://actix.github.io/actix-web/actix_web/middleware/cors/index.html))
+  [CORS](https://actix.github.io/actix-web/actix_web/middleware/cors/index.html),
+  [CSRF](https://actix.github.io/actix-web/actix_web/middleware/csrf/index.html))
 * Built on top of [Actix actor framework](https://github.com/actix/actix).
 
 ## Documentation
@@ -29,7 +31,7 @@ Actix web is a small, pragmatic, extremely fast, web framework for Rust.
 
 ## Example
 
-```rust,ignore
+```rust
 extern crate actix_web;
 use actix_web::*;
 
@@ -50,13 +52,13 @@ fn main() {
 
 * [Basics](https://github.com/actix/actix-web/tree/master/examples/basics/)
 * [Stateful](https://github.com/actix/actix-web/tree/master/examples/state/)
+* [Protobuf support](https://github.com/actix/actix-web/tree/master/examples/protobuf/)
 * [Multipart streams](https://github.com/actix/actix-web/tree/master/examples/multipart/)
 * [Simple websocket session](https://github.com/actix/actix-web/tree/master/examples/websocket/)
 * [Tera templates](https://github.com/actix/actix-web/tree/master/examples/template_tera/)
 * [Diesel integration](https://github.com/actix/actix-web/tree/master/examples/diesel/)
 * [SSL / HTTP/2.0](https://github.com/actix/actix-web/tree/master/examples/tls/)
 * [Tcp/Websocket chat](https://github.com/actix/actix-web/tree/master/examples/websocket-chat/)
-* [SockJS Server](https://github.com/actix/actix-sockjs)
 * [Json](https://github.com/actix/actix-web/tree/master/examples/json/)
 
 You may consider checking out

build.rs

@@ -6,12 +6,13 @@ use std::{env, fs};
 
 #[cfg(unix)]
 fn main() {
+    println!("cargo:rerun-if-env-changed=USE_SKEPTIC");
     let f = env::var("OUT_DIR").unwrap() + "/skeptic-tests.rs";
     if env::var("USE_SKEPTIC").is_ok() {
         let _ = fs::remove_file(f);
         // generates doc tests for `README.md`.
         skeptic::generate_doc_tests(
-            &["README.md",
+            &[// "README.md",
               "guide/src/qs_1.md",
               "guide/src/qs_2.md",
               "guide/src/qs_3.md",

examples/basics/src/main.rs

@@ -139,7 +139,7 @@ fn main() {
             // default
             .default_resource(|r| {
                 r.method(Method::GET).f(p404);
-                r.route().p(pred::Not(pred::Get())).f(|req| httpcodes::HTTPMethodNotAllowed);
+                r.route().filter(pred::Not(pred::Get())).f(|req| httpcodes::HTTPMethodNotAllowed);
             }))
 
         .bind("127.0.0.1:8080").expect("Can not bind to 127.0.0.1:8080")

examples/diesel/src/main.rs

@@ -1,8 +1,8 @@
 //! Actix web diesel example
 //!
 //! Diesel does not support tokio, so we have to run it in separate threads.
-//! Actix supports sync actors by default, so we going to create sync actor that will
-//! use diesel. Technically sync actors are worker style actors, multiple of them
+//! Actix supports sync actors by default, so we going to create sync actor that use diesel.
+//! Technically sync actors are worker style actors, multiple of them
 //! can run in parallel and process messages from same queue.
 extern crate serde;
 extern crate serde_json;
@@ -38,6 +38,7 @@ struct State {
 fn index(req: HttpRequest<State>) -> Box<Future<Item=HttpResponse, Error=Error>> {
     let name = &req.match_info()["name"];
 
+    // send async `CreateUser` message to a `DbExecutor`
     req.state().db.send(CreateUser{name: name.to_owned()})
         .from_err()
         .and_then(|res| {
@@ -54,7 +55,7 @@ fn main() {
     let _ = env_logger::init();
     let sys = actix::System::new("diesel-example");
 
-    // Start db executor actors
+    // Start 3 db executor actors
     let addr = SyncArbiter::start(3, || {
         DbExecutor(SqliteConnection::establish("test.db").unwrap())
     });

examples/http-proxy/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "http-proxy"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+workspace = "../.."
+
+[dependencies]
+env_logger = "0.5"
+futures = "0.1"
+actix = "0.5"
+actix-web = { path = "../../", features=["alpn"] }

examples/http-proxy/src/main.rs

@@ -0,0 +1,59 @@
+extern crate actix;
+extern crate actix_web;
+extern crate futures;
+extern crate env_logger;
+
+use actix_web::*;
+use futures::{Future, Stream};
+
+
+/// Stream client request response and then send body to a server response
+fn index(_req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    client::ClientRequest::get("https://www.rust-lang.org/en-US/")
+        .finish().unwrap()
+        .send()
+        .map_err(error::Error::from)   // <- convert SendRequestError to an Error
+        .and_then(
+            |resp| resp.body()         // <- this is MessageBody type, resolves to complete body
+                .from_err()            // <- convet PayloadError to a Error
+                .and_then(|body| {     // <- we got complete body, now send as server response
+                    httpcodes::HttpOk.build()
+                        .body(body)
+                        .map_err(error::Error::from)
+                }))
+        .responder()
+}
+
+/// streaming client request to a streaming server response
+fn streaming(_req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    // send client request
+    client::ClientRequest::get("https://www.rust-lang.org/en-US/")
+        .finish().unwrap()
+        .send()                         // <- connect to host and send request
+        .map_err(error::Error::from)    // <- convert SendRequestError to an Error
+        .and_then(|resp| {              // <- we received client response
+            httpcodes::HttpOk.build()
+                // read one chunk from client response and send this chunk to a server response
+                // .from_err() converts PayloadError to a Error
+                .body(Body::Streaming(Box::new(resp.from_err())))
+                .map_err(|e| e.into()) // HttpOk::build() mayb return HttpError, we need to convert it to a Error
+        })
+        .responder()
+}
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+    let sys = actix::System::new("http-proxy");
+
+    let _addr = HttpServer::new(
+        || Application::new()
+            .middleware(middleware::Logger::default())
+            .resource("/streaming", |r| r.f(streaming))
+            .resource("/", |r| r.f(index)))
+        .bind("127.0.0.1:8080").unwrap()
+        .start();
+
+    println!("Started http server: 127.0.0.1:8080");
+    let _ = sys.run();
+}

examples/protobuf/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "protobuf-example"
+version = "0.1.0"
+authors = ["kingxsp <jin_hb_zh@126.com>"]
+
+[dependencies]
+bytes = "0.4"
+futures = "0.1"
+failure = "0.1"
+env_logger = "*"
+
+prost = "0.2.0"
+prost-derive = "0.2.0"
+
+actix = "0.5"
+actix-web = { path="../../" }

examples/protobuf/client.py

@@ -0,0 +1,66 @@
+# just start server and run client.py
+
+# wget https://github.com/google/protobuf/releases/download/v3.5.1/protobuf-python-3.5.1.zip
+# unzip protobuf-python-3.5.1.zip.1
+# cd protobuf-3.5.1/python/
+# python3.6 setup.py install
+
+# pip3.6 install --upgrade pip
+# pip3.6 install aiohttp
+
+#!/usr/bin/env python
+import test_pb2
+import traceback
+import sys
+
+import asyncio
+import aiohttp
+
+def op():
+    try:
+        obj = test_pb2.MyObj()
+        obj.number = 9
+        obj.name = 'USB'
+
+        #Serialize
+        sendDataStr = obj.SerializeToString()
+        #print serialized string value
+        print('serialized string:', sendDataStr)
+        #------------------------#
+        #  message transmission  #
+        #------------------------#
+        receiveDataStr = sendDataStr
+        receiveData = test_pb2.MyObj()
+
+        #Deserialize
+        receiveData.ParseFromString(receiveDataStr)
+        print('pares serialize string, return: devId = ', receiveData.number, ', name = ', receiveData.name)
+    except(Exception, e):
+        print(Exception, ':', e)
+        print(traceback.print_exc())
+        errInfo = sys.exc_info()
+        print(errInfo[0], ':', errInfo[1])
+
+
+async def fetch(session):
+    obj = test_pb2.MyObj()
+    obj.number = 9
+    obj.name = 'USB'
+    async with session.post('http://localhost:8080/', data=obj.SerializeToString(),
+        headers={"content-type": "application/protobuf"}) as resp:
+        print(resp.status)
+        data = await resp.read()
+        receiveObj = test_pb2.MyObj()
+        receiveObj.ParseFromString(data)
+        print(receiveObj)
+
+async def go(loop):
+    obj = test_pb2.MyObj()
+    obj.number = 9
+    obj.name = 'USB'
+    async with aiohttp.ClientSession(loop=loop) as session:
+        await fetch(session)
+
+loop = asyncio.get_event_loop()
+loop.run_until_complete(go(loop))
+loop.close()

examples/protobuf/src/main.rs

@@ -0,0 +1,55 @@
+extern crate actix;
+extern crate actix_web;
+extern crate bytes;
+extern crate futures;
+#[macro_use]
+extern crate failure;
+extern crate env_logger;
+extern crate prost;
+#[macro_use]
+extern crate prost_derive;
+
+use actix_web::*;
+use futures::Future;
+
+mod protobuf;
+use protobuf::ProtoBufResponseBuilder;
+
+
+#[derive(Clone, Debug, PartialEq, Message)]
+pub struct MyObj {
+    #[prost(int32, tag="1")]
+    pub number: i32,
+    #[prost(string, tag="2")]
+    pub name: String,
+}
+
+
+/// This handler uses `ProtoBufMessage` for loading protobuf object.
+fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    protobuf::ProtoBufMessage::new(req)
+        .from_err()  // convert all errors into `Error`
+        .and_then(|val: MyObj| {
+            println!("model: {:?}", val);
+            Ok(httpcodes::HTTPOk.build().protobuf(val)?)  // <- send response
+        })
+        .responder()
+}
+
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    let _ = env_logger::init();
+    let sys = actix::System::new("protobuf-example");
+
+    let addr = HttpServer::new(|| {
+        Application::new()
+            .middleware(middleware::Logger::default())
+            .resource("/", |r| r.method(Method::POST).f(index))})
+        .bind("127.0.0.1:8080").unwrap()
+        .shutdown_timeout(1)
+        .start();
+
+    println!("Started http server: 127.0.0.1:8080");
+    let _ = sys.run();
+}

examples/protobuf/src/protobuf.rs

@@ -0,0 +1,169 @@
+use bytes::{Bytes, BytesMut};
+use futures::{Poll, Future, Stream};
+
+use bytes::IntoBuf;
+use prost::Message;
+use prost::DecodeError as ProtoBufDecodeError;
+use prost::EncodeError as ProtoBufEncodeError;
+
+use actix_web::header::http::{CONTENT_TYPE, CONTENT_LENGTH};
+use actix_web::{Responder, HttpMessage, HttpRequest, HttpResponse};
+use actix_web::dev::HttpResponseBuilder;
+use actix_web::error::{Error, PayloadError, ResponseError};
+use actix_web::httpcodes::{HttpBadRequest, HttpPayloadTooLarge};
+
+
+#[derive(Fail, Debug)]
+pub enum ProtoBufPayloadError {
+    /// Payload size is bigger than 256k
+    #[fail(display="Payload size is bigger than 256k")]
+    Overflow,
+    /// Content type error
+    #[fail(display="Content type error")]
+    ContentType,
+    /// Serialize error
+    #[fail(display="ProtoBud serialize error: {}", _0)]
+    Serialize(#[cause] ProtoBufEncodeError),
+    /// Deserialize error
+    #[fail(display="ProtoBud deserialize error: {}", _0)]
+    Deserialize(#[cause] ProtoBufDecodeError),
+    /// Payload error
+    #[fail(display="Error that occur during reading payload: {}", _0)]
+    Payload(#[cause] PayloadError),
+}
+
+impl ResponseError for ProtoBufPayloadError {
+
+    fn error_response(&self) -> HttpResponse {
+        match *self {
+            ProtoBufPayloadError::Overflow => HttpPayloadTooLarge.into(),
+            _ => HttpBadRequest.into(),
+        }
+    }
+}
+
+impl From<PayloadError> for ProtoBufPayloadError {
+    fn from(err: PayloadError) -> ProtoBufPayloadError {
+        ProtoBufPayloadError::Payload(err)
+    }
+}
+
+impl From<ProtoBufDecodeError> for ProtoBufPayloadError {
+    fn from(err: ProtoBufDecodeError) -> ProtoBufPayloadError {
+        ProtoBufPayloadError::Deserialize(err)
+    }
+}
+
+#[derive(Debug)]
+pub struct ProtoBuf<T: Message>(pub T);
+
+impl<T: Message> Responder for ProtoBuf<T> {
+    type Item = HttpResponse;
+    type Error = Error;
+
+    fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, Error> {
+        let mut buf = Vec::new();
+        self.0.encode(&mut buf)
+            .map_err(|e| Error::from(ProtoBufPayloadError::Serialize(e)))
+            .and_then(|()| {
+                Ok(HttpResponse::Ok()
+                   .content_type("application/protobuf")
+                    .body(buf)
+                    .into())
+              })
+    }
+}
+
+pub struct ProtoBufMessage<T, U: Message + Default>{
+    limit: usize,
+    ct: &'static str,
+    req: Option<T>,
+    fut: Option<Box<Future<Item=U, Error=ProtoBufPayloadError>>>,
+}
+
+impl<T, U: Message + Default> ProtoBufMessage<T, U> {
+
+    /// Create `ProtoBufMessage` for request.
+    pub fn new(req: T) -> Self {
+        ProtoBufMessage{
+            limit: 262_144,
+            req: Some(req),
+            fut: None,
+            ct: "application/protobuf",
+        }
+    }
+
+    /// Change max size of payload. By default max size is 256Kb
+    pub fn limit(mut self, limit: usize) -> Self {
+        self.limit = limit;
+        self
+    }
+
+    /// Set allowed content type.
+    ///
+    /// By default *application/protobuf* content type is used. Set content type
+    /// to empty string if you want to disable content type check.
+    pub fn content_type(mut self, ct: &'static str) -> Self {
+        self.ct = ct;
+        self
+    }
+}
+
+impl<T, U: Message + Default + 'static> Future for ProtoBufMessage<T, U>
+    where T: HttpMessage + Stream<Item=Bytes, Error=PayloadError> + 'static
+{
+    type Item = U;
+    type Error = ProtoBufPayloadError;
+
+    fn poll(&mut self) -> Poll<U, ProtoBufPayloadError> {
+        if let Some(req) = self.req.take() {
+            if let Some(len) = req.headers().get(CONTENT_LENGTH) {
+                if let Ok(s) = len.to_str() {
+                    if let Ok(len) = s.parse::<usize>() {
+                        if len > self.limit {
+                            return Err(ProtoBufPayloadError::Overflow);
+                        }
+                    } else {
+                        return Err(ProtoBufPayloadError::Overflow);
+                    }
+                }
+            }
+            // check content-type
+            if !self.ct.is_empty() && req.content_type() != self.ct {
+                return Err(ProtoBufPayloadError::ContentType)
+            }
+
+            let limit = self.limit;
+            let fut = req.from_err()
+                .fold(BytesMut::new(), move |mut body, chunk| {
+                    if (body.len() + chunk.len()) > limit {
+                        Err(ProtoBufPayloadError::Overflow)
+                    } else {
+                        body.extend_from_slice(&chunk);
+                        Ok(body)
+                    }
+                })
+                .and_then(|body| Ok(<U>::decode(&mut body.into_buf())?));
+            self.fut = Some(Box::new(fut));
+        }
+
+        self.fut.as_mut().expect("ProtoBufBody could not be used second time").poll()
+    }
+}
+
+
+pub trait ProtoBufResponseBuilder {
+
+    fn protobuf<T: Message>(&mut self, value: T) -> Result<HttpResponse, Error>;
+}
+
+impl ProtoBufResponseBuilder for HttpResponseBuilder {
+
+    fn protobuf<T: Message>(&mut self, value: T) -> Result<HttpResponse, Error> {
+        self.header(CONTENT_TYPE, "application/protobuf");
+
+        let mut body = Vec::new();
+        value.encode(&mut body).map_err(|e| ProtoBufPayloadError::Serialize(e))?;
+        Ok(self.body(body)?)
+    }
+}

examples/protobuf/test.proto

@@ -0,0 +1,6 @@
+syntax = "proto3";
+
+message MyObj {
+    int32 number = 1;
+    string name = 2;
+}

examples/protobuf/test_pb2.py

@@ -0,0 +1,76 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: test.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='test.proto',
+  package='',
+  syntax='proto3',
+  serialized_pb=_b('\n\ntest.proto\"%\n\x05MyObj\x12\x0e\n\x06number\x18\x01 \x01(\x05\x12\x0c\n\x04name\x18\x02 \x01(\tb\x06proto3')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+
+
+
+_MYOBJ = _descriptor.Descriptor(
+  name='MyObj',
+  full_name='MyObj',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='number', full_name='MyObj.number', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+    _descriptor.FieldDescriptor(
+      name='name', full_name='MyObj.name', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      options=None),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=14,
+  serialized_end=51,
+)
+
+DESCRIPTOR.message_types_by_name['MyObj'] = _MYOBJ
+
+MyObj = _reflection.GeneratedProtocolMessageType('MyObj', (_message.Message,), dict(
+  DESCRIPTOR = _MYOBJ,
+  __module__ = 'test_pb2'
+  # @@protoc_insertion_point(class_scope:MyObj)
+  ))
+_sym_db.RegisterMessage(MyObj)
+
+
+# @@protoc_insertion_point(module_scope)

examples/state/src/main.rs

@@ -36,7 +36,7 @@ impl Actor for MyWebSocket {
     type Context = ws::WebsocketContext<Self, AppState>;
 }
 
-impl StreamHandler<ws::Message, ws::WsError> for MyWebSocket {
+impl StreamHandler<ws::Message, ws::ProtocolError> for MyWebSocket {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         self.counter += 1;

examples/unix-socket/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "unix-socket"
+version = "0.1.0"
+authors = ["Messense Lv <messense@icloud.com>"]
+
+[dependencies]
+env_logger = "0.5"
+actix = "0.5"
+actix-web = { path = "../../" }
+tokio-uds = "0.1"

examples/unix-socket/README.md

@@ -0,0 +1,14 @@
+## Unix domain socket example
+
+```bash
+$ curl --unix-socket /tmp/actix-uds.socket http://localhost/
+Hello world!
+```
+
+Although this will only one thread for handling incoming connections 
+according to the 
+[documentation](https://actix.github.io/actix-web/actix_web/struct.HttpServer.html#method.start_incoming).
+
+And it does not delete the socket file (`/tmp/actix-uds.socket`) when stopping
+the server so it will fail to start next time you run it unless you delete
+the socket file manually.

examples/unix-socket/src/main.rs

@@ -0,0 +1,31 @@
+extern crate actix;
+extern crate actix_web;
+extern crate env_logger;
+extern crate tokio_uds;
+
+use actix::*;
+use actix_web::*;
+use tokio_uds::UnixListener;
+
+
+fn index(_req: HttpRequest) -> &'static str {
+    "Hello world!"
+}
+
+fn main() {
+    ::std::env::set_var("RUST_LOG", "actix_web=info");
+    let _ = env_logger::init();
+    let sys = actix::System::new("unix-socket");
+
+    let listener = UnixListener::bind("/tmp/actix-uds.socket", Arbiter::handle()).expect("bind failed");
+    let _addr = HttpServer::new(
+        || Application::new()
+            // enable logger
+            .middleware(middleware::Logger::default())
+            .resource("/index.html", |r| r.f(|_| "Hello world!"))
+            .resource("/", |r| r.f(index)))
+        .start_incoming(listener.incoming(), false);
+
+    println!("Started http server: /tmp/actix-uds.socket");
+    let _ = sys.run();
+}

examples/websocket-chat/src/main.rs

@@ -92,7 +92,7 @@ impl Handler<session::Message> for WsChatSession {
 }
 
 /// WebSocket message handler
-impl StreamHandler<ws::Message, ws::WsError> for WsChatSession {
+impl StreamHandler<ws::Message, ws::ProtocolError> for WsChatSession {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         println!("WEBSOCKET MESSAGE: {:?}", msg);

examples/websocket/src/client.rs

@@ -12,7 +12,7 @@ use std::time::Duration;
 
 use actix::*;
 use futures::Future;
-use actix_web::ws::{Message, WsError, WsClient, WsClientWriter};
+use actix_web::ws::{Message, ProtocolError, Client, ClientWriter};
 
 
 fn main() {
@@ -21,7 +21,7 @@ fn main() {
     let sys = actix::System::new("ws-example");
 
     Arbiter::handle().spawn(
-        WsClient::new("http://127.0.0.1:8080/ws/")
+        Client::new("http://127.0.0.1:8080/ws/")
             .connect()
             .map_err(|e| {
                 println!("Error: {}", e);
@@ -53,7 +53,7 @@ fn main() {
 }
 
 
-struct ChatClient(WsClientWriter);
+struct ChatClient(ClientWriter);
 
 #[derive(Message)]
 struct ClientCommand(String);
@@ -88,12 +88,12 @@ impl Handler<ClientCommand> for ChatClient {
     type Result = ();
 
     fn handle(&mut self, msg: ClientCommand, ctx: &mut Context<Self>) {
-        self.0.text(msg.0.as_str())
+        self.0.text(msg.0)
     }
 }
 
 /// Handle server websocket messages
-impl StreamHandler<Message, WsError> for ChatClient {
+impl StreamHandler<Message, ProtocolError> for ChatClient {
 
     fn handle(&mut self, msg: Message, ctx: &mut Context<Self>) {
         match msg {

examples/websocket/src/main.rs

@@ -25,7 +25,7 @@ impl Actor for MyWebSocket {
 }
 
 /// Handler for `ws::Message`
-impl StreamHandler<ws::Message, ws::WsError> for MyWebSocket {
+impl StreamHandler<ws::Message, ws::ProtocolError> for MyWebSocket {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         // process websocket messages

guide/src/qs_14.md

@@ -12,7 +12,7 @@ We have to define sync actor and connection that this actor will use. Same appro
 could be used for other databases.
 
 ```rust,ignore
-use actix::prelude::*;*
+use actix::prelude::*;
 
 struct DbExecutor(SqliteConnection);
 
@@ -24,11 +24,13 @@ impl Actor for DbExecutor {
 This is definition of our actor. Now we need to define *create user* message and response.
 
 ```rust,ignore
-#[derive(Message)]
-#[rtype(User, Error)]
 struct CreateUser {
     name: String,
 }
+
+impl Message for CreateUser {
+    type Result = Result<User, Error>;
+}
 ```
 
 We can send `CreateUser` message to `DbExecutor` actor, and as result we get
@@ -36,7 +38,7 @@ We can send `CreateUser` message to `DbExecutor` actor, and as result we get
 
 ```rust,ignore
 impl Handler<CreateUser> for DbExecutor {
-    type Result = Result<User, Error>
+    type Result = Result<User, Error>;
 
     fn handle(&mut self, msg: CreateUser, _: &mut Self::Context) -> Self::Result
     {

guide/src/qs_3_5.md

@@ -134,9 +134,10 @@ for full example.
 Actix can wait for requests on a keep-alive connection. *Keep alive*
 connection behavior is defined by server settings.
 
- * `Some(75)` - enable 75 sec *keep alive* timer according request and response settings.
- * `Some(0)` - disable *keep alive*.
- * `None` - Use `SO_KEEPALIVE` socket option.
+ * `75` or `Some(75)` or `KeepAlive::Timeout(75)` - enable 75 sec *keep alive* timer according
+    request and response settings.
+ * `None` or `KeepAlive::Disabled` - disable *keep alive*.
+ * `KeepAlive::Tcp(75)` - Use `SO_KEEPALIVE` socket option.
 
 ```rust
 # extern crate actix_web;
@@ -147,7 +148,17 @@ fn main() {
     HttpServer::new(||
         Application::new()
             .resource("/", |r| r.h(httpcodes::HttpOk)))
-        .keep_alive(None); // <- Use `SO_KEEPALIVE` socket option.
+        .keep_alive(75); // <- Set keep-alive to 75 seconds
+
+    HttpServer::new(||
+        Application::new()
+            .resource("/", |r| r.h(httpcodes::HttpOk)))
+        .keep_alive(server::KeepAlive::Tcp(75)); // <- Use `SO_KEEPALIVE` socket option.
+
+    HttpServer::new(||
+        Application::new()
+            .resource("/", |r| r.h(httpcodes::HttpOk)))
+        .keep_alive(None); // <- Disable keep-alive
 }
 ```
 

guide/src/qs_4.md

@@ -235,6 +235,44 @@ fn main() {
 
 Both methods could be combined. (i.e Async response with streaming body)
 
+## Different return types (Either)
+
+Sometimes you need to return different types of responses. For example
+you can do error check and return error and return async response otherwise.
+Or any result that requires two different types.
+For this case [*Either*](../actix_web/enum.Either.html) type can be used.
+*Either* allows to combine two different responder types into a single type.
+
+```rust
+# extern crate actix_web;
+# extern crate futures;
+# use actix_web::*;
+# use futures::future::Future;
+use futures::future::result;
+use actix_web::{Either, Error, HttpResponse, httpcodes};
+
+type RegisterResult = Either<HttpResponse, Box<Future<Item=HttpResponse, Error=Error>>>;
+
+fn index(req: HttpRequest) -> RegisterResult {
+    if is_a_variant() { // <- choose variant A
+        Either::A(
+            httpcodes::HttpBadRequest.with_body("Bad data"))
+    } else {
+        Either::B(      // <- variant B
+            result(HttpResponse::Ok()
+                   .content_type("text/html")
+                   .body(format!("Hello!"))
+                   .map_err(|e| e.into())).responder())
+    }
+}
+# fn is_a_variant() -> bool { true }
+# fn main() {
+#    Application::new()
+#        .resource("/register", |r| r.f(index))
+#        .finish();
+# }
+```
+
 ## Tokio core handle
 
 Any actix web handler runs within properly configured

guide/src/qs_9.md

@@ -22,7 +22,7 @@ impl Actor for Ws {
 }
 
 /// Handler for ws::Message message
-impl StreamHandler<ws::Message, ws::WsError> for Ws {
+impl StreamHandler<ws::Message, ws::ProtocolError> for Ws {
 
     fn handle(&mut self, msg: ws::Message, ctx: &mut Self::Context) {
         match msg {

src/application.rs

@@ -44,8 +44,9 @@ impl<S: 'static> PipelineHandler<S> for Inner<S> {
             for &mut (ref prefix, ref mut handler) in &mut self.handlers {
                 let m = {
                     let path = &req.path()[self.prefix..];
-                    path.starts_with(prefix) && (path.len() == prefix.len() ||
-                                                 path.split_at(prefix.len()).1.starts_with('/'))
+                    path.starts_with(prefix) && (
+                        path.len() == prefix.len() ||
+                            path.split_at(prefix.len()).1.starts_with('/'))
                 };
                 if m {
                     let path: &'static str = unsafe {

src/body.rs

@@ -36,6 +36,8 @@ pub enum Binary {
     /// Shared string body
     #[doc(hidden)]
     ArcSharedString(Arc<String>),
+    /// Shared vec body
+    SharedVec(Arc<Vec<u8>>),
 }
 
 impl Body {
@@ -115,6 +117,7 @@ impl Binary {
             Binary::Slice(slice) => slice.len(),
             Binary::SharedString(ref s) => s.len(),
             Binary::ArcSharedString(ref s) => s.len(),
+            Binary::SharedVec(ref s) => s.len(),
         }
     }
 
@@ -134,8 +137,9 @@ impl Clone for Binary {
         match *self {
             Binary::Bytes(ref bytes) => Binary::Bytes(bytes.clone()),
             Binary::Slice(slice) => Binary::Bytes(Bytes::from(slice)),
-            Binary::SharedString(ref s) => Binary::Bytes(Bytes::from(s.as_str())),
-            Binary::ArcSharedString(ref s) => Binary::Bytes(Bytes::from(s.as_str())),
+            Binary::SharedString(ref s) => Binary::SharedString(s.clone()),
+            Binary::ArcSharedString(ref s) => Binary::ArcSharedString(s.clone()),
+            Binary::SharedVec(ref s) => Binary::SharedVec(s.clone()),
         }
     }
 }
@@ -147,6 +151,7 @@ impl Into<Bytes> for Binary {
             Binary::Slice(slice) => Bytes::from(slice),
             Binary::SharedString(s) => Bytes::from(s.as_str()),
             Binary::ArcSharedString(s) => Bytes::from(s.as_str()),
+            Binary::SharedVec(s) => Bytes::from(AsRef::<[u8]>::as_ref(s.as_ref())),
         }
     }
 }
@@ -217,6 +222,18 @@ impl<'a> From<&'a Arc<String>> for Binary {
     }
 }
 
+impl From<Arc<Vec<u8>>> for Binary {
+    fn from(body: Arc<Vec<u8>>) -> Binary {
+        Binary::SharedVec(body)
+    }
+}
+
+impl<'a> From<&'a Arc<Vec<u8>>> for Binary {
+    fn from(body: &'a Arc<Vec<u8>>) -> Binary {
+        Binary::SharedVec(Arc::clone(body))
+    }
+}
+
 impl AsRef<[u8]> for Binary {
     fn as_ref(&self) -> &[u8] {
         match *self {
@@ -224,6 +241,7 @@ impl AsRef<[u8]> for Binary {
             Binary::Slice(slice) => slice,
             Binary::SharedString(ref s) => s.as_bytes(),
             Binary::ArcSharedString(ref s) => s.as_bytes(),
+            Binary::SharedVec(ref s) => s.as_ref().as_ref(),
         }
     }
 }
@@ -304,6 +322,15 @@ mod tests {
         assert_eq!(Binary::from(&b).as_ref(), "test".as_bytes());
     }
 
+    #[test]
+    fn test_shared_vec() {
+        let b = Arc::new(Vec::from(&b"test"[..]));
+        assert_eq!(Binary::from(b.clone()).len(), 4);
+        assert_eq!(Binary::from(b.clone()).as_ref(), &b"test"[..]);
+        assert_eq!(Binary::from(&b).len(), 4);
+        assert_eq!(Binary::from(&b).as_ref(), &b"test"[..]);
+    }
+
     #[test]
     fn test_bytes_mut() {
         let b =  BytesMut::from("test");

src/client/connector.rs

@@ -1,5 +1,6 @@
 use std::{io, time};
 use std::net::Shutdown;
+use std::time::Duration;
 
 use actix::{fut, Actor, ActorFuture, Context,
             Handler, Message, ActorResponse, Supervised};
@@ -18,19 +19,32 @@ use tokio_openssl::SslConnectorExt;
 #[cfg(feature="alpn")]
 use futures::Future;
 
-use HAS_OPENSSL;
+#[cfg(all(feature="tls", not(feature="alpn")))]
+use native_tls::{TlsConnector, Error as TlsError};
+#[cfg(all(feature="tls", not(feature="alpn")))]
+use tokio_tls::TlsConnectorExt;
+#[cfg(all(feature="tls", not(feature="alpn")))]
+use futures::Future;
+
+use {HAS_OPENSSL, HAS_TLS};
 use server::IoStream;
 
 
 #[derive(Debug)]
 /// `Connect` type represents message that can be send to `ClientConnector`
 /// with connection request.
-pub struct Connect(pub Uri);
+pub struct Connect {
+    pub uri: Uri,
+    pub conn_timeout: Duration,
+}
 
 impl Connect {
     /// Create `Connect` message for specified `Uri`
     pub fn new<U>(uri: U) -> Result<Connect, HttpError> where Uri: HttpTryFrom<U> {
-        Ok(Connect(Uri::try_from(uri).map_err(|e| e.into())?))
+        Ok(Connect {
+            uri: Uri::try_from(uri).map_err(|e| e.into())?,
+            conn_timeout: Duration::from_secs(1)
+        })
     }
 }
 
@@ -54,11 +68,16 @@ pub enum ClientConnectorError {
     #[fail(display="{}", _0)]
     SslError(#[cause] OpensslError),
 
+    /// SSL error
+    #[cfg(all(feature="tls", not(feature="alpn")))]
+    #[fail(display="{}", _0)]
+    SslError(#[cause] TlsError),
+
     /// Connection error
     #[fail(display = "{}", _0)]
     Connector(#[cause] ConnectorError),
 
-    /// Connecting took too long
+    /// Connection took too long
     #[fail(display = "Timeout out while establishing connection")]
     Timeout,
 
@@ -73,13 +92,18 @@ pub enum ClientConnectorError {
 
 impl From<ConnectorError> for ClientConnectorError {
     fn from(err: ConnectorError) -> ClientConnectorError {
-        ClientConnectorError::Connector(err)
+        match err {
+            ConnectorError::Timeout => ClientConnectorError::Timeout,
+            _ => ClientConnectorError::Connector(err)
+        }
     }
 }
 
 pub struct ClientConnector {
-    #[cfg(feature="alpn")]
+    #[cfg(all(feature="alpn"))]
     connector: SslConnector,
+    #[cfg(all(feature="tls", not(feature="alpn")))]
+    connector: TlsConnector,
 }
 
 impl Actor for ClientConnector {
@@ -92,15 +116,22 @@ impl ArbiterService for ClientConnector {}
 
 impl Default for ClientConnector {
     fn default() -> ClientConnector {
-        #[cfg(feature="alpn")]
+        #[cfg(all(feature="alpn"))]
         {
             let builder = SslConnector::builder(SslMethod::tls()).unwrap();
             ClientConnector {
                 connector: builder.build()
             }
         }
+        #[cfg(all(feature="tls", not(feature="alpn")))]
+        {
+            let builder = TlsConnector::builder().unwrap();
+            ClientConnector {
+                connector: builder.build().unwrap()
+            }
+        }
 
-        #[cfg(not(feature="alpn"))]
+        #[cfg(not(any(feature="alpn", feature="tls")))]
         ClientConnector {}
     }
 }
@@ -159,7 +190,8 @@ impl Handler<Connect> for ClientConnector {
     type Result = ActorResponse<ClientConnector, Connection, ClientConnectorError>;
 
     fn handle(&mut self, msg: Connect, _: &mut Self::Context) -> Self::Result {
-        let uri = &msg.0;
+        let uri = &msg.uri;
+        let conn_timeout = msg.conn_timeout;
 
         // host name is required
         if uri.host().is_none() {
@@ -176,7 +208,7 @@ impl Handler<Connect> for ClientConnector {
         };
 
         // check ssl availability
-        if proto.is_secure() && !HAS_OPENSSL { //&& !HAS_TLS {
+        if proto.is_secure() && !HAS_OPENSSL && !HAS_TLS {
             return ActorResponse::reply(Err(ClientConnectorError::SslIsNotSupported))
         }
 
@@ -185,7 +217,8 @@ impl Handler<Connect> for ClientConnector {
 
         ActorResponse::async(
             Connector::from_registry()
-                .send(ResolveConnect::host_and_port(&host, port))
+                .send(ResolveConnect::host_and_port(&host, port)
+                      .timeout(conn_timeout))
                 .into_actor(self)
                 .map_err(|_, _, _| ClientConnectorError::Disconnected)
                 .and_then(move |res, _act, _| {
@@ -205,7 +238,23 @@ impl Handler<Connect> for ClientConnector {
                         }
                     }
 
-                    #[cfg(not(feature="alpn"))]
+                    #[cfg(all(feature="tls", not(feature="alpn")))]
+                    match res {
+                        Err(err) => fut::Either::B(fut::err(err.into())),
+                        Ok(stream) => {
+                            if proto.is_secure() {
+                                fut::Either::A(
+                                    _act.connector.connect_async(&host, stream)
+                                        .map_err(ClientConnectorError::SslError)
+                                        .map(|stream| Connection{stream: Box::new(stream)})
+                                        .into_actor(_act))
+                            } else {
+                                fut::Either::B(fut::ok(Connection{stream: Box::new(stream)}))
+                            }
+                        }
+                    }
+
+                    #[cfg(not(any(feature="alpn", feature="tls")))]
                     match res {
                         Err(err) => fut::err(err.into()),
                         Ok(stream) => {

src/client/mod.rs

@@ -12,3 +12,20 @@ pub use self::response::ClientResponse;
 pub use self::connector::{Connect, Connection, ClientConnector, ClientConnectorError};
 pub(crate) use self::writer::HttpClientWriter;
 pub(crate) use self::parser::{HttpResponseParser, HttpResponseParserError};
+
+
+use httpcodes;
+use httpresponse::HttpResponse;
+use error::ResponseError;
+
+
+/// Convert `SendRequestError` to a `HttpResponse`
+impl ResponseError for SendRequestError {
+
+    fn error_response(&self) -> HttpResponse {
+        match *self {
+            SendRequestError::Connector(_) => httpcodes::HttpBadGateway.into(),
+            _ => httpcodes::HttpInternalServerError.into(),
+        }
+    }
+}

src/client/parser.rs

@@ -2,7 +2,7 @@ use std::mem;
 use httparse;
 use http::{Version, HttpTryFrom, HeaderMap, StatusCode};
 use http::header::{self, HeaderName, HeaderValue};
-use bytes::{Bytes, BytesMut, BufMut};
+use bytes::{Bytes, BytesMut};
 use futures::{Poll, Async};
 
 use error::{ParseError, PayloadError};
@@ -37,25 +37,22 @@ impl HttpResponseParser {
         where T: IoStream
     {
         // if buf is empty parse_message will always return NotReady, let's avoid that
-        let read = if buf.is_empty() {
+        if buf.is_empty() {
             match utils::read_from_io(io, buf) {
-                Ok(Async::Ready(0)) => {
-                    // debug!("Ignored premature client disconnection");
-                    return Err(HttpResponseParserError::Disconnect);
-                },
+                Ok(Async::Ready(0)) =>
+                    return Err(HttpResponseParserError::Disconnect),
                 Ok(Async::Ready(_)) => (),
                 Ok(Async::NotReady) =>
                     return Ok(Async::NotReady),
                 Err(err) =>
                     return Err(HttpResponseParserError::Error(err.into()))
             }
-            false
-        } else {
-            true
-        };
+        }
 
         loop {
-            match HttpResponseParser::parse_message(buf).map_err(HttpResponseParserError::Error)? {
+            match HttpResponseParser::parse_message(buf)
+                .map_err(HttpResponseParserError::Error)?
+            {
                 Async::Ready((msg, decoder)) => {
                     self.decoder = decoder;
                     return Ok(Async::Ready(msg));
@@ -64,15 +61,13 @@ impl HttpResponseParser {
                     if buf.capacity() >= MAX_BUFFER_SIZE {
                         return Err(HttpResponseParserError::Error(ParseError::TooLarge));
                     }
-                    if read || buf.remaining_mut() == 0 {
-                        match utils::read_from_io(io, buf) {
-                            Ok(Async::Ready(0)) => return Err(HttpResponseParserError::Disconnect),
-                            Ok(Async::Ready(_)) => (),
-                            Ok(Async::NotReady) => return Ok(Async::NotReady),
-                            Err(err) => return Err(HttpResponseParserError::Error(err.into())),
-                        }
-                    } else {
-                        return Ok(Async::NotReady)
+                    match utils::read_from_io(io, buf) {
+                        Ok(Async::Ready(0)) =>
+                            return Err(HttpResponseParserError::Disconnect),
+                        Ok(Async::Ready(_)) => (),
+                        Ok(Async::NotReady) => return Ok(Async::NotReady),
+                        Err(err) =>
+                            return Err(HttpResponseParserError::Error(err.into())),
                     }
                 },
             }
@@ -84,32 +79,42 @@ impl HttpResponseParser {
         where T: IoStream
     {
         if self.decoder.is_some() {
-            // read payload
-            match utils::read_from_io(io, buf) {
-                Ok(Async::Ready(0)) => {
-                    if buf.is_empty() {
-                        return Err(PayloadError::Incomplete)
+            loop {
+                // read payload
+                let not_ready = match utils::read_from_io(io, buf) {
+                    Ok(Async::Ready(0)) => {
+                        if buf.is_empty() {
+                            return Err(PayloadError::Incomplete)
+                        }
+                        true
                     }
-                }
-                Err(err) => return Err(err.into()),
-                _ => (),
-            }
+                    Err(err) => return Err(err.into()),
+                    Ok(Async::NotReady) => true,
+                    _ => false,
+                };
 
-            match self.decoder.as_mut().unwrap().decode(buf) {
-                Ok(Async::Ready(Some(b))) => Ok(Async::Ready(Some(b))),
-                Ok(Async::Ready(None)) => {
-                    self.decoder.take();
-                    Ok(Async::Ready(None))
+                match self.decoder.as_mut().unwrap().decode(buf) {
+                    Ok(Async::Ready(Some(b))) =>
+                        return Ok(Async::Ready(Some(b))),
+                    Ok(Async::Ready(None)) => {
+                        self.decoder.take();
+                        return Ok(Async::Ready(None))
+                    }
+                    Ok(Async::NotReady) => {
+                        if not_ready {
+                            return Ok(Async::NotReady)
+                        }
+                    }
+                    Err(err) => return Err(err.into()),
                 }
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-                Err(err) => Err(err.into()),
             }
         } else {
             Ok(Async::Ready(None))
         }
     }
 
-    fn parse_message(buf: &mut BytesMut) -> Poll<(ClientResponse, Option<Decoder>), ParseError>
+    fn parse_message(buf: &mut BytesMut)
+                     -> Poll<(ClientResponse, Option<Decoder>), ParseError>
     {
         // Parse http message
         let bytes_ptr = buf.as_ref().as_ptr() as usize;

src/client/pipeline.rs

@@ -1,8 +1,10 @@
 use std::{io, mem};
+use std::time::Duration;
 use bytes::{Bytes, BytesMut};
 use http::header::CONTENT_ENCODING;
 use futures::{Async, Future, Poll};
 use futures::unsync::oneshot;
+use tokio_core::reactor::Timeout;
 
 use actix::prelude::*;
 
@@ -23,6 +25,9 @@ use super::{HttpResponseParser, HttpResponseParserError};
 /// A set of errors that can occur during sending request and reading response
 #[derive(Fail, Debug)]
 pub enum SendRequestError {
+    /// Response took too long
+    #[fail(display = "Timeout out while waiting for response")]
+    Timeout,
     /// Failed to connect to host
     #[fail(display="Failed to connect to host: {}", _0)]
     Connector(#[cause] ClientConnectorError),
@@ -40,6 +45,15 @@ impl From<io::Error> for SendRequestError {
     }
 }
 
+impl From<ClientConnectorError> for SendRequestError {
+    fn from(err: ClientConnectorError) -> SendRequestError {
+        match err {
+            ClientConnectorError::Timeout => SendRequestError::Timeout,
+            _ => SendRequestError::Connector(err),
+        }
+    }
+}
+
 enum State {
     New,
     Connect(actix::dev::Request<Unsync, ClientConnector, Connect>),
@@ -54,6 +68,8 @@ pub struct SendRequest {
     req: ClientRequest,
     state: State,
     conn: Addr<Unsync, ClientConnector>,
+    conn_timeout: Duration,
+    timeout: Option<Timeout>,
 }
 
 impl SendRequest {
@@ -64,15 +80,53 @@ impl SendRequest {
     pub(crate) fn with_connector(req: ClientRequest, conn: Addr<Unsync, ClientConnector>)
                                  -> SendRequest
     {
-        SendRequest{req, conn, state: State::New}
+        SendRequest{req, conn,
+                    state: State::New,
+                    timeout: None,
+                    conn_timeout: Duration::from_secs(1)
+        }
     }
 
     pub(crate) fn with_connection(req: ClientRequest, conn: Connection) -> SendRequest
     {
-        SendRequest{
-            req,
-            state: State::Connection(conn),
-            conn: ClientConnector::from_registry()}
+        SendRequest{req,
+                    state: State::Connection(conn),
+                    conn: ClientConnector::from_registry(),
+                    timeout: None,
+                    conn_timeout: Duration::from_secs(1),
+        }
+    }
+
+    /// Set request timeout
+    ///
+    /// Request timeout is a total time before response should be received.
+    /// Default value is 5 seconds.
+    pub fn timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(Timeout::new(timeout, Arbiter::handle()).unwrap());
+        self
+    }
+
+    /// Set connection timeout
+    ///
+    /// Connection timeout includes resolving hostname and actual connection to
+    /// the host.
+    /// Default value is 1 second.
+    pub fn conn_timeout(mut self, timeout: Duration) -> Self {
+        self.conn_timeout = timeout;
+        self
+    }
+
+    fn poll_timeout(&mut self) -> Poll<(), SendRequestError> {
+        if self.timeout.is_none() {
+            self.timeout = Some(Timeout::new(
+                Duration::from_secs(5), Arbiter::handle()).unwrap());
+        }
+
+        match self.timeout.as_mut().unwrap().poll() {
+            Ok(Async::Ready(())) => Err(SendRequestError::Timeout),
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Err(_) => unreachable!()
+        }
     }
 }
 
@@ -81,12 +135,17 @@ impl Future for SendRequest {
     type Error = SendRequestError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        self.poll_timeout()?;
+
         loop {
             let state = mem::replace(&mut self.state, State::None);
 
             match state {
                 State::New =>
-                    self.state = State::Connect(self.conn.send(Connect(self.req.uri().clone()))),
+                    self.state = State::Connect(self.conn.send(Connect {
+                        uri: self.req.uri().clone(),
+                        conn_timeout: self.conn_timeout,
+                    })),
                 State::Connect(mut conn) => match conn.poll() {
                     Ok(Async::NotReady) => {
                         self.state = State::Connect(conn);
@@ -96,7 +155,7 @@ impl Future for SendRequest {
                         Ok(stream) => {
                             self.state = State::Connection(stream)
                         },
-                        Err(err) => return Err(SendRequestError::Connector(err)),
+                        Err(err) => return Err(err.into()),
                     },
                     Err(_) => return Err(SendRequestError::Connector(
                         ClientConnectorError::Disconnected))
@@ -111,7 +170,7 @@ impl Future for SendRequest {
                         _ => IoBody::Done,
                     };
 
-                    let mut pl = Box::new(Pipeline {
+                    let pl = Box::new(Pipeline {
                         body, conn, writer,
                         parser: Some(HttpResponseParser::default()),
                         parser_buf: BytesMut::new(),

src/client/request.rs

@@ -1,4 +1,5 @@
 use std::{fmt, mem};
+use std::fmt::Write as FmtWrite;
 use std::io::Write;
 
 use actix::{Addr, Unsync};
@@ -8,10 +9,11 @@ use http::{uri, HeaderMap, Method, Version, Uri, HttpTryFrom, Error as HttpError
 use http::header::{self, HeaderName, HeaderValue};
 use serde_json;
 use serde::Serialize;
+use percent_encoding::{USERINFO_ENCODE_SET, percent_encode};
 
 use body::Body;
 use error::Error;
-use headers::ContentEncoding;
+use header::{ContentEncoding, Header, IntoHeaderValue};
 use super::pipeline::SendRequest;
 use super::connector::{Connection, ClientConnector};
 
@@ -26,9 +28,8 @@ pub struct ClientRequest {
     upgrade: bool,
     encoding: ContentEncoding,
     response_decompress: bool,
-    buffer_capacity: Option<(usize, usize)>,
+    buffer_capacity: usize,
     conn: ConnectionType,
-
 }
 
 enum ConnectionType {
@@ -50,7 +51,7 @@ impl Default for ClientRequest {
             upgrade: false,
             encoding: ContentEncoding::Auto,
             response_decompress: true,
-            buffer_capacity: None,
+            buffer_capacity: 32_768,
             conn: ConnectionType::Default,
         }
     }
@@ -102,7 +103,7 @@ impl ClientRequest {
             request: Some(ClientRequest::default()),
             err: None,
             cookies: None,
-            default_headers: true,
+            default_headers: true
         }
     }
 
@@ -178,7 +179,8 @@ impl ClientRequest {
         self.response_decompress
     }
 
-    pub fn buffer_capacity(&self) -> Option<(usize, usize)> {
+    /// Requested write buffer capacity
+    pub fn write_buffer_capacity(&self) -> usize {
         self.buffer_capacity
     }
     
@@ -215,13 +217,8 @@ impl fmt::Debug for ClientRequest {
         let res = write!(f, "\nClientRequest {:?} {}:{}\n",
                          self.version, self.method, self.uri);
         let _ = write!(f, "  headers:\n");
-        for key in self.headers.keys() {
-            let vals: Vec<_> = self.headers.get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        for (key, val) in self.headers.iter() {
+            let _ = write!(f, "    {:?}: {:?}\n", key, val);
         }
         res
     }
@@ -236,7 +233,7 @@ pub struct ClientRequestBuilder {
     request: Option<ClientRequest>,
     err: Option<HttpError>,
     cookies: Option<CookieJar>,
-    default_headers: bool,
+    default_headers: bool
 }
 
 impl ClientRequestBuilder {
@@ -267,6 +264,14 @@ impl ClientRequestBuilder {
         self
     }
 
+    /// Set HTTP method of this request.
+    #[inline]
+    pub fn get_method(&mut self) -> &Method {
+        let parts = parts(&mut self.request, &self.err)
+            .expect("cannot reuse request builder");
+        &parts.method
+    }
+
     /// Set HTTP version of this request.
     ///
     /// By default requests's http version depends on network stream
@@ -278,7 +283,37 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// Add a header.
+    /// Set a header.
+    ///
+    /// ```rust
+    /// # extern crate mime;
+    /// # extern crate actix_web;
+    /// # use actix_web::*;
+    /// # use actix_web::httpcodes::*;
+    /// # use actix_web::client::*;
+    /// #
+    /// use actix_web::header;
+    ///
+    /// fn main() {
+    ///     let req = ClientRequest::build()
+    ///         .set(header::Date::now())
+    ///         .set(header::ContentType(mime::TEXT_HTML))
+    ///         .finish().unwrap();
+    /// }
+    /// ```
+    #[doc(hidden)]
+    pub fn set<H: Header>(&mut self, hdr: H) -> &mut Self
+    {
+        if let Some(parts) = parts(&mut self.request, &self.err) {
+            match hdr.try_into() {
+                Ok(value) => { parts.headers.insert(H::name(), value); }
+                Err(e) => self.err = Some(e.into()),
+            }
+        }
+        self
+    }
+
+    /// Append a header.
     ///
     /// Header get appended to existing header.
     /// To override header use `set_header()` method.
@@ -298,12 +333,12 @@ impl ClientRequestBuilder {
     /// }
     /// ```
     pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
-        where HeaderName: HttpTryFrom<K>, HeaderValue: HttpTryFrom<V>
+        where HeaderName: HttpTryFrom<K>, V: IntoHeaderValue
     {
         if let Some(parts) = parts(&mut self.request, &self.err) {
             match HeaderName::try_from(key) {
                 Ok(key) => {
-                    match HeaderValue::try_from(value) {
+                    match value.try_into() {
                         Ok(value) => { parts.headers.append(key, value); }
                         Err(e) => self.err = Some(e.into()),
                     }
@@ -314,14 +349,14 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// Replace a header.
+    /// Set a header.
     pub fn set_header<K, V>(&mut self, key: K, value: V) -> &mut Self
-        where HeaderName: HttpTryFrom<K>, HeaderValue: HttpTryFrom<V>
+        where HeaderName: HttpTryFrom<K>, V: IntoHeaderValue
     {
         if let Some(parts) = parts(&mut self.request, &self.err) {
             match HeaderName::try_from(key) {
                 Ok(key) => {
-                    match HeaderValue::try_from(value) {
+                    match value.try_into() {
                         Ok(value) => { parts.headers.insert(key, value); }
                         Err(e) => self.err = Some(e.into()),
                     }
@@ -416,20 +451,6 @@ impl ClientRequestBuilder {
         self
     }
 
-    /// Remove cookie, cookie has to be cookie from `HttpRequest::cookies()` method.
-    pub fn del_cookie<'a>(&mut self, cookie: &Cookie<'a>) -> &mut Self {
-        {
-            if self.cookies.is_none() {
-                self.cookies = Some(CookieJar::new())
-            }
-            let jar = self.cookies.as_mut().unwrap();
-            let cookie = cookie.clone().into_owned();
-            jar.add_original(cookie.clone());
-            jar.remove(cookie);
-        }
-        self
-    }
-
     /// Do not add default request headers.
     /// By default `Accept-Encoding` header is set.
     pub fn no_default_headers(&mut self) -> &mut Self {
@@ -446,12 +467,11 @@ impl ClientRequestBuilder {
     }
 
     /// Set write buffer capacity
-    pub fn buffer_capacity(&mut self,
-                           low_watermark: usize,
-                           high_watermark: usize) -> &mut Self
-    {
+    ///
+    /// Default buffer capacity is 32kb
+    pub fn write_buffer_capacity(&mut self, cap: usize) -> &mut Self {
         if let Some(parts) = parts(&mut self.request, &self.err) {
-            parts.buffer_capacity = Some((low_watermark, high_watermark));
+            parts.buffer_capacity = cap;
         }
         self
     }
@@ -520,12 +540,15 @@ impl ClientRequestBuilder {
         let mut request = self.request.take().expect("cannot reuse request builder");
 
         // set cookies
-        if let Some(ref jar) = self.cookies {
-            for cookie in jar.delta() {
-                request.headers.append(
-                    header::SET_COOKIE,
-                    HeaderValue::from_str(&cookie.to_string())?);
+        if let Some(ref mut jar) = self.cookies {
+            let mut cookie = String::new();
+            for c in jar.delta() {
+                let name = percent_encode(c.name().as_bytes(), USERINFO_ENCODE_SET);
+                let value = percent_encode(c.value().as_bytes(), USERINFO_ENCODE_SET);
+                let _ = write!(&mut cookie, "; {}={}", name, value);
             }
+            request.headers.insert(
+                header::COOKIE, HeaderValue::from_str(&cookie.as_str()[2..]).unwrap());
         }
         request.body = body.into();
         Ok(request)
@@ -562,7 +585,7 @@ impl ClientRequestBuilder {
             request: self.request.take(),
             err: self.err.take(),
             cookies: self.cookies.take(),
-            default_headers: self.default_headers,
+            default_headers: self.default_headers
         }
     }
 }

src/client/response.rs

@@ -77,17 +77,14 @@ impl ClientResponse {
         self.as_ref().status
     }
 
-    /// Load request cookies.
+    /// Load response cookies.
     pub fn cookies(&self) -> Result<&Vec<Cookie<'static>>, CookieParseError> {
         if self.as_ref().cookies.is_none() {
             let msg = self.as_mut();
             let mut cookies = Vec::new();
-            if let Some(val) = msg.headers.get(header::COOKIE) {
-                let s = str::from_utf8(val.as_bytes())
-                    .map_err(CookieParseError::from)?;
-                for cookie in s.split("; ") {
-                    cookies.push(Cookie::parse_encoded(cookie)?.into_owned());
-                }
+            for val in msg.headers.get_all(header::SET_COOKIE).iter() {
+                let s = str::from_utf8(val.as_bytes()).map_err(CookieParseError::from)?;
+                cookies.push(Cookie::parse_encoded(s)?.into_owned());
             }
             msg.cookies = Some(cookies)
         }
@@ -112,13 +109,8 @@ impl fmt::Debug for ClientResponse {
         let res = write!(
             f, "\nClientResponse {:?} {}\n", self.version(), self.status());
         let _ = write!(f, "  headers:\n");
-        for key in self.headers().keys() {
-            let vals: Vec<_> = self.headers().get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        for (key, val) in self.headers().iter() {
+            let _ = write!(f, "    {:?}: {:?}\n", key, val);
         }
         res
     }
@@ -137,3 +129,20 @@ impl Stream for ClientResponse {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_debug() {
+        let resp = ClientResponse::new(ClientMessage::default());
+        resp.as_mut().headers.insert(
+            header::COOKIE, HeaderValue::from_static("cookie1=value1"));
+        resp.as_mut().headers.insert(
+            header::COOKIE, HeaderValue::from_static("cookie2=value2"));
+
+        let dbg = format!("{:?}", resp);
+        assert!(dbg.contains("ClientResponse"));
+    }
+}

src/client/writer.rs

@@ -24,8 +24,6 @@ use server::encoding::{ContentEncoder, TransferEncoding};
 use client::ClientRequest;
 
 
-const LOW_WATERMARK: usize = 1024;
-const HIGH_WATERMARK: usize = 8 * LOW_WATERMARK;
 const AVERAGE_HEADER_SIZE: usize = 30;
 
 bitflags! {
@@ -42,9 +40,8 @@ pub(crate) struct HttpClientWriter {
     written: u64,
     headers_size: u32,
     buffer: SharedBytes,
+    buffer_capacity: usize,
     encoder: ContentEncoder,
-    low: usize,
-    high: usize,
 }
 
 impl HttpClientWriter {
@@ -55,10 +52,9 @@ impl HttpClientWriter {
             flags: Flags::empty(),
             written: 0,
             headers_size: 0,
+            buffer_capacity: 0,
             buffer,
             encoder,
-            low: LOW_WATERMARK,
-            high: HIGH_WATERMARK,
         }
     }
 
@@ -70,12 +66,6 @@ impl HttpClientWriter {
     //    self.flags.contains(Flags::KEEPALIVE) && !self.flags.contains(Flags::UPGRADE)
     // }
 
-    /// Set write buffer capacity
-    pub fn set_buffer_capacity(&mut self, low_watermark: usize, high_watermark: usize) {
-        self.low = low_watermark;
-        self.high = high_watermark;
-    }
-
     fn write_to_stream<T: AsyncWrite>(&mut self, stream: &mut T) -> io::Result<WriterState> {
         while !self.buffer.is_empty() {
             match stream.write(self.buffer.as_ref()) {
@@ -87,7 +77,7 @@ impl HttpClientWriter {
                     let _ = self.buffer.split_to(n);
                 },
                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                    if self.buffer.len() > self.high {
+                    if self.buffer.len() > self.buffer_capacity {
                         return Ok(WriterState::Pause)
                     } else {
                         return Ok(WriterState::Done)
@@ -106,9 +96,6 @@ impl HttpClientWriter {
         // prepare task
         self.flags.insert(Flags::STARTED);
         self.encoder = content_encoder(self.buffer.clone(), msg);
-        if let Some(capacity) = msg.buffer_capacity() {
-            self.set_buffer_capacity(capacity.0, capacity.1);
-        }
 
         // render message
         {
@@ -153,6 +140,8 @@ impl HttpClientWriter {
                     self.written += bytes.len() as u64;
                     self.encoder.write(bytes)?;
                 }
+            } else {
+                self.buffer_capacity = msg.write_buffer_capacity();
             }
         }
         Ok(())
@@ -168,7 +157,7 @@ impl HttpClientWriter {
             }
         }
 
-        if self.buffer.len() > self.high {
+        if self.buffer.len() > self.buffer_capacity {
             Ok(WriterState::Pause)
         } else {
             Ok(WriterState::Done)

src/error.rs

@@ -129,8 +129,19 @@ impl ResponseError for io::Error {
     }
 }
 
-/// `InternalServerError` for `InvalidHeaderValue`
-impl ResponseError for header::InvalidHeaderValue {}
+/// `BadRequest` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValue {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+ }
+}
+
+/// `BadRequest` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValueBytes {
+    fn error_response(&self) -> HttpResponse {
+        HttpResponse::new(StatusCode::BAD_REQUEST, Body::Empty)
+    }
+}
 
 /// `InternalServerError` for `futures::Canceled`
 impl ResponseError for Canceled {}

src/fs.rs

@@ -1,26 +1,42 @@
 //! Static files support.
 
 // //! TODO: needs to re-implement actual files handling, current impl blocks
-use std::io;
-use std::io::Read;
+use std::{io, cmp};
+use std::io::{Read, Seek};
 use std::fmt::Write;
-use std::fs::{File, DirEntry};
+use std::fs::{File, DirEntry, Metadata};
 use std::path::{Path, PathBuf};
 use std::ops::{Deref, DerefMut};
+use std::time::{SystemTime, UNIX_EPOCH};
 
+#[cfg(unix)]
+use std::os::unix::fs::MetadataExt;
+
+use bytes::{Bytes, BytesMut, BufMut};
+use http::{Method, StatusCode};
+use futures::{Async, Poll, Future, Stream};
+use futures_cpupool::{CpuPool, CpuFuture};
 use mime_guess::get_mime_type;
 
+use header;
+use error::Error;
 use param::FromParam;
 use handler::{Handler, Responder};
-use headers::ContentEncoding;
+use httpmessage::HttpMessage;
 use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
-use httpcodes::{HttpOk, HttpFound};
+use httpcodes::{HttpOk, HttpFound, HttpMethodNotAllowed};
 
 /// A file with an associated name; responds with the Content-Type based on the
 /// file extension.
 #[derive(Debug)]
-pub struct NamedFile(PathBuf, File);
+pub struct NamedFile {
+    path: PathBuf,
+    file: File,
+    md: Metadata,
+    modified: Option<SystemTime>,
+    cpu_pool: Option<CpuPool>,
+}
 
 impl NamedFile {
     /// Attempts to open a file in read-only mode.
@@ -30,18 +46,21 @@ impl NamedFile {
     /// ```rust
     /// use actix_web::fs::NamedFile;
     ///
-    /// # #[allow(unused_variables)]
     /// let file = NamedFile::open("foo.txt");
     /// ```
     pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
         let file = File::open(path.as_ref())?;
-        Ok(NamedFile(path.as_ref().to_path_buf(), file))
+        let md = file.metadata()?;
+        let path = path.as_ref().to_path_buf();
+        let modified = md.modified().ok();
+        let cpu_pool = None;
+        Ok(NamedFile{path, file, md, modified, cpu_pool})
     }
 
     /// Returns reference to the underlying `File` object.
     #[inline]
     pub fn file(&self) -> &File {
-        &self.1
+        &self.file
     }
 
     /// Retrieve the path of this file.
@@ -52,7 +71,6 @@ impl NamedFile {
     /// # use std::io;
     /// use actix_web::fs::NamedFile;
     ///
-    /// # #[allow(dead_code)]
     /// # fn path() -> io::Result<()> {
     /// let file = NamedFile::open("test.txt")?;
     /// assert_eq!(file.path().as_os_str(), "foo.txt");
@@ -61,7 +79,37 @@ impl NamedFile {
     /// ```
     #[inline]
     pub fn path(&self) -> &Path {
-        self.0.as_path()
+        self.path.as_path()
+    }
+
+    /// Set `CpuPool` to use
+    #[inline]
+    pub fn set_cpu_pool(mut self, cpu_pool: CpuPool) -> Self {
+        self.cpu_pool = Some(cpu_pool);
+        self
+    }
+
+    fn etag(&self) -> Option<header::EntityTag> {
+        // This etag format is similar to Apache's.
+        self.modified.as_ref().map(|mtime| {
+            let ino = {
+                #[cfg(unix)]
+                { self.md.ino() }
+                #[cfg(not(unix))]
+                { 0 }
+            };
+
+            let dur = mtime.duration_since(UNIX_EPOCH)
+                .expect("modification time must be after epoch");
+            header::EntityTag::strong(
+                format!("{:x}:{:x}:{:x}:{:x}",
+                        ino, self.md.len(), dur.as_secs(),
+                        dur.subsec_nanos()))
+        })
+    }
+
+    fn last_modified(&self) -> Option<header::HttpDate> {
+        self.modified.map(|mtime| mtime.into())
     }
 }
 
@@ -69,30 +117,166 @@ impl Deref for NamedFile {
     type Target = File;
 
     fn deref(&self) -> &File {
-        &self.1
+        &self.file
     }
 }
 
 impl DerefMut for NamedFile {
     fn deref_mut(&mut self) -> &mut File {
-        &mut self.1
+        &mut self.file
     }
 }
 
+/// Returns true if `req` has no `If-Match` header or one which matches `etag`.
+fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
+    match req.get_header::<header::IfMatch>() {
+        None | Some(header::IfMatch::Any) => true,
+        Some(header::IfMatch::Items(ref items)) => {
+            if let Some(some_etag) = etag {
+                for item in items {
+                    if item.strong_eq(some_etag) {
+                        return true;
+                    }
+                }
+            }
+            false
+        }
+    }
+}
+
+/// Returns true if `req` doesn't have an `If-None-Match` header matching `req`.
+fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
+    match req.get_header::<header::IfNoneMatch>() {
+        Some(header::IfNoneMatch::Any) => false,
+        Some(header::IfNoneMatch::Items(ref items)) => {
+            if let Some(some_etag) = etag {
+                for item in items {
+                    if item.weak_eq(some_etag) {
+                        return false;
+                    }
+                }
+            }
+            true
+        }
+        None => true,
+    }
+}
+
+
 impl Responder for NamedFile {
     type Item = HttpResponse;
     type Error = io::Error;
 
-    fn respond_to(mut self, _: HttpRequest) -> Result<HttpResponse, io::Error> {
-        let mut resp = HttpOk.build();
-        resp.content_encoding(ContentEncoding::Identity);
-        if let Some(ext) = self.path().extension() {
-            let mime = get_mime_type(&ext.to_string_lossy());
-            resp.content_type(format!("{}", mime).as_str());
+    fn respond_to(self, req: HttpRequest) -> Result<HttpResponse, io::Error> {
+        if *req.method() != Method::GET && *req.method() != Method::HEAD {
+            return Ok(HttpMethodNotAllowed.build()
+                      .header(header::http::CONTENT_TYPE, "text/plain")
+                      .header(header::http::ALLOW, "GET, HEAD")
+                      .body("This resource only supports GET and HEAD.").unwrap())
+        }
+
+        let etag = self.etag();
+        let last_modified = self.last_modified();
+
+        // check preconditions
+        let precondition_failed = if !any_match(etag.as_ref(), &req) {
+            true
+        } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
+            (last_modified, req.get_header())
+        {
+            m > since
+        } else {
+            false
+        };
+
+        // check last modified
+        let not_modified = if !none_match(etag.as_ref(), &req) {
+            true
+        } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
+            (last_modified, req.get_header())
+        {
+            m <= since
+        } else {
+            false
+        };
+
+        let mut resp = HttpOk.build();
+
+        resp
+            .if_some(self.path().extension(), |ext, resp| {
+                resp.set(header::ContentType(get_mime_type(&ext.to_string_lossy())));
+            })
+            .if_some(last_modified, |lm, resp| {resp.set(header::LastModified(lm));})
+            .if_some(etag, |etag, resp| {resp.set(header::ETag(etag));});
+
+        if precondition_failed {
+            return Ok(resp.status(StatusCode::PRECONDITION_FAILED).finish().unwrap())
+        } else if not_modified {
+            return Ok(resp.status(StatusCode::NOT_MODIFIED).finish().unwrap())
+        }
+
+        if *req.method() == Method::GET {
+            let reader = ChunkedReadFile {
+                size: self.md.len(),
+                offset: 0,
+                cpu_pool: self.cpu_pool.unwrap_or_else(|| req.cpu_pool().clone()),
+                file: Some(self.file),
+                fut: None,
+            };
+            Ok(resp.streaming(reader).unwrap())
+        } else {
+            Ok(resp.finish().unwrap())
+        }
+    }
+}
+
+/// A helper created from a `std::fs::File` which reads the file
+/// chunk-by-chunk on a `CpuPool`.
+pub struct ChunkedReadFile {
+    size: u64,
+    offset: u64,
+    cpu_pool: CpuPool,
+    file: Option<File>,
+    fut: Option<CpuFuture<(File, Bytes), io::Error>>,
+}
+
+impl Stream for ChunkedReadFile {
+    type Item = Bytes;
+    type Error= Error;
+
+    fn poll(&mut self) -> Poll<Option<Bytes>, Error> {
+        if self.fut.is_some() {
+            return match self.fut.as_mut().unwrap().poll()? {
+                Async::Ready((file, bytes)) => {
+                    self.fut.take();
+                    self.file = Some(file);
+                    self.offset += bytes.len() as u64;
+                    Ok(Async::Ready(Some(bytes)))
+                },
+                Async::NotReady => Ok(Async::NotReady),
+            };
+        }
+
+        let size = self.size;
+        let offset = self.offset;
+
+        if size == offset {
+            Ok(Async::Ready(None))
+        } else {
+            let mut file = self.file.take().expect("Use after completion");
+            self.fut = Some(self.cpu_pool.spawn_fn(move || {
+                let max_bytes = cmp::min(size.saturating_sub(offset), 65_536) as usize;
+                let mut buf = BytesMut::with_capacity(max_bytes);
+                file.seek(io::SeekFrom::Start(offset))?;
+                let nbytes = file.read(unsafe{buf.bytes_mut()})?;
+                if nbytes == 0 {
+                    return Err(io::ErrorKind::UnexpectedEof.into())
+                }
+                unsafe{buf.advance_mut(nbytes)};
+                Ok((file, buf.freeze()))
+            }));
+            self.poll()
         }
-        let mut data = Vec::new();
-        let _ = self.1.read_to_end(&mut data);
-        Ok(resp.body(data).unwrap())
     }
 }
 
@@ -211,6 +395,7 @@ pub struct StaticFiles {
     accessible: bool,
     index: Option<String>,
     show_index: bool,
+    cpu_pool: CpuPool,
     _chunk_size: usize,
     _follow_symlinks: bool,
 }
@@ -244,6 +429,7 @@ impl StaticFiles {
             accessible: access,
             index: None,
             show_index: index,
+            cpu_pool: CpuPool::new(40),
             _chunk_size: 0,
             _follow_symlinks: false,
         }
@@ -291,15 +477,17 @@ impl<S> Handler<S> for StaticFiles {
                     Ok(FilesystemElement::Redirect(
                         HttpFound
                             .build()
-                            .header::<_, &str>("LOCATION", &new_path)
+                            .header(header::http::LOCATION, new_path.as_str())
                             .finish().unwrap()))
                 } else if self.show_index {
-                    Ok(FilesystemElement::Directory(Directory::new(self.directory.clone(), path)))
+                    Ok(FilesystemElement::Directory(
+                        Directory::new(self.directory.clone(), path)))
                 } else {
                     Err(io::Error::new(io::ErrorKind::NotFound, "not found"))
                 }
             } else {
-                Ok(FilesystemElement::File(NamedFile::open(path)?))
+                Ok(FilesystemElement::File(
+                    NamedFile::open(path)?.set_cpu_pool(self.cpu_pool.clone())))
             }
         }
     }
@@ -308,12 +496,14 @@ impl<S> Handler<S> for StaticFiles {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use http::{header, StatusCode};
+    use test::TestRequest;
+    use http::{header, Method, StatusCode};
 
     #[test]
     fn test_named_file() {
         assert!(NamedFile::open("test--").is_err());
-        let mut file = NamedFile::open("Cargo.toml").unwrap();
+        let mut file = NamedFile::open("Cargo.toml").unwrap()
+            .set_cpu_pool(CpuPool::new(1));
         { file.file();
           let _f: &File = &file; }
         { let _f: &mut File = &mut file; }
@@ -322,6 +512,15 @@ mod tests {
         assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/x-toml")
     }
 
+    #[test]
+    fn test_named_file_not_allowed() {
+        let req = TestRequest::default().method(Method::POST).finish();
+        let file = NamedFile::open("Cargo.toml").unwrap();
+
+        let resp = file.respond_to(req).unwrap();
+        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
+    }
+
     #[test]
     fn test_static_files() {
         let mut st = StaticFiles::new(".", true);

src/handler.rs

@@ -34,6 +34,63 @@ pub trait Responder {
     fn respond_to(self, req: HttpRequest) -> Result<Self::Item, Self::Error>;
 }
 
+/// Combines two different responder types into a single type
+///
+/// ```rust
+/// # extern crate actix_web;
+/// # extern crate futures;
+/// # use futures::future::Future;
+/// use actix_web::AsyncResponder;
+/// use futures::future::result;
+/// use actix_web::{Either, Error, HttpRequest, HttpResponse, httpcodes};
+///
+/// type RegisterResult = Either<HttpResponse, Box<Future<Item=HttpResponse, Error=Error>>>;
+///
+///
+/// fn index(req: HttpRequest) -> RegisterResult {
+///     if is_a_variant() { // <- choose variant A
+///         Either::A(
+///             httpcodes::HttpBadRequest.with_body("Bad data"))
+///     } else {
+///         Either::B(      // <- variant B
+///             result(HttpResponse::Ok()
+///                    .content_type("text/html")
+///                    .body(format!("Hello!"))
+///                    .map_err(|e| e.into())).responder())
+///     }
+/// }
+/// # fn is_a_variant() -> bool { true }
+/// # fn main() {}
+/// ```
+#[derive(Debug)]
+pub enum Either<A, B> {
+    /// First branch of the type
+    A(A),
+    /// Second branch of the type
+    B(B),
+}
+
+impl<A, B> Responder for Either<A, B>
+    where A: Responder, B: Responder
+{
+    type Item = Reply;
+    type Error = Error;
+
+    fn respond_to(self, req: HttpRequest) -> Result<Reply, Error> {
+        match self {
+            Either::A(a) => match a.respond_to(req) {
+                Ok(val) => Ok(val.into()),
+                Err(err) => Err(err.into()),
+            },
+            Either::B(b) => match b.respond_to(req) {
+                Ok(val) => Ok(val.into()),
+                Err(err) => Err(err.into()),
+            },
+        }
+    }
+}
+
+
 #[doc(hidden)]
 /// Convenience trait that convert `Future` object into `Boxed` future
 pub trait AsyncResponder<I, E>: Sized {

src/header/common/accept.rs

@@ -0,0 +1,158 @@
+use mime::{self, Mime};
+use header::{QualityItem, qitem, http};
+
+header! {
+    /// `Accept` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.2)
+    ///
+    /// The `Accept` header field can be used by user agents to specify
+    /// response media types that are acceptable.  Accept header fields can
+    /// be used to indicate that the request is specifically limited to a
+    /// small set of desired types, as in the case of a request for an
+    /// in-line image
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept = #( media-range [ accept-params ] )
+    ///
+    /// media-range    = ( "*/*"
+    ///                  / ( type "/" "*" )
+    ///                  / ( type "/" subtype )
+    ///                  ) *( OWS ";" OWS parameter )
+    /// accept-params  = weight *( accept-ext )
+    /// accept-ext = OWS ";" OWS token [ "=" ( token / quoted-string ) ]
+    /// ```
+    ///
+    /// # Example values
+    /// * `audio/*; q=0.2, audio/basic`
+    /// * `text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c`
+    ///
+    /// # Examples
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{Accept, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::TEXT_HTML),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{Accept, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::APPLICATION_JSON),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// extern crate mime;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{Accept, QualityItem, q, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    ///
+    /// builder.set(
+    ///     Accept(vec![
+    ///         qitem(mime::TEXT_HTML),
+    ///         qitem("application/xhtml+xml".parse().unwrap()),
+    ///         QualityItem::new(
+    ///             mime::TEXT_XML,
+    ///             q(900)
+    ///         ),
+    ///         qitem("image/webp".parse().unwrap()),
+    ///         QualityItem::new(
+    ///             mime::STAR_STAR,
+    ///             q(800)
+    ///         ),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (Accept, http::ACCEPT) => (QualityItem<Mime>)+
+
+    test_accept {
+        // Tests from the RFC
+         test_header!(
+            test1,
+            vec![b"audio/*; q=0.2, audio/basic"],
+            Some(HeaderField(vec![
+                QualityItem::new("audio/*".parse().unwrap(), q(200)),
+                qitem("audio/basic".parse().unwrap()),
+                ])));
+        test_header!(
+            test2,
+            vec![b"text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"],
+            Some(HeaderField(vec![
+                QualityItem::new(TEXT_PLAIN, q(500)),
+                qitem(TEXT_HTML),
+                QualityItem::new(
+                    "text/x-dvi".parse().unwrap(),
+                    q(800)),
+                qitem("text/x-c".parse().unwrap()),
+                ])));
+        // Custom tests
+        test_header!(
+            test3,
+            vec![b"text/plain; charset=utf-8"],
+            Some(Accept(vec![
+                qitem(TEXT_PLAIN_UTF_8),
+                ])));
+        test_header!(
+            test4,
+            vec![b"text/plain; charset=utf-8; q=0.5"],
+            Some(Accept(vec![
+                QualityItem::new(TEXT_PLAIN_UTF_8,
+                    q(500)),
+            ])));
+
+        #[test]
+        fn test_fuzzing1() {
+            use test::TestRequest;
+            let req = TestRequest::with_header(http::ACCEPT, "chunk#;e").finish();
+            let header = Accept::parse(&req);
+            assert!(header.is_ok());
+        }
+    }
+}
+
+impl Accept {
+    /// A constructor to easily create `Accept: */*`.
+    pub fn star() -> Accept {
+        Accept(vec![qitem(mime::STAR_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: application/json`.
+    pub fn json() -> Accept {
+        Accept(vec![qitem(mime::APPLICATION_JSON)])
+    }
+
+    /// A constructor to easily create `Accept: text/*`.
+    pub fn text() -> Accept {
+        Accept(vec![qitem(mime::TEXT_STAR)])
+    }
+
+    /// A constructor to easily create `Accept: image/*`.
+    pub fn image() -> Accept {
+        Accept(vec![qitem(mime::IMAGE_STAR)])
+    }
+}

src/header/common/accept_charset.rs

@@ -0,0 +1,69 @@
+use header::{http, Charset, QualityItem};
+
+header! {
+    /// `Accept-Charset` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.3)
+    ///
+    /// The `Accept-Charset` header field can be sent by a user agent to
+    /// indicate what charsets are acceptable in textual response content.
+    /// This field allows user agents capable of understanding more
+    /// comprehensive or special-purpose charsets to signal that capability
+    /// to an origin server that is capable of representing information in
+    /// those charsets.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Charset = 1#( ( charset / "*" ) [ weight ] )
+    /// ```
+    ///
+    /// # Example values
+    /// * `iso-8859-5, unicode-1-1;q=0.8`
+    ///
+    /// # Examples
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{AcceptCharset, Charset, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     AcceptCharset(vec![qitem(Charset::Us_Ascii)])
+    /// );
+    /// # }
+    /// ```
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{AcceptCharset, Charset, q, QualityItem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     AcceptCharset(vec![
+    ///         QualityItem::new(Charset::Us_Ascii, q(900)),
+    ///         QualityItem::new(Charset::Iso_8859_10, q(200)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    /// ```rust
+    /// # extern crate actix_web;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{AcceptCharset, Charset, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     AcceptCharset(vec![qitem(Charset::Ext("utf-8".to_owned()))])
+    /// );
+    /// # }
+    /// ```
+    (AcceptCharset, http::ACCEPT_CHARSET) => (QualityItem<Charset>)+
+
+    test_accept_charset {
+        /// Testcase from RFC
+        test_header!(test1, vec![b"iso-8859-5, unicode-1-1;q=0.8"]);
+    }
+}

src/header/common/accept_encoding.rs

@@ -0,0 +1,72 @@
+use header::{Encoding, QualityItem};
+
+header! {
+    /// `Accept-Encoding` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.4)
+    ///
+    /// The `Accept-Encoding` header field can be used by user agents to
+    /// indicate what response content-codings are
+    /// acceptable in the response.  An  `identity` token is used as a synonym
+    /// for "no encoding" in order to communicate when no encoding is
+    /// preferred.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Encoding  = #( codings [ weight ] )
+    /// codings          = content-coding / "identity" / "*"
+    /// ```
+    ///
+    /// # Example values
+    /// * `compress, gzip`
+    /// * ``
+    /// * `*`
+    /// * `compress;q=0.5, gzip;q=1`
+    /// * `gzip;q=1.0, identity; q=0.5, *;q=0`
+    ///
+    /// # Examples
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![qitem(Encoding::Chunked)])
+    /// );
+    /// ```
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![
+    ///         qitem(Encoding::Chunked),
+    ///         qitem(Encoding::Gzip),
+    ///         qitem(Encoding::Deflate),
+    ///     ])
+    /// );
+    /// ```
+    /// ```
+    /// use hyper::header::{Headers, AcceptEncoding, Encoding, QualityItem, q, qitem};
+    ///
+    /// let mut headers = Headers::new();
+    /// headers.set(
+    ///     AcceptEncoding(vec![
+    ///         qitem(Encoding::Chunked),
+    ///         QualityItem::new(Encoding::Gzip, q(600)),
+    ///         QualityItem::new(Encoding::EncodingExt("*".to_owned()), q(0)),
+    ///     ])
+    /// );
+    /// ```
+    (AcceptEncoding, "Accept-Encoding") => (QualityItem<Encoding>)*
+
+    test_accept_encoding {
+        // From the RFC
+        test_header!(test1, vec![b"compress, gzip"]);
+        test_header!(test2, vec![b""], Some(AcceptEncoding(vec![])));
+        test_header!(test3, vec![b"*"]);
+        // Note: Removed quality 1 from gzip
+        test_header!(test4, vec![b"compress;q=0.5, gzip"]);
+        // Note: Removed quality 1 from gzip
+        test_header!(test5, vec![b"gzip, identity; q=0.5, *;q=0"]);
+    }
+}

src/header/common/accept_language.rs

@@ -0,0 +1,76 @@
+use language_tags::LanguageTag;
+use header::{http, QualityItem};
+
+
+header! {
+    /// `Accept-Language` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-5.3.5)
+    ///
+    /// The `Accept-Language` header field can be used by user agents to
+    /// indicate the set of natural languages that are preferred in the
+    /// response.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Accept-Language = 1#( language-range [ weight ] )
+    /// language-range  = <language-range, see [RFC4647], Section 2.1>
+    /// ```
+    ///
+    /// # Example values
+    /// * `da, en-gb;q=0.8, en;q=0.7`
+    /// * `en-us;q=1.0, en;q=0.5, fr`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # extern crate language_tags;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{AcceptLanguage, LanguageTag, qitem};
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// let mut langtag: LanguageTag = Default::default();
+    /// langtag.language = Some("en".to_owned());
+    /// langtag.region = Some("US".to_owned());
+    /// builder.set(
+    ///     AcceptLanguage(vec![
+    ///         qitem(langtag),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::{AcceptLanguage, QualityItem, q, qitem};
+    /// #
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     AcceptLanguage(vec![
+    ///         qitem(langtag!(da)),
+    ///         QualityItem::new(langtag!(en;;;GB), q(800)),
+    ///         QualityItem::new(langtag!(en), q(700)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (AcceptLanguage, http::ACCEPT_LANGUAGE) => (QualityItem<LanguageTag>)+
+
+    test_accept_language {
+        // From the RFC
+        test_header!(test1, vec![b"da, en-gb;q=0.8, en;q=0.7"]);
+        // Own test
+        test_header!(
+            test2, vec![b"en-US, en; q=0.5, fr"],
+            Some(AcceptLanguage(vec![
+                qitem("en-US".parse().unwrap()),
+                QualityItem::new("en".parse().unwrap(), q(500)),
+                qitem("fr".parse().unwrap()),
+        ])));
+    }
+}

src/header/common/allow.rs

@@ -0,0 +1,85 @@
+use http::Method;
+use header::http;
+
+header! {
+    /// `Allow` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.4.1)
+    ///
+    /// The `Allow` header field lists the set of methods advertised as
+    /// supported by the target resource.  The purpose of this field is
+    /// strictly to inform the recipient of valid request methods associated
+    /// with the resource.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Allow = #method
+    /// ```
+    ///
+    /// # Example values
+    /// * `GET, HEAD, PUT`
+    /// * `OPTIONS, GET, PUT, POST, DELETE, HEAD, TRACE, CONNECT, PATCH, fOObAr`
+    /// * ``
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_web;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::Allow;
+    /// use http::Method;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     Allow(vec![Method::GET])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate http;
+    /// # extern crate actix_web;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::Allow;
+    /// use http::Method;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     Allow(vec![
+    ///         Method::GET,
+    ///         Method::POST,
+    ///         Method::PATCH,
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (Allow, http::ALLOW) => (Method)*
+
+    test_allow {
+        // From the RFC
+        test_header!(
+            test1,
+            vec![b"GET, HEAD, PUT"],
+            Some(HeaderField(vec![Method::GET, Method::HEAD, Method::PUT])));
+        // Own tests
+        test_header!(
+            test2,
+            vec![b"OPTIONS, GET, PUT, POST, DELETE, HEAD, TRACE, CONNECT, PATCH"],
+            Some(HeaderField(vec![
+                Method::OPTIONS,
+                Method::GET,
+                Method::PUT,
+                Method::POST,
+                Method::DELETE,
+                Method::HEAD,
+                Method::TRACE,
+                Method::CONNECT,
+                Method::PATCH])));
+        test_header!(
+            test3,
+            vec![b""],
+            Some(HeaderField(Vec::<Method>::new())));
+    }
+}

src/header/common/cache_control.rs

@@ -0,0 +1,231 @@
+use std::fmt::{self, Write};
+use std::str::FromStr;
+use header::{Header, IntoHeaderValue, Writer};
+use header::{http, from_comma_delimited, fmt_comma_delimited};
+
+/// `Cache-Control` header, defined in [RFC7234](https://tools.ietf.org/html/rfc7234#section-5.2)
+///
+/// The `Cache-Control` header field is used to specify directives for
+/// caches along the request/response chain.  Such cache directives are
+/// unidirectional in that the presence of a directive in a request does
+/// not imply that the same directive is to be given in the response.
+///
+/// # ABNF
+///
+/// ```text
+/// Cache-Control   = 1#cache-directive
+/// cache-directive = token [ "=" ( token / quoted-string ) ]
+/// ```
+///
+/// # Example values
+///
+/// * `no-cache`
+/// * `private, community="UCI"`
+/// * `max-age=30`
+///
+/// # Examples
+/// ```rust
+/// use actix_web::httpcodes::HttpOk;
+/// use actix_web::header::{CacheControl, CacheDirective};
+///
+/// let mut builder = HttpOk.build();
+/// builder.set(
+///     CacheControl(vec![CacheDirective::MaxAge(86400u32)])
+/// );
+/// ```
+///
+/// ```rust
+/// use actix_web::httpcodes::HttpOk;
+/// use actix_web::header::{CacheControl, CacheDirective};
+///
+/// let mut builder = HttpOk.build();
+/// builder.set(
+///     CacheControl(vec![
+///         CacheDirective::NoCache,
+///         CacheDirective::Private,
+///         CacheDirective::MaxAge(360u32),
+///         CacheDirective::Extension("foo".to_owned(),
+///                                   Some("bar".to_owned())),
+///     ])
+/// );
+/// ```
+#[derive(PartialEq, Clone, Debug)]
+pub struct CacheControl(pub Vec<CacheDirective>);
+
+__hyper__deref!(CacheControl => Vec<CacheDirective>);
+
+//TODO: this could just be the header! macro
+impl Header for CacheControl {
+    fn name() -> http::HeaderName {
+        http::CACHE_CONTROL
+    }
+
+    #[inline]
+    fn parse<T>(msg: &T) -> Result<Self, ::error::ParseError>
+        where T: ::HttpMessage
+    {
+        let directives = from_comma_delimited(msg.headers().get_all(Self::name()))?;
+        if !directives.is_empty() {
+            Ok(CacheControl(directives))
+        } else {
+            Err(::error::ParseError::Header)
+        }
+    }
+}
+
+impl fmt::Display for CacheControl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt_comma_delimited(f, &self[..])
+    }
+}
+
+impl IntoHeaderValue for CacheControl {
+    type Error = http::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        let mut writer = Writer::new();
+        let _ = write!(&mut writer, "{}", self);
+        http::HeaderValue::from_shared(writer.take())
+    }
+}
+
+/// `CacheControl` contains a list of these directives.
+#[derive(PartialEq, Clone, Debug)]
+pub enum CacheDirective {
+    /// "no-cache"
+    NoCache,
+    /// "no-store"
+    NoStore,
+    /// "no-transform"
+    NoTransform,
+    /// "only-if-cached"
+    OnlyIfCached,
+
+    // request directives
+    /// "max-age=delta"
+    MaxAge(u32),
+    /// "max-stale=delta"
+    MaxStale(u32),
+    /// "min-fresh=delta"
+    MinFresh(u32),
+
+    // response directives
+    /// "must-revalidate"
+    MustRevalidate,
+    /// "public"
+    Public,
+    /// "private"
+    Private,
+    /// "proxy-revalidate"
+    ProxyRevalidate,
+    /// "s-maxage=delta"
+    SMaxAge(u32),
+
+    /// Extension directives. Optionally include an argument.
+    Extension(String, Option<String>)
+}
+
+impl fmt::Display for CacheDirective {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use self::CacheDirective::*;
+        fmt::Display::fmt(match *self {
+            NoCache => "no-cache",
+            NoStore => "no-store",
+            NoTransform => "no-transform",
+            OnlyIfCached => "only-if-cached",
+
+            MaxAge(secs) => return write!(f, "max-age={}", secs),
+            MaxStale(secs) => return write!(f, "max-stale={}", secs),
+            MinFresh(secs) => return write!(f, "min-fresh={}", secs),
+
+            MustRevalidate => "must-revalidate",
+            Public => "public",
+            Private => "private",
+            ProxyRevalidate => "proxy-revalidate",
+            SMaxAge(secs) => return write!(f, "s-maxage={}", secs),
+
+            Extension(ref name, None) => &name[..],
+            Extension(ref name, Some(ref arg)) => return write!(f, "{}={}", name, arg),
+
+        }, f)
+    }
+}
+
+impl FromStr for CacheDirective {
+    type Err = Option<<u32 as FromStr>::Err>;
+    fn from_str(s: &str) -> Result<CacheDirective, Option<<u32 as FromStr>::Err>> {
+        use self::CacheDirective::*;
+        match s {
+            "no-cache" => Ok(NoCache),
+            "no-store" => Ok(NoStore),
+            "no-transform" => Ok(NoTransform),
+            "only-if-cached" => Ok(OnlyIfCached),
+            "must-revalidate" => Ok(MustRevalidate),
+            "public" => Ok(Public),
+            "private" => Ok(Private),
+            "proxy-revalidate" => Ok(ProxyRevalidate),
+            "" => Err(None),
+            _ => match s.find('=') {
+                Some(idx) if idx+1 < s.len() => match (&s[..idx], (&s[idx+1..]).trim_matches('"')) {
+                    ("max-age" , secs) => secs.parse().map(MaxAge).map_err(Some),
+                    ("max-stale", secs) => secs.parse().map(MaxStale).map_err(Some),
+                    ("min-fresh", secs) => secs.parse().map(MinFresh).map_err(Some),
+                    ("s-maxage", secs) => secs.parse().map(SMaxAge).map_err(Some),
+                    (left, right) => Ok(Extension(left.to_owned(), Some(right.to_owned())))
+                },
+                Some(_) => Err(None),
+                None => Ok(Extension(s.to_owned(), None))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use header::Header;
+    use test::TestRequest;
+
+    #[test]
+    fn test_parse_multiple_headers() {
+        let req = TestRequest::with_header(
+            http::CACHE_CONTROL, "no-cache, private").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![CacheDirective::NoCache,
+                                                      CacheDirective::Private])))
+    }
+
+    #[test]
+    fn test_parse_argument() {
+        let req = TestRequest::with_header(
+            http::CACHE_CONTROL, "max-age=100, private").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![CacheDirective::MaxAge(100),
+                                                      CacheDirective::Private])))
+    }
+
+    #[test]
+    fn test_parse_quote_form() {
+        let req = TestRequest::with_header(
+            http::CACHE_CONTROL, "max-age=\"200\"").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![CacheDirective::MaxAge(200)])))
+    }
+
+    #[test]
+    fn test_parse_extension() {
+        let req = TestRequest::with_header(
+            http::CACHE_CONTROL, "foo, bar=baz").finish();
+        let cache = Header::parse(&req);
+        assert_eq!(cache.ok(), Some(CacheControl(vec![
+            CacheDirective::Extension("foo".to_owned(), None),
+            CacheDirective::Extension("bar".to_owned(), Some("baz".to_owned()))])))
+    }
+
+    #[test]
+    fn test_parse_bad_syntax() {
+        let req = TestRequest::with_header(http::CACHE_CONTROL, "foo=").finish();
+        let cache: Result<CacheControl, _> = Header::parse(&req);
+        assert_eq!(cache.ok(), None)
+    }
+}

src/header/common/content_disposition.rs

@@ -0,0 +1,264 @@
+// # References
+//
+// "The Content-Disposition Header Field" https://www.ietf.org/rfc/rfc2183.txt
+// "The Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)" https://www.ietf.org/rfc/rfc6266.txt
+// "Returning Values from Forms: multipart/form-data" https://www.ietf.org/rfc/rfc2388.txt
+// Browser conformance tests at: http://greenbytes.de/tech/tc2231/
+// IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
+
+use language_tags::LanguageTag;
+use std::fmt;
+use unicase;
+
+use header::{Header, Raw, parsing};
+use header::parsing::{parse_extended_value, http_percent_encode};
+use header::shared::Charset;
+
+/// The implied disposition of the content of the HTTP body.
+#[derive(Clone, Debug, PartialEq)]
+pub enum DispositionType {
+    /// Inline implies default processing
+    Inline,
+    /// Attachment implies that the recipient should prompt the user to save the response locally,
+    /// rather than process it normally (as per its media type).
+    Attachment,
+    /// Extension type.  Should be handled by recipients the same way as Attachment
+    Ext(String)
+}
+
+/// A parameter to the disposition type.
+#[derive(Clone, Debug, PartialEq)]
+pub enum DispositionParam {
+    /// A Filename consisting of a Charset, an optional LanguageTag, and finally a sequence of
+    /// bytes representing the filename
+    Filename(Charset, Option<LanguageTag>, Vec<u8>),
+    /// Extension type consisting of token and value.  Recipients should ignore unrecognized
+    /// parameters.
+    Ext(String, String)
+}
+
+/// A `Content-Disposition` header, (re)defined in [RFC6266](https://tools.ietf.org/html/rfc6266).
+///
+/// The Content-Disposition response header field is used to convey
+/// additional information about how to process the response payload, and
+/// also can be used to attach additional metadata, such as the filename
+/// to use when saving the response payload locally.
+///
+/// # ABNF
+
+/// ```text
+/// content-disposition = "Content-Disposition" ":"
+///                       disposition-type *( ";" disposition-parm )
+///
+/// disposition-type    = "inline" | "attachment" | disp-ext-type
+///                       ; case-insensitive
+///
+/// disp-ext-type       = token
+///
+/// disposition-parm    = filename-parm | disp-ext-parm
+///
+/// filename-parm       = "filename" "=" value
+///                     | "filename*" "=" ext-value
+///
+/// disp-ext-parm       = token "=" value
+///                     | ext-token "=" ext-value
+///
+/// ext-token           = <the characters in token, followed by "*">
+/// ```
+///
+/// # Example
+///
+/// ```
+/// use hyper::header::{Headers, ContentDisposition, DispositionType, DispositionParam, Charset};
+///
+/// let mut headers = Headers::new();
+/// headers.set(ContentDisposition {
+///     disposition: DispositionType::Attachment,
+///     parameters: vec![DispositionParam::Filename(
+///       Charset::Iso_8859_1, // The character set for the bytes of the filename
+///       None, // The optional language tag (see `language-tag` crate)
+///       b"\xa9 Copyright 1989.txt".to_vec() // the actual bytes of the filename
+///     )]
+/// });
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+pub struct ContentDisposition {
+    /// The disposition
+    pub disposition: DispositionType,
+    /// Disposition parameters
+    pub parameters: Vec<DispositionParam>,
+}
+
+impl Header for ContentDisposition {
+    fn header_name() -> &'static str {
+        static NAME: &'static str = "Content-Disposition";
+        NAME
+    }
+
+    fn parse_header(raw: &Raw) -> ::Result<ContentDisposition> {
+        parsing::from_one_raw_str(raw).and_then(|s: String| {
+            let mut sections = s.split(';');
+            let disposition = match sections.next() {
+                Some(s) => s.trim(),
+                None => return Err(::Error::Header),
+            };
+
+            let mut cd = ContentDisposition {
+                disposition: if unicase::eq_ascii(&*disposition, "inline") {
+                    DispositionType::Inline
+                } else if unicase::eq_ascii(&*disposition, "attachment") {
+                    DispositionType::Attachment
+                } else {
+                    DispositionType::Ext(disposition.to_owned())
+                },
+                parameters: Vec::new(),
+            };
+
+            for section in sections {
+                let mut parts = section.splitn(2, '=');
+
+                let key = if let Some(key) = parts.next() {
+                    key.trim()
+                } else {
+                    return Err(::Error::Header);
+                };
+
+                let val = if let Some(val) = parts.next() {
+                    val.trim()
+                } else {
+                    return Err(::Error::Header);
+                };
+
+                cd.parameters.push(
+                    if unicase::eq_ascii(&*key, "filename") {
+                        DispositionParam::Filename(
+                            Charset::Ext("UTF-8".to_owned()), None,
+                            val.trim_matches('"').as_bytes().to_owned())
+                    } else if unicase::eq_ascii(&*key, "filename*") {
+                        let extended_value = try!(parse_extended_value(val));
+                        DispositionParam::Filename(extended_value.charset, extended_value.language_tag, extended_value.value)
+                    } else {
+                        DispositionParam::Ext(key.to_owned(), val.trim_matches('"').to_owned())
+                    }
+                );
+            }
+
+            Ok(cd)
+        })
+    }
+
+    #[inline]
+    fn fmt_header(&self, f: &mut ::header::Formatter) -> fmt::Result {
+        f.fmt_line(self)
+    }
+}
+
+impl fmt::Display for ContentDisposition {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.disposition {
+            DispositionType::Inline => try!(write!(f, "inline")),
+            DispositionType::Attachment => try!(write!(f, "attachment")),
+            DispositionType::Ext(ref s) => try!(write!(f, "{}", s)),
+        }
+        for param in &self.parameters {
+            match *param {
+                DispositionParam::Filename(ref charset, ref opt_lang, ref bytes) => {
+                    let mut use_simple_format: bool = false;
+                    if opt_lang.is_none() {
+                        if let Charset::Ext(ref ext) = *charset {
+                            if unicase::eq_ascii(&**ext, "utf-8") {
+                                use_simple_format = true;
+                            }
+                        }
+                    }
+                    if use_simple_format {
+                        try!(write!(f, "; filename=\"{}\"",
+                                    match String::from_utf8(bytes.clone()) {
+                                        Ok(s) => s,
+                                        Err(_) => return Err(fmt::Error),
+                                    }));
+                    } else {
+                        try!(write!(f, "; filename*={}'", charset));
+                        if let Some(ref lang) = *opt_lang {
+                            try!(write!(f, "{}", lang));
+                        };
+                        try!(write!(f, "'"));
+                        try!(http_percent_encode(f, bytes))
+                    }
+                },
+                DispositionParam::Ext(ref k, ref v) => try!(write!(f, "; {}=\"{}\"", k, v)),
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{ContentDisposition,DispositionType,DispositionParam};
+    use ::header::Header;
+    use ::header::shared::Charset;
+
+    #[test]
+    fn test_parse_header() {
+        assert!(ContentDisposition::parse_header(&"".into()).is_err());
+
+        let a = "form-data; dummy=3; name=upload;\r\n filename=\"sample.png\"".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Ext("form-data".to_owned()),
+            parameters: vec![
+                DispositionParam::Ext("dummy".to_owned(), "3".to_owned()),
+                DispositionParam::Ext("name".to_owned(), "upload".to_owned()),
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    "sample.png".bytes().collect()) ]
+        };
+        assert_eq!(a, b);
+
+        let a = "attachment; filename=\"image.jpg\"".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Attachment,
+            parameters: vec![
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    "image.jpg".bytes().collect()) ]
+        };
+        assert_eq!(a, b);
+
+        let a = "attachment; filename*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let b = ContentDisposition {
+            disposition: DispositionType::Attachment,
+            parameters: vec![
+                DispositionParam::Filename(
+                    Charset::Ext("UTF-8".to_owned()),
+                    None,
+                    vec![0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20,
+                         0xe2, 0x82, 0xac, 0x20, b'r', b'a', b't', b'e', b's']) ]
+        };
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn test_display() {
+        let as_string = "attachment; filename*=UTF-8'en'%C2%A3%20and%20%E2%82%AC%20rates";
+        let a = as_string.into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!(as_string, display_rendered);
+
+        let a = "attachment; filename*=UTF-8''black%20and%20white.csv".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!("attachment; filename=\"black and white.csv\"".to_owned(), display_rendered);
+
+        let a = "attachment; filename=colourful.csv".into();
+        let a: ContentDisposition = ContentDisposition::parse_header(&a).unwrap();
+        let display_rendered = format!("{}",a);
+        assert_eq!("attachment; filename=\"colourful.csv\"".to_owned(), display_rendered);
+    }
+}

src/header/common/content_language.rs

@@ -0,0 +1,66 @@
+use language_tags::LanguageTag;
+use header::{http, QualityItem};
+
+
+header! {
+    /// `Content-Language` header, defined in
+    /// [RFC7231](https://tools.ietf.org/html/rfc7231#section-3.1.3.2)
+    /// 
+    /// The `Content-Language` header field describes the natural language(s)
+    /// of the intended audience for the representation.  Note that this
+    /// might not be equivalent to all the languages used within the
+    /// representation.
+    /// 
+    /// # ABNF
+    ///
+    /// ```text
+    /// Content-Language = 1#language-tag
+    /// ```
+    /// 
+    /// # Example values
+    ///
+    /// * `da`
+    /// * `mi, en`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::httpcodes::HttpOk;
+    /// # use actix_web::header::{ContentLanguage, qitem};
+    /// # 
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(en)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # #[macro_use] extern crate language_tags;
+    /// use actix_web::httpcodes::HttpOk;
+    /// # use actix_web::header::{ContentLanguage, qitem};
+    /// #
+    /// # fn main() {
+    /// 
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     ContentLanguage(vec![
+    ///         qitem(langtag!(da)),
+    ///         qitem(langtag!(en;;;GB)),
+    ///     ])
+    /// );
+    /// # }
+    /// ```
+    (ContentLanguage, http::CONTENT_LANGUAGE) => (QualityItem<LanguageTag>)+
+
+    test_content_language {
+        test_header!(test1, vec![b"da"]);
+        test_header!(test2, vec![b"mi, en"]);
+    }
+}

src/header/common/content_range.rs

@@ -0,0 +1,205 @@
+use std::fmt::{self, Display, Write};
+use std::str::FromStr;
+use header::{http, IntoHeaderValue, Writer};
+use error::ParseError;
+
+
+header! {
+    /// `Content-Range` header, defined in
+    /// [RFC7233](http://tools.ietf.org/html/rfc7233#section-4.2)
+    (ContentRange, http::CONTENT_RANGE) => [ContentRangeSpec]
+
+    test_content_range {
+        test_header!(test_bytes,
+            vec![b"bytes 0-499/500"],
+            Some(ContentRange(ContentRangeSpec::Bytes {
+                range: Some((0, 499)),
+                instance_length: Some(500)
+            })));
+
+        test_header!(test_bytes_unknown_len,
+            vec![b"bytes 0-499/*"],
+            Some(ContentRange(ContentRangeSpec::Bytes {
+                range: Some((0, 499)),
+                instance_length: None
+            })));
+
+        test_header!(test_bytes_unknown_range,
+            vec![b"bytes */500"],
+            Some(ContentRange(ContentRangeSpec::Bytes {
+                range: None,
+                instance_length: Some(500)
+            })));
+
+        test_header!(test_unregistered,
+            vec![b"seconds 1-2"],
+            Some(ContentRange(ContentRangeSpec::Unregistered {
+                unit: "seconds".to_owned(),
+                resp: "1-2".to_owned()
+            })));
+
+        test_header!(test_no_len,
+            vec![b"bytes 0-499"],
+            None::<ContentRange>);
+
+        test_header!(test_only_unit,
+            vec![b"bytes"],
+            None::<ContentRange>);
+
+        test_header!(test_end_less_than_start,
+            vec![b"bytes 499-0/500"],
+            None::<ContentRange>);
+
+        test_header!(test_blank,
+            vec![b""],
+            None::<ContentRange>);
+
+        test_header!(test_bytes_many_spaces,
+            vec![b"bytes 1-2/500 3"],
+            None::<ContentRange>);
+
+        test_header!(test_bytes_many_slashes,
+            vec![b"bytes 1-2/500/600"],
+            None::<ContentRange>);
+
+        test_header!(test_bytes_many_dashes,
+            vec![b"bytes 1-2-3/500"],
+            None::<ContentRange>);
+
+    }
+}
+
+
+/// Content-Range, described in [RFC7233](https://tools.ietf.org/html/rfc7233#section-4.2)
+///
+/// # ABNF
+///
+/// ```text
+/// Content-Range       = byte-content-range
+///                     / other-content-range
+///
+/// byte-content-range  = bytes-unit SP
+///                       ( byte-range-resp / unsatisfied-range )
+///
+/// byte-range-resp     = byte-range "/" ( complete-length / "*" )
+/// byte-range          = first-byte-pos "-" last-byte-pos
+/// unsatisfied-range   = "*/" complete-length
+///
+/// complete-length     = 1*DIGIT
+///
+/// other-content-range = other-range-unit SP other-range-resp
+/// other-range-resp    = *CHAR
+/// ```
+#[derive(PartialEq, Clone, Debug)]
+pub enum ContentRangeSpec {
+    /// Byte range
+    Bytes {
+        /// First and last bytes of the range, omitted if request could not be
+        /// satisfied
+        range: Option<(u64, u64)>,
+
+        /// Total length of the instance, can be omitted if unknown
+        instance_length: Option<u64>
+    },
+
+    /// Custom range, with unit not registered at IANA
+    Unregistered {
+        /// other-range-unit
+        unit: String,
+
+        /// other-range-resp
+        resp: String
+    }
+}
+
+fn split_in_two(s: &str, separator: char) -> Option<(&str, &str)> {
+    let mut iter = s.splitn(2, separator);
+    match (iter.next(), iter.next()) {
+        (Some(a), Some(b)) => Some((a, b)),
+        _ => None
+    }
+}
+
+impl FromStr for ContentRangeSpec {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, ParseError> {
+        let res = match split_in_two(s, ' ') {
+            Some(("bytes", resp)) => {
+                let (range, instance_length) = split_in_two(
+                    resp, '/').ok_or(ParseError::Header)?;
+
+                let instance_length = if instance_length == "*" {
+                    None
+                } else {
+                    Some(instance_length.parse()
+                         .map_err(|_| ParseError::Header)?)
+                };
+
+                let range = if range == "*" {
+                    None
+                } else {
+                    let (first_byte, last_byte) = split_in_two(
+                        range, '-').ok_or(ParseError::Header)?;
+                    let first_byte = first_byte.parse()
+                        .map_err(|_| ParseError::Header)?;
+                    let last_byte = last_byte.parse()
+                        .map_err(|_| ParseError::Header)?;
+                    if last_byte < first_byte {
+                        return Err(ParseError::Header);
+                    }
+                    Some((first_byte, last_byte))
+                };
+
+                ContentRangeSpec::Bytes {range, instance_length}
+            }
+            Some((unit, resp)) => {
+                ContentRangeSpec::Unregistered {
+                    unit: unit.to_owned(),
+                    resp: resp.to_owned()
+                }
+            }
+            _ => return Err(ParseError::Header)
+        };
+        Ok(res)
+    }
+}
+
+impl Display for ContentRangeSpec {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ContentRangeSpec::Bytes { range, instance_length } => {
+                try!(f.write_str("bytes "));
+                match range {
+                    Some((first_byte, last_byte)) => {
+                        try!(write!(f, "{}-{}", first_byte, last_byte));
+                    },
+                    None => {
+                        try!(f.write_str("*"));
+                    }
+                };
+                try!(f.write_str("/"));
+                if let Some(v) = instance_length {
+                    write!(f, "{}", v)
+                } else {
+                    f.write_str("*")
+                }
+            }
+            ContentRangeSpec::Unregistered { ref unit, ref resp } => {
+                try!(f.write_str(unit));
+                try!(f.write_str(" "));
+                f.write_str(resp)
+            }
+        }
+    }
+}
+
+impl IntoHeaderValue for ContentRangeSpec {
+    type Error = http::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        let mut writer = Writer::new();
+        let _ = write!(&mut writer, "{}", self);
+        http::HeaderValue::from_shared(writer.take())
+    }
+}

src/header/common/content_type.rs

@@ -0,0 +1,119 @@
+use mime::{self, Mime};
+use header::http;
+
+
+header! {
+    /// `Content-Type` header, defined in
+    /// [RFC7231](http://tools.ietf.org/html/rfc7231#section-3.1.1.5)
+    ///
+    /// The `Content-Type` header field indicates the media type of the
+    /// associated representation: either the representation enclosed in the
+    /// message payload or the selected representation, as determined by the
+    /// message semantics.  The indicated media type defines both the data
+    /// format and how that data is intended to be processed by a recipient,
+    /// within the scope of the received message semantics, after any content
+    /// codings indicated by Content-Encoding are decoded.
+    ///
+    /// Although the `mime` crate allows the mime options to be any slice, this crate
+    /// forces the use of Vec. This is to make sure the same header can't have more than 1 type. If
+    /// this is an issue, it's possible to implement `Header` on a custom struct.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Content-Type = media-type
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `text/html; charset=utf-8`
+    /// * `application/json`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::ContentType;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     ContentType::json()
+    /// );
+    /// # }
+    /// ```
+    ///
+    /// ```rust
+    /// # extern crate mime;
+    /// # extern crate actix_web;
+    /// use mime::TEXT_HTML;
+    /// use actix_web::httpcodes::HttpOk;
+    /// use actix_web::header::ContentType;
+    ///
+    /// # fn main() {
+    /// let mut builder = HttpOk.build();
+    /// builder.set(
+    ///     ContentType(TEXT_HTML)
+    /// );
+    /// # }
+    /// ```
+    (ContentType, http::CONTENT_TYPE) => [Mime]
+
+    test_content_type {
+        test_header!(
+            test1,
+            vec![b"text/html"],
+            Some(HeaderField(TEXT_HTML)));
+    }
+}
+
+impl ContentType {
+    /// A constructor  to easily create a `Content-Type: application/json` header.
+    #[inline]
+    pub fn json() -> ContentType {
+        ContentType(mime::APPLICATION_JSON)
+    }
+
+    /// A constructor  to easily create a `Content-Type: text/plain; charset=utf-8` header.
+    #[inline]
+    pub fn plaintext() -> ContentType {
+        ContentType(mime::TEXT_PLAIN_UTF_8)
+    }
+
+    /// A constructor  to easily create a `Content-Type: text/html` header.
+    #[inline]
+    pub fn html() -> ContentType {
+        ContentType(mime::TEXT_HTML)
+    }
+
+    /// A constructor  to easily create a `Content-Type: text/xml` header.
+    #[inline]
+    pub fn xml() -> ContentType {
+        ContentType(mime::TEXT_XML)
+    }
+
+    /// A constructor  to easily create a `Content-Type: application/www-form-url-encoded` header.
+    #[inline]
+    pub fn form_url_encoded() -> ContentType {
+        ContentType(mime::APPLICATION_WWW_FORM_URLENCODED)
+    }
+    /// A constructor  to easily create a `Content-Type: image/jpeg` header.
+    #[inline]
+    pub fn jpeg() -> ContentType {
+        ContentType(mime::IMAGE_JPEG)
+    }
+
+    /// A constructor  to easily create a `Content-Type: image/png` header.
+    #[inline]
+    pub fn png() -> ContentType {
+        ContentType(mime::IMAGE_PNG)
+    }
+
+    /// A constructor  to easily create a `Content-Type: application/octet-stream` header.
+    #[inline]
+    pub fn octet_stream() -> ContentType {
+        ContentType(mime::APPLICATION_OCTET_STREAM)
+    }
+}
+
+impl Eq for ContentType {}

src/header/common/date.rs

@@ -0,0 +1,42 @@
+use std::time::SystemTime;
+use header::{http, HttpDate};
+
+
+header! {
+    /// `Date` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.1.2)
+    ///
+    /// The `Date` header field represents the date and time at which the
+    /// message was originated.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Date = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `Tue, 15 Nov 1994 08:12:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::Date;
+    /// use std::time::SystemTime;
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// builder.set(Date(SystemTime::now().into()));
+    /// ```
+    (Date, http::DATE) => [HttpDate]
+
+    test_date {
+        test_header!(test1, vec![b"Tue, 15 Nov 1994 08:12:31 GMT"]);
+    }
+}
+
+impl Date {
+    pub fn now() -> Date {
+        Date(SystemTime::now().into())
+    }
+}

src/header/common/etag.rs

@@ -0,0 +1,96 @@
+use header::{http, EntityTag};
+
+header! {
+    /// `ETag` header, defined in [RFC7232](http://tools.ietf.org/html/rfc7232#section-2.3)
+    ///
+    /// The `ETag` header field in a response provides the current entity-tag
+    /// for the selected representation, as determined at the conclusion of
+    /// handling the request.  An entity-tag is an opaque validator for
+    /// differentiating between multiple representations of the same
+    /// resource, regardless of whether those multiple representations are
+    /// due to resource state changes over time, content negotiation
+    /// resulting in multiple representations being valid at the same time,
+    /// or both.  An entity-tag consists of an opaque quoted string, possibly
+    /// prefixed by a weakness indicator.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// ETag       = entity-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `"xyzzy"`
+    /// * `W/"xyzzy"`
+    /// * `""`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::{ETag, EntityTag};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// builder.set(ETag(EntityTag::new(false, "xyzzy".to_owned())));
+    /// ```
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::{ETag, EntityTag};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// builder.set(ETag(EntityTag::new(true, "xyzzy".to_owned())));
+    /// ```
+    (ETag, http::ETAG) => [EntityTag]
+
+    test_etag {
+        // From the RFC
+        test_header!(test1,
+            vec![b"\"xyzzy\""],
+            Some(ETag(EntityTag::new(false, "xyzzy".to_owned()))));
+        test_header!(test2,
+            vec![b"W/\"xyzzy\""],
+            Some(ETag(EntityTag::new(true, "xyzzy".to_owned()))));
+        test_header!(test3,
+            vec![b"\"\""],
+            Some(ETag(EntityTag::new(false, "".to_owned()))));
+        // Own tests
+        test_header!(test4,
+            vec![b"\"foobar\""],
+            Some(ETag(EntityTag::new(false, "foobar".to_owned()))));
+        test_header!(test5,
+            vec![b"\"\""],
+            Some(ETag(EntityTag::new(false, "".to_owned()))));
+        test_header!(test6,
+            vec![b"W/\"weak-etag\""],
+            Some(ETag(EntityTag::new(true, "weak-etag".to_owned()))));
+        test_header!(test7,
+            vec![b"W/\"\x65\x62\""],
+            Some(ETag(EntityTag::new(true, "\u{0065}\u{0062}".to_owned()))));
+        test_header!(test8,
+            vec![b"W/\"\""],
+            Some(ETag(EntityTag::new(true, "".to_owned()))));
+        test_header!(test9,
+            vec![b"no-dquotes"],
+            None::<ETag>);
+        test_header!(test10,
+            vec![b"w/\"the-first-w-is-case-sensitive\""],
+            None::<ETag>);
+        test_header!(test11,
+            vec![b""],
+            None::<ETag>);
+        test_header!(test12,
+            vec![b"\"unmatched-dquotes1"],
+            None::<ETag>);
+        test_header!(test13,
+            vec![b"unmatched-dquotes2\""],
+            None::<ETag>);
+        test_header!(test14,
+            vec![b"matched-\"dquotes\""],
+            None::<ETag>);
+        test_header!(test15,
+            vec![b"\""],
+            None::<ETag>);
+    }
+}

src/header/common/expires.rs

@@ -0,0 +1,39 @@
+use header::{http, HttpDate};
+
+header! {
+    /// `Expires` header, defined in [RFC7234](http://tools.ietf.org/html/rfc7234#section-5.3)
+    ///
+    /// The `Expires` header field gives the date/time after which the
+    /// response is considered stale.
+    ///
+    /// The presence of an Expires field does not imply that the original
+    /// resource will change or cease to exist at, before, or after that
+    /// time.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Expires = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    /// * `Thu, 01 Dec 1994 16:00:00 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::Expires;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// let expiration = SystemTime::now() + Duration::from_secs(60 * 60 * 24);
+    /// builder.set(Expires(expiration.into()));
+    /// ```
+    (Expires, http::EXPIRES) => [HttpDate]
+
+    test_expires {
+        // Testcase from RFC
+        test_header!(test1, vec![b"Thu, 01 Dec 1994 16:00:00 GMT"]);
+    }
+}

src/header/common/if_match.rs

@@ -0,0 +1,70 @@
+use header::{http, EntityTag};
+
+header! {
+    /// `If-Match` header, defined in
+    /// [RFC7232](https://tools.ietf.org/html/rfc7232#section-3.1)
+    ///
+    /// The `If-Match` header field makes the request method conditional on
+    /// the recipient origin server either having at least one current
+    /// representation of the target resource, when the field-value is "*",
+    /// or having a current representation of the target resource that has an
+    /// entity-tag matching a member of the list of entity-tags provided in
+    /// the field-value.
+    ///
+    /// An origin server MUST use the strong comparison function when
+    /// comparing entity-tags for `If-Match`, since the client
+    /// intends this precondition to prevent the method from being applied if
+    /// there have been any changes to the representation data.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-Match = "*" / 1#entity-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `"xyzzy"`
+    /// * "xyzzy", "r2d2xxxx", "c3piozzzz"
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::IfMatch;
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// builder.set(IfMatch::Any);
+    /// ```
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::{IfMatch, EntityTag};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// builder.set(
+    ///     IfMatch::Items(vec![
+    ///         EntityTag::new(false, "xyzzy".to_owned()),
+    ///         EntityTag::new(false, "foobar".to_owned()),
+    ///         EntityTag::new(false, "bazquux".to_owned()),
+    ///     ])
+    /// );
+    /// ```
+    (IfMatch, http::IF_MATCH) => {Any / (EntityTag)+}
+
+    test_if_match {
+        test_header!(
+            test1,
+            vec![b"\"xyzzy\""],
+            Some(HeaderField::Items(
+                vec![EntityTag::new(false, "xyzzy".to_owned())])));
+        test_header!(
+            test2,
+            vec![b"\"xyzzy\", \"r2d2xxxx\", \"c3piozzzz\""],
+            Some(HeaderField::Items(
+                vec![EntityTag::new(false, "xyzzy".to_owned()),
+                     EntityTag::new(false, "r2d2xxxx".to_owned()),
+                     EntityTag::new(false, "c3piozzzz".to_owned())])));
+        test_header!(test3, vec![b"*"], Some(IfMatch::Any));
+    }
+}

src/header/common/if_modified_since.rs

@@ -0,0 +1,39 @@
+use header::{http, HttpDate};
+
+header! {
+    /// `If-Modified-Since` header, defined in
+    /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.3)
+    ///
+    /// The `If-Modified-Since` header field makes a GET or HEAD request
+    /// method conditional on the selected representation's modification date
+    /// being more recent than the date provided in the field-value.
+    /// Transfer of the selected representation's data is avoided if that
+    /// data has not changed.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-Unmodified-Since = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    /// * `Sat, 29 Oct 1994 19:43:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::IfModifiedSince;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+    /// builder.set(IfModifiedSince(modified.into()));
+    /// ```
+    (IfModifiedSince, http::IF_MODIFIED_SINCE) => [HttpDate]
+
+    test_if_modified_since {
+        // Testcase from RFC
+        test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);
+    }
+}

src/header/common/if_none_match.rs

@@ -0,0 +1,91 @@
+use header::{http, EntityTag};
+
+header! {
+    /// `If-None-Match` header, defined in
+    /// [RFC7232](https://tools.ietf.org/html/rfc7232#section-3.2)
+    ///
+    /// The `If-None-Match` header field makes the request method conditional
+    /// on a recipient cache or origin server either not having any current
+    /// representation of the target resource, when the field-value is "*",
+    /// or having a selected representation with an entity-tag that does not
+    /// match any of those listed in the field-value.
+    ///
+    /// A recipient MUST use the weak comparison function when comparing
+    /// entity-tags for If-None-Match (Section 2.3.2), since weak entity-tags
+    /// can be used for cache validation even if there have been changes to
+    /// the representation data.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-None-Match = "*" / 1#entity-tag
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `"xyzzy"`
+    /// * `W/"xyzzy"`
+    /// * `"xyzzy", "r2d2xxxx", "c3piozzzz"`
+    /// * `W/"xyzzy", W/"r2d2xxxx", W/"c3piozzzz"`
+    /// * `*`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::IfNoneMatch;
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// builder.set(IfNoneMatch::Any);
+    /// ```
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::{IfNoneMatch, EntityTag};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// builder.set(
+    ///     IfNoneMatch::Items(vec![
+    ///         EntityTag::new(false, "xyzzy".to_owned()),
+    ///         EntityTag::new(false, "foobar".to_owned()),
+    ///         EntityTag::new(false, "bazquux".to_owned()),
+    ///     ])
+    /// );
+    /// ```
+    (IfNoneMatch, http::IF_NONE_MATCH) => {Any / (EntityTag)+}
+
+    test_if_none_match {
+        test_header!(test1, vec![b"\"xyzzy\""]);
+        test_header!(test2, vec![b"W/\"xyzzy\""]);
+        test_header!(test3, vec![b"\"xyzzy\", \"r2d2xxxx\", \"c3piozzzz\""]);
+        test_header!(test4, vec![b"W/\"xyzzy\", W/\"r2d2xxxx\", W/\"c3piozzzz\""]);
+        test_header!(test5, vec![b"*"]);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::IfNoneMatch;
+    use test::TestRequest;
+    use header::{http, Header, EntityTag};
+
+    #[test]
+    fn test_if_none_match() {
+        let mut if_none_match: Result<IfNoneMatch, _>;
+
+        let req = TestRequest::with_header(http::IF_NONE_MATCH, "*").finish();
+        if_none_match = Header::parse(&req);
+        assert_eq!(if_none_match.ok(), Some(IfNoneMatch::Any));
+
+        let req = TestRequest::with_header(
+            http::IF_NONE_MATCH, &b"\"foobar\", W/\"weak-etag\""[..]).finish();
+
+        if_none_match = Header::parse(&req);
+        let mut entities: Vec<EntityTag> = Vec::new();
+        let foobar_etag = EntityTag::new(false, "foobar".to_owned());
+        let weak_etag = EntityTag::new(true, "weak-etag".to_owned());
+        entities.push(foobar_etag);
+        entities.push(weak_etag);
+        assert_eq!(if_none_match.ok(), Some(IfNoneMatch::Items(entities)));
+    }
+}

src/header/common/if_range.rs

@@ -0,0 +1,107 @@
+use std::fmt::{self, Display, Write};
+use error::ParseError;
+use httpmessage::HttpMessage;
+use header::{http, from_one_raw_str};
+use header::{IntoHeaderValue, Header, EntityTag, HttpDate, Writer};
+
+/// `If-Range` header, defined in [RFC7233](http://tools.ietf.org/html/rfc7233#section-3.2)
+///
+/// If a client has a partial copy of a representation and wishes to have
+/// an up-to-date copy of the entire representation, it could use the
+/// Range header field with a conditional GET (using either or both of
+/// If-Unmodified-Since and If-Match.)  However, if the precondition
+/// fails because the representation has been modified, the client would
+/// then have to make a second request to obtain the entire current
+/// representation.
+///
+/// The `If-Range` header field allows a client to \"short-circuit\" the
+/// second request.  Informally, its meaning is as follows: if the
+/// representation is unchanged, send me the part(s) that I am requesting
+/// in Range; otherwise, send me the entire representation.
+///
+/// # ABNF
+///
+/// ```text
+/// If-Range = entity-tag / HTTP-date
+/// ```
+///
+/// # Example values
+///
+/// * `Sat, 29 Oct 1994 19:43:31 GMT`
+/// * `\"xyzzy\"`
+///
+/// # Examples
+///
+/// ```rust
+/// use actix_web::httpcodes;
+/// use actix_web::header::{IfRange, EntityTag};
+///
+/// let mut builder = httpcodes::HttpOk.build();
+/// builder.set(IfRange::EntityTag(EntityTag::new(false, "xyzzy".to_owned())));
+/// ```
+///
+/// ```rust
+/// use actix_web::httpcodes;
+/// use actix_web::header::IfRange;
+/// use std::time::{SystemTime, Duration};
+///
+/// let mut builder = httpcodes::HttpOk.build();
+/// let fetched = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+/// builder.set(IfRange::Date(fetched.into()));
+/// ```
+#[derive(Clone, Debug, PartialEq)]
+pub enum IfRange {
+    /// The entity-tag the client has of the resource
+    EntityTag(EntityTag),
+    /// The date when the client retrieved the resource
+    Date(HttpDate),
+}
+
+impl Header for IfRange {
+    fn name() -> http::HeaderName {
+        http::IF_RANGE
+    }
+    #[inline]
+    fn parse<T>(msg: &T) -> Result<Self, ParseError> where T: HttpMessage
+    {
+        let etag: Result<EntityTag, _> = from_one_raw_str(msg.headers().get(http::IF_RANGE));
+        if let Ok(etag) = etag {
+            return Ok(IfRange::EntityTag(etag));
+        }
+        let date: Result<HttpDate, _> = from_one_raw_str(msg.headers().get(http::IF_RANGE));
+        if let Ok(date) = date {
+            return Ok(IfRange::Date(date));
+        }
+        Err(ParseError::Header)
+    }
+}
+
+impl Display for IfRange {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            IfRange::EntityTag(ref x) => Display::fmt(x, f),
+            IfRange::Date(ref x) => Display::fmt(x, f),
+        }
+    }
+}
+
+impl IntoHeaderValue for IfRange {
+    type Error = http::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        let mut writer = Writer::new();
+        let _ = write!(&mut writer, "{}", self);
+        http::HeaderValue::from_shared(writer.take())
+    }
+}
+
+
+#[cfg(test)]
+mod test_if_range {
+    use std::str;
+    use header::*;
+    use super::IfRange as HeaderField;
+    test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);
+    test_header!(test2, vec![b"\"xyzzy\""]);
+    test_header!(test3, vec![b"this-is-invalid"], None::<IfRange>);
+}

src/header/common/if_unmodified_since.rs

@@ -0,0 +1,40 @@
+use header::{http, HttpDate};
+
+header! {
+    /// `If-Unmodified-Since` header, defined in
+    /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.4)
+    ///
+    /// The `If-Unmodified-Since` header field makes the request method
+    /// conditional on the selected representation's last modification date
+    /// being earlier than or equal to the date provided in the field-value.
+    /// This field accomplishes the same purpose as If-Match for cases where
+    /// the user agent does not have an entity-tag for the representation.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// If-Unmodified-Since = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `Sat, 29 Oct 1994 19:43:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::IfUnmodifiedSince;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+    /// builder.set(IfUnmodifiedSince(modified.into()));
+    /// ```
+    (IfUnmodifiedSince, http::IF_UNMODIFIED_SINCE) => [HttpDate]
+
+    test_if_unmodified_since {
+        // Testcase from RFC
+        test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);
+    }
+}

src/header/common/last_modified.rs

@@ -0,0 +1,38 @@
+use header::{http, HttpDate};
+
+header! {
+    /// `Last-Modified` header, defined in
+    /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-2.2)
+    ///
+    /// The `Last-Modified` header field in a response provides a timestamp
+    /// indicating the date and time at which the origin server believes the
+    /// selected representation was last modified, as determined at the
+    /// conclusion of handling the request.
+    ///
+    /// # ABNF
+    ///
+    /// ```text
+    /// Expires = HTTP-date
+    /// ```
+    ///
+    /// # Example values
+    ///
+    /// * `Sat, 29 Oct 1994 19:43:31 GMT`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_web::httpcodes;
+    /// use actix_web::header::LastModified;
+    /// use std::time::{SystemTime, Duration};
+    ///
+    /// let mut builder = httpcodes::HttpOk.build();
+    /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
+    /// builder.set(LastModified(modified.into()));
+    /// ```
+    (LastModified, http::LAST_MODIFIED) => [HttpDate]
+
+        test_last_modified {
+            // Testcase from RFC
+            test_header!(test1, vec![b"Sat, 29 Oct 1994 19:43:31 GMT"]);}
+}

src/header/common/mod.rs

@@ -0,0 +1,351 @@
+//! A Collection of Header implementations for common HTTP Headers.
+//!
+//! ## Mime
+//!
+//! Several header fields use MIME values for their contents. Keeping with the
+//! strongly-typed theme, the [mime](https://docs.rs/mime) crate
+//! is used, such as `ContentType(pub Mime)`.
+
+pub use self::accept_charset::AcceptCharset;
+//pub use self::accept_encoding::AcceptEncoding;
+pub use self::accept_language::AcceptLanguage;
+pub use self::accept::Accept;
+pub use self::allow::Allow;
+pub use self::cache_control::{CacheControl, CacheDirective};
+//pub use self::content_disposition::{ContentDisposition, DispositionType, DispositionParam};
+pub use self::content_language::ContentLanguage;
+pub use self::content_range::{ContentRange, ContentRangeSpec};
+pub use self::content_type::ContentType;
+pub use self::date::Date;
+pub use self::etag::ETag;
+pub use self::expires::Expires;
+pub use self::if_match::IfMatch;
+pub use self::if_modified_since::IfModifiedSince;
+pub use self::if_none_match::IfNoneMatch;
+pub use self::if_range::IfRange;
+pub use self::if_unmodified_since::IfUnmodifiedSince;
+pub use self::last_modified::LastModified;
+//pub use self::range::{Range, ByteRangeSpec};
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __hyper__deref {
+    ($from:ty => $to:ty) => {
+        impl ::std::ops::Deref for $from {
+            type Target = $to;
+
+            #[inline]
+            fn deref(&self) -> &$to {
+                &self.0
+            }
+        }
+
+        impl ::std::ops::DerefMut for $from {
+            #[inline]
+            fn deref_mut(&mut self) -> &mut $to {
+                &mut self.0
+            }
+        }
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __hyper__tm {
+    ($id:ident, $tm:ident{$($tf:item)*}) => {
+        #[allow(unused_imports)]
+        #[cfg(test)]
+        mod $tm{
+            use std::str;
+            use http::Method;
+            use $crate::header::*;
+            use $crate::mime::*;
+            use super::$id as HeaderField;
+            $($tf)*
+        }
+
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! test_header {
+    ($id:ident, $raw:expr) => {
+        #[test]
+        fn $id() {
+            #[allow(unused)]
+            use std::ascii::AsciiExt;
+            use test;
+            let raw = $raw;
+            let a: Vec<Vec<u8>> = raw.iter().map(|x| x.to_vec()).collect();
+            let mut req = test::TestRequest::default();
+            for item in a {
+                req = req.header(HeaderField::name(), item);
+            }
+            let req = req.finish();
+            let value = HeaderField::parse(&req);
+            let result = format!("{}", value.unwrap());
+            let expected = String::from_utf8(raw[0].to_vec()).unwrap();
+            let result_cmp: Vec<String> = result
+                .to_ascii_lowercase()
+                .split(' ')
+                .map(|x| x.to_owned())
+                .collect();
+            let expected_cmp: Vec<String> = expected
+                .to_ascii_lowercase()
+                .split(' ')
+                .map(|x| x.to_owned())
+                .collect();
+            assert_eq!(result_cmp.concat(), expected_cmp.concat());
+        }
+    };
+    ($id:ident, $raw:expr, $typed:expr) => {
+        #[test]
+        fn $id() {
+            use $crate::test;
+            let a: Vec<Vec<u8>> = $raw.iter().map(|x| x.to_vec()).collect();
+            let mut req = test::TestRequest::default();
+            for item in a {
+                req = req.header(HeaderField::name(), item);
+            }
+            let req = req.finish();
+            let val = HeaderField::parse(&req);
+            let typed: Option<HeaderField> = $typed;
+            // Test parsing
+            assert_eq!(val.ok(), typed);
+            // Test formatting
+            if typed.is_some() {
+                let raw = &($raw)[..];
+                let mut iter = raw.iter().map(|b|str::from_utf8(&b[..]).unwrap());
+                let mut joined = String::new();
+                joined.push_str(iter.next().unwrap());
+                for s in iter {
+                    joined.push_str(", ");
+                    joined.push_str(s);
+                }
+                assert_eq!(format!("{}", typed.unwrap()), joined);
+            }
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! header {
+    // $a:meta: Attributes associated with the header item (usually docs)
+    // $id:ident: Identifier of the header
+    // $n:expr: Lowercase name of the header
+    // $nn:expr: Nice name of the header
+
+    // List header, zero or more items
+    ($(#[$a:meta])*($id:ident, $name:expr) => ($item:ty)*) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct $id(pub Vec<$item>);
+        __hyper__deref!($id => Vec<$item>);
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::http::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::HttpMessage
+            {
+                $crate::header::from_comma_delimited(
+                    msg.headers().get_all(Self::name())).map($id)
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                $crate::header::fmt_comma_delimited(f, &self.0[..])
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::http::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::http::HeaderValue, Self::Error> {
+                use std::fmt::Write;
+                let mut writer = $crate::header::Writer::new();
+                let _ = write!(&mut writer, "{}", self);
+                $crate::header::http::HeaderValue::from_shared(writer.take())
+            }
+        }
+    };
+    // List header, one or more items
+    ($(#[$a:meta])*($id:ident, $name:expr) => ($item:ty)+) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct $id(pub Vec<$item>);
+        __hyper__deref!($id => Vec<$item>);
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::http::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::HttpMessage
+            {
+                $crate::header::from_comma_delimited(
+                    msg.headers().get_all(Self::name())).map($id)
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                $crate::header::fmt_comma_delimited(f, &self.0[..])
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::http::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::http::HeaderValue, Self::Error> {
+                use std::fmt::Write;
+                let mut writer = $crate::header::Writer::new();
+                let _ = write!(&mut writer, "{}", self);
+                $crate::header::http::HeaderValue::from_shared(writer.take())
+            }
+        }
+    };
+    // Single value header
+    ($(#[$a:meta])*($id:ident, $name:expr) => [$value:ty]) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub struct $id(pub $value);
+        __hyper__deref!($id => $value);
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::http::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::HttpMessage
+            {
+                $crate::header::from_one_raw_str(
+                    msg.headers().get(Self::name())).map($id)
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                ::std::fmt::Display::fmt(&self.0, f)
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::http::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::http::HeaderValue, Self::Error> {
+                self.0.try_into()
+            }
+        }
+    };
+    // List header, one or more items with "*" option
+    ($(#[$a:meta])*($id:ident, $name:expr) => {Any / ($item:ty)+}) => {
+        $(#[$a])*
+        #[derive(Clone, Debug, PartialEq)]
+        pub enum $id {
+            /// Any value is a match
+            Any,
+            /// Only the listed items are a match
+            Items(Vec<$item>),
+        }
+        impl $crate::header::Header for $id {
+            #[inline]
+            fn name() -> $crate::header::http::HeaderName {
+                $name
+            }
+            #[inline]
+            fn parse<T>(msg: &T) -> Result<Self, $crate::error::ParseError>
+                where T: $crate::header::HttpMessage
+            {
+                let any = msg.headers().get(Self::name()).and_then(|hdr| {
+                    hdr.to_str().ok().and_then(|hdr| Some(hdr.trim() == "*"))});
+
+                if let Some(true) = any {
+                    Ok($id::Any)
+                } else {
+                    Ok($id::Items(
+                        $crate::header::from_comma_delimited(
+                            msg.headers().get_all(Self::name()))?))
+                }
+            }
+        }
+        impl ::std::fmt::Display for $id {
+            #[inline]
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                match *self {
+                    $id::Any => f.write_str("*"),
+                    $id::Items(ref fields) => $crate::header::fmt_comma_delimited(
+                        f, &fields[..])
+                }
+            }
+        }
+        impl $crate::header::IntoHeaderValue for $id {
+            type Error = $crate::header::http::InvalidHeaderValueBytes;
+
+            fn try_into(self) -> Result<$crate::header::http::HeaderValue, Self::Error> {
+                use std::fmt::Write;
+                let mut writer = $crate::header::Writer::new();
+                let _ = write!(&mut writer, "{}", self);
+                $crate::header::http::HeaderValue::from_shared(writer.take())
+            }
+        }
+    };
+
+    // optional test module
+    ($(#[$a:meta])*($id:ident, $name:expr) => ($item:ty)* $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])*
+            ($id, $name) => ($item)*
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+    ($(#[$a:meta])*($id:ident, $n:expr) => ($item:ty)+ $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])*
+            ($id, $n) => ($item)+
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+    ($(#[$a:meta])*($id:ident, $name:expr) => [$item:ty] $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])* ($id, $name) => [$item]
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+    ($(#[$a:meta])*($id:ident, $name:expr) => {Any / ($item:ty)+} $tm:ident{$($tf:item)*}) => {
+        header! {
+            $(#[$a])*
+            ($id, $name) => {Any / ($item)+}
+        }
+
+        __hyper__tm! { $id, $tm { $($tf)* }}
+    };
+}
+
+
+mod accept_charset;
+//mod accept_encoding;
+mod accept_language;
+mod accept;
+mod allow;
+mod cache_control;
+//mod content_disposition;
+mod content_language;
+mod content_range;
+mod content_type;
+mod date;
+mod etag;
+mod expires;
+mod if_match;
+mod if_modified_since;
+mod if_none_match;
+mod if_range;
+mod if_unmodified_since;
+mod last_modified;
+//mod range;

src/header/common/range.rs

@@ -0,0 +1,387 @@
+use std::fmt::{self, Display};
+use std::str::FromStr;
+
+use header::{Header, Raw};
+use header::parsing::{from_one_raw_str};
+
+/// `Range` header, defined in [RFC7233](https://tools.ietf.org/html/rfc7233#section-3.1)
+///
+/// The "Range" header field on a GET request modifies the method
+/// semantics to request transfer of only one or more subranges of the
+/// selected representation data, rather than the entire selected
+/// representation data.
+///
+/// # ABNF
+///
+/// ```text
+/// Range =	byte-ranges-specifier / other-ranges-specifier
+/// other-ranges-specifier = other-range-unit "=" other-range-set
+/// other-range-set = 1*VCHAR
+///
+/// bytes-unit = "bytes"
+///
+/// byte-ranges-specifier = bytes-unit "=" byte-range-set
+/// byte-range-set = 1#(byte-range-spec / suffix-byte-range-spec)
+/// byte-range-spec = first-byte-pos "-" [last-byte-pos]
+/// first-byte-pos = 1*DIGIT
+/// last-byte-pos = 1*DIGIT
+/// ```
+///
+/// # Example values
+///
+/// * `bytes=1000-`
+/// * `bytes=-2000`
+/// * `bytes=0-1,30-40`
+/// * `bytes=0-10,20-90,-100`
+/// * `custom_unit=0-123`
+/// * `custom_unit=xxx-yyy`
+///
+/// # Examples
+///
+/// ```
+/// use hyper::header::{Headers, Range, ByteRangeSpec};
+///
+/// let mut headers = Headers::new();
+/// headers.set(Range::Bytes(
+///     vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::AllFrom(200)]
+/// ));
+///
+/// headers.clear();
+/// headers.set(Range::Unregistered("letters".to_owned(), "a-f".to_owned()));
+/// ```
+///
+/// ```
+/// use hyper::header::{Headers, Range};
+///
+/// let mut headers = Headers::new();
+/// headers.set(Range::bytes(1, 100));
+///
+/// headers.clear();
+/// headers.set(Range::bytes_multi(vec![(1, 100), (200, 300)]));
+/// ```
+#[derive(PartialEq, Clone, Debug)]
+pub enum Range {
+    /// Byte range
+    Bytes(Vec<ByteRangeSpec>),
+    /// Custom range, with unit not registered at IANA
+    /// (`other-range-unit`: String , `other-range-set`: String)
+    Unregistered(String, String)
+}
+
+/// Each `Range::Bytes` header can contain one or more `ByteRangeSpecs`.
+/// Each `ByteRangeSpec` defines a range of bytes to fetch
+#[derive(PartialEq, Clone, Debug)]
+pub enum ByteRangeSpec {
+    /// Get all bytes between x and y ("x-y")
+    FromTo(u64, u64),
+    /// Get all bytes starting from x ("x-")
+    AllFrom(u64),
+    /// Get last x bytes ("-x")
+    Last(u64)
+}
+
+impl ByteRangeSpec {
+    /// Given the full length of the entity, attempt to normalize the byte range
+    /// into an satisfiable end-inclusive (from, to) range.
+    ///
+    /// The resulting range is guaranteed to be a satisfiable range within the bounds
+    /// of `0 <= from <= to < full_length`.
+    ///
+    /// If the byte range is deemed unsatisfiable, `None` is returned.
+    /// An unsatisfiable range is generally cause for a server to either reject
+    /// the client request with a `416 Range Not Satisfiable` status code, or to
+    /// simply ignore the range header and serve the full entity using a `200 OK`
+    /// status code.
+    ///
+    /// This function closely follows [RFC 7233][1] section 2.1.
+    /// As such, it considers ranges to be satisfiable if they meet the following
+    /// conditions: 
+    ///
+    /// > If a valid byte-range-set includes at least one byte-range-spec with
+    /// a first-byte-pos that is less than the current length of the
+    /// representation, or at least one suffix-byte-range-spec with a
+    /// non-zero suffix-length, then the byte-range-set is satisfiable.
+    /// Otherwise, the byte-range-set is unsatisfiable.
+    ///
+    /// The function also computes remainder ranges based on the RFC:
+    ///
+    /// > If the last-byte-pos value is
+    /// absent, or if the value is greater than or equal to the current
+    /// length of the representation data, the byte range is interpreted as
+    /// the remainder of the representation (i.e., the server replaces the
+    /// value of last-byte-pos with a value that is one less than the current
+    /// length of the selected representation).
+    ///
+    /// [1]: https://tools.ietf.org/html/rfc7233
+    pub fn to_satisfiable_range(&self, full_length: u64) -> Option<(u64, u64)> {
+        // If the full length is zero, there is no satisfiable end-inclusive range.
+        if full_length == 0 {
+            return None;
+        }
+        match self {
+            &ByteRangeSpec::FromTo(from, to) => {
+                if from < full_length && from <= to {
+                    Some((from, ::std::cmp::min(to, full_length - 1)))
+                } else {
+                    None
+                }
+            },
+            &ByteRangeSpec::AllFrom(from) => {
+                if from < full_length {
+                    Some((from, full_length - 1))
+                } else {
+                    None
+                }
+            },
+            &ByteRangeSpec::Last(last) => {
+                if last > 0 {
+                    // From the RFC: If the selected representation is shorter
+                    // than the specified suffix-length,
+                    // the entire representation is used.
+                    if last > full_length {
+                        Some((0, full_length - 1))
+                    } else {
+                        Some((full_length - last, full_length - 1))
+                    }
+                } else {
+                    None
+                }
+            }
+        }
+    }
+}
+
+impl Range {
+    /// Get the most common byte range header ("bytes=from-to")
+    pub fn bytes(from: u64, to: u64) -> Range {
+        Range::Bytes(vec![ByteRangeSpec::FromTo(from, to)])
+    }
+
+    /// Get byte range header with multiple subranges
+    /// ("bytes=from1-to1,from2-to2,fromX-toX")
+    pub fn bytes_multi(ranges: Vec<(u64, u64)>) -> Range {
+        Range::Bytes(ranges.iter().map(|r| ByteRangeSpec::FromTo(r.0, r.1)).collect())
+    }
+}
+
+
+impl fmt::Display for ByteRangeSpec {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ByteRangeSpec::FromTo(from, to) => write!(f, "{}-{}", from, to),
+            ByteRangeSpec::Last(pos) => write!(f, "-{}", pos),
+            ByteRangeSpec::AllFrom(pos) => write!(f, "{}-", pos),
+        }
+    }
+}
+
+
+impl fmt::Display for Range {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Range::Bytes(ref ranges) => {
+                try!(write!(f, "bytes="));
+
+                for (i, range) in ranges.iter().enumerate() {
+                    if i != 0 {
+                        try!(f.write_str(","));
+                    }
+                    try!(Display::fmt(range, f));
+                }
+                Ok(())
+            },
+            Range::Unregistered(ref unit, ref range_str) => {
+                write!(f, "{}={}", unit, range_str)
+            },
+        }
+    }
+}
+
+impl FromStr for Range {
+    type Err = ::Error;
+
+    fn from_str(s: &str) -> ::Result<Range> {
+        let mut iter = s.splitn(2, '=');
+
+        match (iter.next(), iter.next()) {
+            (Some("bytes"), Some(ranges)) => {
+                let ranges = from_comma_delimited(ranges);
+                if ranges.is_empty() {
+                    return Err(::Error::Header);
+                }
+                Ok(Range::Bytes(ranges))
+            }
+            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => {
+                Ok(Range::Unregistered(unit.to_owned(), range_str.to_owned()))
+
+            },
+            _ => Err(::Error::Header)
+        }
+    }
+}
+
+impl FromStr for ByteRangeSpec {
+    type Err = ::Error;
+
+    fn from_str(s: &str) -> ::Result<ByteRangeSpec> {
+        let mut parts = s.splitn(2, '-');
+
+        match (parts.next(), parts.next()) {
+            (Some(""), Some(end)) => {
+                end.parse().or(Err(::Error::Header)).map(ByteRangeSpec::Last)
+            },
+            (Some(start), Some("")) => {
+                start.parse().or(Err(::Error::Header)).map(ByteRangeSpec::AllFrom)
+            },
+            (Some(start), Some(end)) => {
+                match (start.parse(), end.parse()) {
+                    (Ok(start), Ok(end)) if start <= end => Ok(ByteRangeSpec::FromTo(start, end)),
+                    _ => Err(::Error::Header)
+                }
+            },
+            _ => Err(::Error::Header)
+        }
+    }
+}
+
+fn from_comma_delimited<T: FromStr>(s: &str) -> Vec<T> {
+    s.split(',')
+        .filter_map(|x| match x.trim() {
+            "" => None,
+            y => Some(y)
+        })
+        .filter_map(|x| x.parse().ok())
+        .collect()
+}
+
+impl Header for Range {
+
+    fn header_name() -> &'static str {
+        static NAME: &'static str = "Range";
+        NAME
+    }
+
+    fn parse_header(raw: &Raw) -> ::Result<Range> {
+        from_one_raw_str(raw)
+    }
+
+    fn fmt_header(&self, f: &mut ::header::Formatter) -> fmt::Result {
+        f.fmt_line(self)
+    }
+
+}
+
+#[test]
+fn test_parse_bytes_range_valid() {
+    let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
+    let r3 =  Range::bytes(1, 100);
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);
+
+    let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
+    let r3 =  Range::Bytes(
+        vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::AllFrom(200)]
+    );
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);
+
+    let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
+    let r3 =  Range::Bytes(
+        vec![ByteRangeSpec::FromTo(1, 100), ByteRangeSpec::Last(100)]
+    );
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);
+
+    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+    assert_eq!(r, r2);
+
+}
+
+#[test]
+fn test_parse_unregistered_range_valid() {
+    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+    assert_eq!(r, r2);
+
+    let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "abcd".to_owned());
+    assert_eq!(r, r2);
+
+    let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
+    let r2 =  Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
+    assert_eq!(r, r2);
+}
+
+#[test]
+fn test_parse_invalid() {
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"abc".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"custom=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
+    assert_eq!(r.ok(), None);
+}
+
+#[test]
+fn test_fmt() {
+    use header::Headers;
+
+    let mut headers = Headers::new();
+
+    headers.set(
+        Range::Bytes(
+            vec![ByteRangeSpec::FromTo(0, 1000), ByteRangeSpec::AllFrom(2000)]
+    ));
+    assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
+
+    headers.clear();
+    headers.set(Range::Bytes(vec![]));
+
+    assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
+
+    headers.clear();
+    headers.set(Range::Unregistered("custom".to_owned(), "1-xxx".to_owned()));
+
+    assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
+}
+
+#[test]
+fn test_byte_range_spec_to_satisfiable_range() {
+    assert_eq!(Some((0, 0)), ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3));
+    assert_eq!(Some((1, 2)), ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3));
+    assert_eq!(Some((1, 2)), ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0));
+
+    assert_eq!(Some((0, 2)), ByteRangeSpec::AllFrom(0).to_satisfiable_range(3));
+    assert_eq!(Some((2, 2)), ByteRangeSpec::AllFrom(2).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::AllFrom(3).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::AllFrom(5).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::AllFrom(0).to_satisfiable_range(0));
+
+    assert_eq!(Some((1, 2)), ByteRangeSpec::Last(2).to_satisfiable_range(3));
+    assert_eq!(Some((2, 2)), ByteRangeSpec::Last(1).to_satisfiable_range(3));
+    assert_eq!(Some((0, 2)), ByteRangeSpec::Last(5).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
+}
+

src/header/mod.rs

@@ -0,0 +1,249 @@
+//! Various http headers
+// This is mostly copy of [hyper](https://github.com/hyperium/hyper/tree/master/src/header)
+
+use std::fmt;
+use std::str::FromStr;
+
+use bytes::{Bytes, BytesMut};
+use http::{Error as HttpError};
+use http::header::GetAll;
+use mime::Mime;
+
+pub use cookie::{Cookie, CookieBuilder};
+pub use http_range::HttpRange;
+
+#[doc(hidden)]
+pub mod http {
+    pub use http::header::*;
+}
+
+use error::ParseError;
+use httpmessage::HttpMessage;
+pub use httpresponse::ConnectionType;
+
+mod common;
+mod shared;
+#[doc(hidden)]
+pub use self::common::*;
+#[doc(hidden)]
+pub use self::shared::*;
+
+
+#[doc(hidden)]
+/// A trait for any object that will represent a header field and value.
+pub trait Header where Self: IntoHeaderValue {
+
+    /// Returns the name of the header field
+    fn name() -> http::HeaderName;
+
+    /// Parse a header
+    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
+}
+
+#[doc(hidden)]
+/// A trait for any object that can be Converted to a `HeaderValue`
+pub trait IntoHeaderValue: Sized {
+    /// The type returned in the event of a conversion error.
+    type Error: Into<HttpError>;
+
+    /// Cast from PyObject to a concrete Python object type.
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error>;
+}
+
+impl IntoHeaderValue for http::HeaderValue {
+    type Error = http::InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        Ok(self)
+    }
+}
+
+impl<'a> IntoHeaderValue for &'a str {
+    type Error = http::InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        self.parse()
+    }
+}
+
+impl<'a> IntoHeaderValue for &'a [u8] {
+    type Error = http::InvalidHeaderValue;
+
+    #[inline]
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        http::HeaderValue::from_bytes(self)
+    }
+}
+
+impl IntoHeaderValue for Bytes {
+    type Error = http::InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        http::HeaderValue::from_shared(self)
+    }
+}
+
+impl IntoHeaderValue for Vec<u8> {
+    type Error = http::InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        http::HeaderValue::from_shared(Bytes::from(self))
+    }
+}
+
+impl IntoHeaderValue for String {
+    type Error = http::InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        http::HeaderValue::from_shared(Bytes::from(self))
+    }
+}
+
+impl IntoHeaderValue for Mime {
+    type Error = http::InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        http::HeaderValue::from_shared(Bytes::from(format!("{}", self)))
+    }
+}
+
+/// Represents supported types of content encodings
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum ContentEncoding {
+    /// Automatically select encoding based on encoding negotiation
+    Auto,
+    /// A format using the Brotli algorithm
+    Br,
+    /// A format using the zlib structure with deflate algorithm
+    Deflate,
+    /// Gzip algorithm
+    Gzip,
+    /// Indicates the identity function (i.e. no compression, nor modification)
+    Identity,
+}
+
+impl ContentEncoding {
+
+    #[inline]
+    pub fn is_compression(&self) -> bool {
+        match *self {
+            ContentEncoding::Identity | ContentEncoding::Auto => false,
+            _ => true
+        }
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            ContentEncoding::Br => "br",
+            ContentEncoding::Gzip => "gzip",
+            ContentEncoding::Deflate => "deflate",
+            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
+        }
+    }
+    /// default quality value
+    pub fn quality(&self) -> f64 {
+        match *self {
+            ContentEncoding::Br => 1.1,
+            ContentEncoding::Gzip => 1.0,
+            ContentEncoding::Deflate => 0.9,
+            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
+        }
+    }
+}
+
+// TODO: remove memory allocation
+impl<'a> From<&'a str> for ContentEncoding {
+    fn from(s: &'a str) -> ContentEncoding {
+        match s.trim().to_lowercase().as_ref() {
+            "br" => ContentEncoding::Br,
+            "gzip" => ContentEncoding::Gzip,
+            "deflate" => ContentEncoding::Deflate,
+            _ => ContentEncoding::Identity,
+        }
+    }
+}
+
+#[doc(hidden)]
+pub(crate) struct Writer {
+    buf: BytesMut,
+}
+
+impl Writer {
+    fn new() -> Writer {
+        Writer{buf: BytesMut::new()}
+    }
+    fn take(&mut self) -> Bytes {
+        self.buf.take().freeze()
+    }
+}
+
+impl fmt::Write for Writer {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.buf.extend_from_slice(s.as_bytes());
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+        fmt::write(self, args)
+    }
+}
+
+#[inline]
+#[doc(hidden)]
+/// Reads a comma-delimited raw header into a Vec.
+pub fn from_comma_delimited<T: FromStr>(all: GetAll<http::HeaderValue>)
+                                        -> Result<Vec<T>, ParseError>
+{
+    let mut result = Vec::new();
+    for h in all {
+        let s = h.to_str().map_err(|_| ParseError::Header)?;
+        result.extend(s.split(',')
+                      .filter_map(|x| match x.trim() {
+                          "" => None,
+                          y => Some(y)
+                      })
+                      .filter_map(|x| x.trim().parse().ok()))
+    }
+    Ok(result)
+}
+
+#[inline]
+#[doc(hidden)]
+/// Reads a single string when parsing a header.
+pub fn from_one_raw_str<T: FromStr>(val: Option<&http::HeaderValue>)
+                                    -> Result<T, ParseError>
+{
+    if let Some(line) = val {
+        let line = line.to_str().map_err(|_| ParseError::Header)?;
+        if !line.is_empty() {
+            return T::from_str(line).or(Err(ParseError::Header))
+        }
+    }
+    Err(ParseError::Header)
+}
+
+#[inline]
+#[doc(hidden)]
+/// Format an array into a comma-delimited string.
+pub fn fmt_comma_delimited<T>(f: &mut fmt::Formatter, parts: &[T]) -> fmt::Result
+    where T: fmt::Display
+{
+    let mut iter = parts.iter();
+    if let Some(part) = iter.next() {
+        fmt::Display::fmt(part, f)?;
+    }
+    for part in iter {
+        f.write_str(", ")?;
+        fmt::Display::fmt(part, f)?;
+    }
+    Ok(())
+}

src/header/shared/charset.rs

@@ -0,0 +1,154 @@
+#![allow(unused)]
+use std::fmt::{self, Display};
+use std::str::FromStr;
+use std::ascii::AsciiExt;
+
+use self::Charset::*;
+
+/// A Mime charset.
+///
+/// The string representation is normalised to upper case.
+///
+/// See [http://www.iana.org/assignments/character-sets/character-sets.xhtml][url].
+///
+/// [url]: http://www.iana.org/assignments/character-sets/character-sets.xhtml
+#[derive(Clone,Debug,PartialEq)]
+#[allow(non_camel_case_types)]
+pub enum Charset{
+    /// US ASCII
+    Us_Ascii,
+    /// ISO-8859-1
+    Iso_8859_1,
+    /// ISO-8859-2
+    Iso_8859_2,
+    /// ISO-8859-3
+    Iso_8859_3,
+    /// ISO-8859-4
+    Iso_8859_4,
+    /// ISO-8859-5
+    Iso_8859_5,
+    /// ISO-8859-6
+    Iso_8859_6,
+    /// ISO-8859-7
+    Iso_8859_7,
+    /// ISO-8859-8
+    Iso_8859_8,
+    /// ISO-8859-9
+    Iso_8859_9,
+    /// ISO-8859-10
+    Iso_8859_10,
+    /// Shift_JIS
+    Shift_Jis,
+    /// EUC-JP
+    Euc_Jp,
+    /// ISO-2022-KR
+    Iso_2022_Kr,
+    /// EUC-KR
+    Euc_Kr,
+    /// ISO-2022-JP
+    Iso_2022_Jp,
+    /// ISO-2022-JP-2
+    Iso_2022_Jp_2,
+    /// ISO-8859-6-E
+    Iso_8859_6_E,
+    /// ISO-8859-6-I
+    Iso_8859_6_I,
+    /// ISO-8859-8-E
+    Iso_8859_8_E,
+    /// ISO-8859-8-I
+    Iso_8859_8_I,
+    /// GB2312
+    Gb2312,
+    /// Big5
+    Big5,
+    /// KOI8-R
+    Koi8_R,
+    /// An arbitrary charset specified as a string
+    Ext(String)
+}
+
+impl Charset {
+    fn name(&self) -> &str {
+        match *self {
+            Us_Ascii => "US-ASCII",
+            Iso_8859_1 => "ISO-8859-1",
+            Iso_8859_2 => "ISO-8859-2",
+            Iso_8859_3 => "ISO-8859-3",
+            Iso_8859_4 => "ISO-8859-4",
+            Iso_8859_5 => "ISO-8859-5",
+            Iso_8859_6 => "ISO-8859-6",
+            Iso_8859_7 => "ISO-8859-7",
+            Iso_8859_8 => "ISO-8859-8",
+            Iso_8859_9 => "ISO-8859-9",
+            Iso_8859_10 => "ISO-8859-10",
+            Shift_Jis => "Shift-JIS",
+            Euc_Jp => "EUC-JP",
+            Iso_2022_Kr => "ISO-2022-KR",
+            Euc_Kr => "EUC-KR",
+            Iso_2022_Jp => "ISO-2022-JP",
+            Iso_2022_Jp_2 => "ISO-2022-JP-2",
+            Iso_8859_6_E => "ISO-8859-6-E",
+            Iso_8859_6_I => "ISO-8859-6-I",
+            Iso_8859_8_E => "ISO-8859-8-E",
+            Iso_8859_8_I => "ISO-8859-8-I",
+            Gb2312 => "GB2312",
+            Big5 => "5",
+            Koi8_R => "KOI8-R",
+            Ext(ref s) => s
+        }
+    }
+}
+
+impl Display for Charset {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.name())
+    }
+}
+
+impl FromStr for Charset {
+    type Err = ::Error;
+    fn from_str(s: &str) -> ::Result<Charset> {
+        Ok(match s.to_ascii_uppercase().as_ref() {
+            "US-ASCII" => Us_Ascii,
+            "ISO-8859-1" => Iso_8859_1,
+            "ISO-8859-2" => Iso_8859_2,
+            "ISO-8859-3" => Iso_8859_3,
+            "ISO-8859-4" => Iso_8859_4,
+            "ISO-8859-5" => Iso_8859_5,
+            "ISO-8859-6" => Iso_8859_6,
+            "ISO-8859-7" => Iso_8859_7,
+            "ISO-8859-8" => Iso_8859_8,
+            "ISO-8859-9" => Iso_8859_9,
+            "ISO-8859-10" => Iso_8859_10,
+            "SHIFT-JIS" => Shift_Jis,
+            "EUC-JP" => Euc_Jp,
+            "ISO-2022-KR" => Iso_2022_Kr,
+            "EUC-KR" => Euc_Kr,
+            "ISO-2022-JP" => Iso_2022_Jp,
+            "ISO-2022-JP-2" => Iso_2022_Jp_2,
+            "ISO-8859-6-E" => Iso_8859_6_E,
+            "ISO-8859-6-I" => Iso_8859_6_I,
+            "ISO-8859-8-E" => Iso_8859_8_E,
+            "ISO-8859-8-I" => Iso_8859_8_I,
+            "GB2312" => Gb2312,
+            "5" => Big5,
+            "KOI8-R" => Koi8_R,
+            s => Ext(s.to_owned())
+        })
+    }
+}
+
+#[test]
+fn test_parse() {
+    assert_eq!(Us_Ascii,"us-ascii".parse().unwrap());
+    assert_eq!(Us_Ascii,"US-Ascii".parse().unwrap());
+    assert_eq!(Us_Ascii,"US-ASCII".parse().unwrap());
+    assert_eq!(Shift_Jis,"Shift-JIS".parse().unwrap());
+    assert_eq!(Ext("ABCD".to_owned()),"abcd".parse().unwrap());
+}
+
+#[test]
+fn test_display() {
+    assert_eq!("US-ASCII", format!("{}", Us_Ascii));
+    assert_eq!("ABCD", format!("{}", Ext("ABCD".to_owned())));
+}

src/header/shared/encoding.rs

@@ -0,0 +1,57 @@
+use std::fmt;
+use std::str;
+
+pub use self::Encoding::{Chunked, Brotli, Gzip, Deflate, Compress, Identity, EncodingExt, Trailers};
+
+/// A value to represent an encoding used in `Transfer-Encoding`
+/// or `Accept-Encoding` header.
+#[derive(Clone, PartialEq, Debug)]
+pub enum Encoding {
+    /// The `chunked` encoding.
+    Chunked,
+    /// The `br` encoding.
+    Brotli,
+    /// The `gzip` encoding.
+    Gzip,
+    /// The `deflate` encoding.
+    Deflate,
+    /// The `compress` encoding.
+    Compress,
+    /// The `identity` encoding.
+    Identity,
+    /// The `trailers` encoding.
+    Trailers,
+    /// Some other encoding that is less common, can be any String.
+    EncodingExt(String)
+}
+
+impl fmt::Display for Encoding {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match *self {
+            Chunked => "chunked",
+            Brotli => "br",
+            Gzip => "gzip",
+            Deflate => "deflate",
+            Compress => "compress",
+            Identity => "identity",
+            Trailers => "trailers",
+            EncodingExt(ref s) => s.as_ref()
+        })
+    }
+}
+
+impl str::FromStr for Encoding {
+    type Err = ::error::ParseError;
+    fn from_str(s: &str) -> Result<Encoding, ::error::ParseError> {
+        match s {
+            "chunked" => Ok(Chunked),
+            "br" => Ok(Brotli),
+            "deflate" => Ok(Deflate),
+            "gzip" => Ok(Gzip),
+            "compress" => Ok(Compress),
+            "identity" => Ok(Identity),
+            "trailers" => Ok(Trailers),
+            _ => Ok(EncodingExt(s.to_owned()))
+        }
+    }
+}

src/header/shared/entity.rs

@@ -0,0 +1,230 @@
+use std::str::FromStr;
+use std::fmt::{self, Display, Write};
+use header::{http, Writer, IntoHeaderValue};
+
+/// check that each char in the slice is either:
+/// 1. `%x21`, or
+/// 2. in the range `%x23` to `%x7E`, or
+/// 3. above `%x80`
+fn check_slice_validity(slice: &str) -> bool {
+    slice.bytes().all(|c|
+        c == b'\x21' || (c >= b'\x23' && c <= b'\x7e') | (c >= b'\x80'))
+}
+
+/// An entity tag, defined in [RFC7232](https://tools.ietf.org/html/rfc7232#section-2.3)
+///
+/// An entity tag consists of a string enclosed by two literal double quotes.
+/// Preceding the first double quote is an optional weakness indicator,
+/// which always looks like `W/`. Examples for valid tags are `"xyzzy"` and `W/"xyzzy"`.
+///
+/// # ABNF
+///
+/// ```text
+/// entity-tag = [ weak ] opaque-tag
+/// weak       = %x57.2F ; "W/", case-sensitive
+/// opaque-tag = DQUOTE *etagc DQUOTE
+/// etagc      = %x21 / %x23-7E / obs-text
+///            ; VCHAR except double quotes, plus obs-text
+/// ```
+///
+/// # Comparison
+/// To check if two entity tags are equivalent in an application always use the `strong_eq` or
+/// `weak_eq` methods based on the context of the Tag. Only use `==` to check if two tags are
+/// identical.
+///
+/// The example below shows the results for a set of entity-tag pairs and
+/// both the weak and strong comparison function results:
+///
+/// | `ETag 1`| `ETag 2`| Strong Comparison | Weak Comparison |
+/// |---------|---------|-------------------|-----------------|
+/// | `W/"1"` | `W/"1"` | no match          | match           |
+/// | `W/"1"` | `W/"2"` | no match          | no match        |
+/// | `W/"1"` | `"1"`   | no match          | match           |
+/// | `"1"`   | `"1"`   | match             | match           |
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EntityTag {
+    /// Weakness indicator for the tag
+    pub weak: bool,
+    /// The opaque string in between the DQUOTEs
+    tag: String
+}
+
+impl EntityTag {
+    /// Constructs a new EntityTag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn new(weak: bool, tag: String) -> EntityTag {
+        assert!(check_slice_validity(&tag), "Invalid tag: {:?}", tag);
+        EntityTag { weak, tag }
+    }
+
+    /// Constructs a new weak EntityTag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn weak(tag: String) -> EntityTag {
+        EntityTag::new(true, tag)
+    }
+
+    /// Constructs a new strong EntityTag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn strong(tag: String) -> EntityTag {
+        EntityTag::new(false, tag)
+    }
+
+    /// Get the tag.
+    pub fn tag(&self) -> &str {
+        self.tag.as_ref()
+    }
+
+    /// Set the tag.
+    /// # Panics
+    /// If the tag contains invalid characters.
+    pub fn set_tag(&mut self, tag: String) {
+        assert!(check_slice_validity(&tag), "Invalid tag: {:?}", tag);
+        self.tag = tag
+    }
+
+    /// For strong comparison two entity-tags are equivalent if both are not weak and their
+    /// opaque-tags match character-by-character.
+    pub fn strong_eq(&self, other: &EntityTag) -> bool {
+        !self.weak && !other.weak && self.tag == other.tag
+    }
+
+    /// For weak comparison two entity-tags are equivalent if their
+    /// opaque-tags match character-by-character, regardless of either or
+    /// both being tagged as "weak".
+    pub fn weak_eq(&self, other: &EntityTag) -> bool {
+        self.tag == other.tag
+    }
+
+    /// The inverse of `EntityTag.strong_eq()`.
+    pub fn strong_ne(&self, other: &EntityTag) -> bool {
+        !self.strong_eq(other)
+    }
+
+    /// The inverse of `EntityTag.weak_eq()`.
+    pub fn weak_ne(&self, other: &EntityTag) -> bool {
+        !self.weak_eq(other)
+    }
+}
+
+impl Display for EntityTag {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.weak {
+            write!(f, "W/\"{}\"", self.tag)
+        } else {
+            write!(f, "\"{}\"", self.tag)
+        }
+    }
+}
+
+impl FromStr for EntityTag {
+    type Err = ::error::ParseError;
+
+    fn from_str(s: &str) -> Result<EntityTag, ::error::ParseError> {
+        let length: usize = s.len();
+        let slice = &s[..];
+        // Early exits if it doesn't terminate in a DQUOTE.
+        if !slice.ends_with('"') || slice.len() < 2 {
+            return Err(::error::ParseError::Header);
+        }
+        // The etag is weak if its first char is not a DQUOTE.
+        if slice.len() >= 2 && slice.starts_with('"')
+                && check_slice_validity(&slice[1..length-1]) {
+            // No need to check if the last char is a DQUOTE,
+            // we already did that above.
+            return Ok(EntityTag { weak: false, tag: slice[1..length-1].to_owned() });
+        } else if slice.len() >= 4 && slice.starts_with("W/\"")
+                && check_slice_validity(&slice[3..length-1]) {
+            return Ok(EntityTag { weak: true, tag: slice[3..length-1].to_owned() });
+        }
+        Err(::error::ParseError::Header)
+    }
+}
+
+impl IntoHeaderValue for EntityTag {
+    type Error = http::InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<http::HeaderValue, Self::Error> {
+        let mut wrt = Writer::new();
+        write!(wrt, "{}", self).unwrap();
+        unsafe{Ok(http::HeaderValue::from_shared_unchecked(wrt.take()))}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EntityTag;
+
+    #[test]
+    fn test_etag_parse_success() {
+        // Expected success
+        assert_eq!("\"foobar\"".parse::<EntityTag>().unwrap(),
+            EntityTag::strong("foobar".to_owned()));
+        assert_eq!("\"\"".parse::<EntityTag>().unwrap(),
+            EntityTag::strong("".to_owned()));
+        assert_eq!("W/\"weaktag\"".parse::<EntityTag>().unwrap(),
+            EntityTag::weak("weaktag".to_owned()));
+        assert_eq!("W/\"\x65\x62\"".parse::<EntityTag>().unwrap(),
+            EntityTag::weak("\x65\x62".to_owned()));
+        assert_eq!("W/\"\"".parse::<EntityTag>().unwrap(), EntityTag::weak("".to_owned()));
+    }
+
+    #[test]
+    fn test_etag_parse_failures() {
+        // Expected failures
+        assert!("no-dquotes".parse::<EntityTag>().is_err());
+        assert!("w/\"the-first-w-is-case-sensitive\"".parse::<EntityTag>().is_err());
+        assert!("".parse::<EntityTag>().is_err());
+        assert!("\"unmatched-dquotes1".parse::<EntityTag>().is_err());
+        assert!("unmatched-dquotes2\"".parse::<EntityTag>().is_err());
+        assert!("matched-\"dquotes\"".parse::<EntityTag>().is_err());
+    }
+
+    #[test]
+    fn test_etag_fmt() {
+        assert_eq!(format!("{}", EntityTag::strong("foobar".to_owned())), "\"foobar\"");
+        assert_eq!(format!("{}", EntityTag::strong("".to_owned())), "\"\"");
+        assert_eq!(format!("{}", EntityTag::weak("weak-etag".to_owned())), "W/\"weak-etag\"");
+        assert_eq!(format!("{}", EntityTag::weak("\u{0065}".to_owned())), "W/\"\x65\"");
+        assert_eq!(format!("{}", EntityTag::weak("".to_owned())), "W/\"\"");
+    }
+
+    #[test]
+    fn test_cmp() {
+        // | ETag 1  | ETag 2  | Strong Comparison | Weak Comparison |
+        // |---------|---------|-------------------|-----------------|
+        // | `W/"1"` | `W/"1"` | no match          | match           |
+        // | `W/"1"` | `W/"2"` | no match          | no match        |
+        // | `W/"1"` | `"1"`   | no match          | match           |
+        // | `"1"`   | `"1"`   | match             | match           |
+        let mut etag1 = EntityTag::weak("1".to_owned());
+        let mut etag2 = EntityTag::weak("1".to_owned());
+        assert!(!etag1.strong_eq(&etag2));
+        assert!(etag1.weak_eq(&etag2));
+        assert!(etag1.strong_ne(&etag2));
+        assert!(!etag1.weak_ne(&etag2));
+
+        etag1 = EntityTag::weak("1".to_owned());
+        etag2 = EntityTag::weak("2".to_owned());
+        assert!(!etag1.strong_eq(&etag2));
+        assert!(!etag1.weak_eq(&etag2));
+        assert!(etag1.strong_ne(&etag2));
+        assert!(etag1.weak_ne(&etag2));
+
+        etag1 = EntityTag::weak("1".to_owned());
+        etag2 = EntityTag::strong("1".to_owned());
+        assert!(!etag1.strong_eq(&etag2));
+        assert!(etag1.weak_eq(&etag2));
+        assert!(etag1.strong_ne(&etag2));
+        assert!(!etag1.weak_ne(&etag2));
+
+        etag1 = EntityTag::strong("1".to_owned());
+        etag2 = EntityTag::strong("1".to_owned());
+        assert!(etag1.strong_eq(&etag2));
+        assert!(etag1.weak_eq(&etag2));
+        assert!(!etag1.strong_ne(&etag2));
+        assert!(!etag1.weak_ne(&etag2));
+    }
+}

src/header/shared/httpdate.rs

@@ -0,0 +1,97 @@
+use std::fmt::{self, Display};
+use std::io::Write;
+use std::str::FromStr;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use time;
+use bytes::{BytesMut, BufMut};
+use http::header::{HeaderValue, InvalidHeaderValueBytes};
+
+use error::ParseError;
+use header::IntoHeaderValue;
+
+
+/// A timestamp with HTTP formatting and parsing
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct HttpDate(time::Tm);
+
+impl FromStr for HttpDate {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<HttpDate, ParseError> {
+        match time::strptime(s, "%a, %d %b %Y %T %Z").or_else(|_| {
+            time::strptime(s, "%A, %d-%b-%y %T %Z")
+        }).or_else(|_| {
+            time::strptime(s, "%c")
+        }) {
+            Ok(t) => Ok(HttpDate(t)),
+            Err(_) => Err(ParseError::Header),
+        }
+    }
+}
+
+impl Display for HttpDate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.0.to_utc().rfc822(), f)
+    }
+}
+
+impl From<time::Tm> for HttpDate {
+    fn from(tm: time::Tm) -> HttpDate {
+        HttpDate(tm)
+    }
+}
+
+impl From<SystemTime> for HttpDate {
+    fn from(sys: SystemTime) -> HttpDate {
+        let tmspec = match sys.duration_since(UNIX_EPOCH) {
+            Ok(dur) => {
+                time::Timespec::new(dur.as_secs() as i64, dur.subsec_nanos() as i32)
+            },
+            Err(err) => {
+                let neg = err.duration();
+                time::Timespec::new(-(neg.as_secs() as i64), -(neg.subsec_nanos() as i32))
+            },
+        };
+        HttpDate(time::at_utc(tmspec))
+    }
+}
+
+impl IntoHeaderValue for HttpDate {
+    type Error = InvalidHeaderValueBytes;
+
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let mut wrt = BytesMut::with_capacity(29).writer();
+        write!(wrt, "{}", self.0.rfc822()).unwrap();
+        unsafe{Ok(HeaderValue::from_shared_unchecked(wrt.get_mut().take().freeze()))}
+    }
+}
+
+impl From<HttpDate> for SystemTime {
+    fn from(date: HttpDate) -> SystemTime {
+        let spec = date.0.to_timespec();
+        if spec.sec >= 0 {
+            UNIX_EPOCH + Duration::new(spec.sec as u64, spec.nsec as u32)
+        } else {
+            UNIX_EPOCH - Duration::new(spec.sec as u64, spec.nsec as u32)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use time::Tm;
+    use super::HttpDate;
+
+    const NOV_07: HttpDate = HttpDate(Tm {
+        tm_nsec: 0, tm_sec: 37, tm_min: 48, tm_hour: 8, tm_mday: 7, tm_mon: 10, tm_year: 94,
+        tm_wday: 0, tm_isdst: 0, tm_yday: 0, tm_utcoff: 0});
+
+    #[test]
+    fn test_date() {
+        assert_eq!("Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(), NOV_07);
+        assert_eq!("Sunday, 07-Nov-94 08:48:37 GMT".parse::<HttpDate>().unwrap(), NOV_07);
+        assert_eq!("Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(), NOV_07);
+        assert!("this-is-no-date".parse::<HttpDate>().is_err());
+    }
+}

src/header/shared/mod.rs

@@ -0,0 +1,14 @@
+//! Copied for `hyper::header::shared`;
+
+pub use self::charset::Charset;
+pub use self::encoding::Encoding;
+pub use self::entity::EntityTag;
+pub use self::httpdate::HttpDate;
+pub use language_tags::LanguageTag;
+pub use self::quality_item::{Quality, QualityItem, qitem, q};
+
+mod charset;
+mod entity;
+mod encoding;
+mod httpdate;
+mod quality_item;

src/header/shared/quality_item.rs

@@ -0,0 +1,265 @@
+#![allow(unused)]
+use std::ascii::AsciiExt;
+use std::cmp;
+use std::default::Default;
+use std::fmt;
+use std::str;
+
+use self::internal::IntoQuality;
+
+/// Represents a quality used in quality values.
+///
+/// Can be created with the `q` function.
+///
+/// # Implementation notes
+///
+/// The quality value is defined as a number between 0 and 1 with three decimal places. This means
+/// there are 1001 possible values. Since floating point numbers are not exact and the smallest
+/// floating point data type (`f32`) consumes four bytes, hyper uses an `u16` value to store the
+/// quality internally. For performance reasons you may set quality directly to a value between
+/// 0 and 1000 e.g. `Quality(532)` matches the quality `q=0.532`.
+///
+/// [RFC7231 Section 5.3.1](https://tools.ietf.org/html/rfc7231#section-5.3.1)
+/// gives more information on quality values in HTTP header fields.
+#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Quality(u16);
+
+impl Default for Quality {
+    fn default() -> Quality {
+        Quality(1000)
+    }
+}
+
+/// Represents an item with a quality value as defined in
+/// [RFC7231](https://tools.ietf.org/html/rfc7231#section-5.3.1).
+#[derive(Clone, PartialEq, Debug)]
+pub struct QualityItem<T> {
+    /// The actual contents of the field.
+    pub item: T,
+    /// The quality (client or server preference) for the value.
+    pub quality: Quality,
+}
+
+impl<T> QualityItem<T> {
+    /// Creates a new `QualityItem` from an item and a quality.
+    /// The item can be of any type.
+    /// The quality should be a value in the range [0, 1].
+    pub fn new(item: T, quality: Quality) -> QualityItem<T> {
+        QualityItem { item, quality }
+    }
+}
+
+impl<T: PartialEq> cmp::PartialOrd for QualityItem<T> {
+    fn partial_cmp(&self, other: &QualityItem<T>) -> Option<cmp::Ordering> {
+        self.quality.partial_cmp(&other.quality)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for QualityItem<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        try!(fmt::Display::fmt(&self.item, f));
+        match self.quality.0 {
+            1000 => Ok(()),
+            0 => f.write_str("; q=0"),
+            x => write!(f, "; q=0.{}", format!("{:03}", x).trim_right_matches('0'))
+        }
+    }
+}
+
+impl<T: str::FromStr> str::FromStr for QualityItem<T> {
+    type Err = ::error::ParseError;
+
+    fn from_str(s: &str) -> Result<QualityItem<T>, ::error::ParseError> {
+        if !s.is_ascii() {
+            return Err(::error::ParseError::Header);
+        }
+        // Set defaults used if parsing fails.
+        let mut raw_item = s;
+        let mut quality = 1f32;
+
+        let parts: Vec<&str> = s.rsplitn(2, ';').map(|x| x.trim()).collect();
+        if parts.len() == 2 {
+            if parts[0].len() < 2 {
+                return Err(::error::ParseError::Header);
+            }
+            let start = &parts[0][0..2];
+            if start == "q=" || start == "Q=" {
+                let q_part = &parts[0][2..parts[0].len()];
+                if q_part.len() > 5 {
+                    return Err(::error::ParseError::Header);
+                }
+                match q_part.parse::<f32>() {
+                    Ok(q_value) => {
+                        if 0f32 <= q_value && q_value <= 1f32 {
+                            quality = q_value;
+                            raw_item = parts[1];
+                        } else {
+                            return Err(::error::ParseError::Header);
+                        }
+                    },
+                    Err(_) => return Err(::error::ParseError::Header),
+                }
+            }
+        }
+        match raw_item.parse::<T>() {
+            // we already checked above that the quality is within range
+            Ok(item) => Ok(QualityItem::new(item, from_f32(quality))),
+            Err(_) => Err(::error::ParseError::Header),
+        }
+    }
+}
+
+#[inline]
+fn from_f32(f: f32) -> Quality {
+    // this function is only used internally. A check that `f` is within range
+    // should be done before calling this method. Just in case, this
+    // debug_assert should catch if we were forgetful
+    debug_assert!(f >= 0f32 && f <= 1f32, "q value must be between 0.0 and 1.0");
+    Quality((f * 1000f32) as u16)
+}
+
+/// Convenience function to wrap a value in a `QualityItem`
+/// Sets `q` to the default 1.0
+pub fn qitem<T>(item: T) -> QualityItem<T> {
+    QualityItem::new(item, Default::default())
+}
+
+/// Convenience function to create a `Quality` from a float or integer.
+/// 
+/// Implemented for `u16` and `f32`. Panics if value is out of range.
+pub fn q<T: IntoQuality>(val: T) -> Quality {
+    val.into_quality()
+}
+
+mod internal {
+    use super::Quality;
+
+    // TryFrom is probably better, but it's not stable. For now, we want to
+    // keep the functionality of the `q` function, while allowing it to be
+    // generic over `f32` and `u16`.
+    //
+    // `q` would panic before, so keep that behavior. `TryFrom` can be
+    // introduced later for a non-panicking conversion.
+
+    pub trait IntoQuality: Sealed + Sized {
+        fn into_quality(self) -> Quality;
+    }
+
+    impl IntoQuality for f32 {
+        fn into_quality(self) -> Quality {
+            assert!(self >= 0f32 && self <= 1f32, "float must be between 0.0 and 1.0");
+            super::from_f32(self)
+        }
+    }
+
+    impl IntoQuality for u16 {
+        fn into_quality(self) -> Quality {
+            assert!(self <= 1000, "u16 must be between 0 and 1000");
+            Quality(self)
+        }
+    }
+
+
+    pub trait Sealed {}
+    impl Sealed for u16 {}
+    impl Sealed for f32 {}
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::super::encoding::*;
+
+    #[test]
+    fn test_quality_item_fmt_q_1() {
+        let x = qitem(Chunked);
+        assert_eq!(format!("{}", x), "chunked");
+    }
+    #[test]
+    fn test_quality_item_fmt_q_0001() {
+        let x = QualityItem::new(Chunked, Quality(1));
+        assert_eq!(format!("{}", x), "chunked; q=0.001");
+    }
+    #[test]
+    fn test_quality_item_fmt_q_05() {
+        // Custom value
+        let x = QualityItem{
+            item: EncodingExt("identity".to_owned()),
+            quality: Quality(500),
+        };
+        assert_eq!(format!("{}", x), "identity; q=0.5");
+    }
+
+    #[test]
+    fn test_quality_item_fmt_q_0() {
+        // Custom value
+        let x = QualityItem{
+            item: EncodingExt("identity".to_owned()),
+            quality: Quality(0),
+        };
+        assert_eq!(x.to_string(), "identity; q=0");
+    }
+
+    #[test]
+    fn test_quality_item_from_str1() {
+        let x: Result<QualityItem<Encoding>, _> = "chunked".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: Quality(1000), });
+    }
+    #[test]
+    fn test_quality_item_from_str2() {
+        let x: Result<QualityItem<Encoding>, _> = "chunked; q=1".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: Quality(1000), });
+    }
+    #[test]
+    fn test_quality_item_from_str3() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=0.5".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: Quality(500), });
+    }
+    #[test]
+    fn test_quality_item_from_str4() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=0.273".parse();
+        assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: Quality(273), });
+    }
+    #[test]
+    fn test_quality_item_from_str5() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=0.2739999".parse();
+        assert!(x.is_err());
+    }
+    #[test]
+    fn test_quality_item_from_str6() {
+        let x: Result<QualityItem<Encoding>, _> = "gzip; q=2".parse();
+        assert!(x.is_err());
+    }
+    #[test]
+    fn test_quality_item_ordering() {
+        let x: QualityItem<Encoding> = "gzip; q=0.5".parse().ok().unwrap();
+        let y: QualityItem<Encoding> = "gzip; q=0.273".parse().ok().unwrap();
+        let comparision_result: bool = x.gt(&y);
+        assert!(comparision_result)
+    }
+
+    #[test]
+    fn test_quality() {
+        assert_eq!(q(0.5), Quality(500));
+    }
+
+    #[test]
+    #[should_panic] // FIXME - 32-bit msvc unwinding broken
+    #[cfg_attr(all(target_arch="x86", target_env="msvc"), ignore)]
+    fn test_quality_invalid() {
+        q(-1.0);
+    }
+
+    #[test]
+    #[should_panic] // FIXME - 32-bit msvc unwinding broken
+    #[cfg_attr(all(target_arch="x86", target_env="msvc"), ignore)]
+    fn test_quality_invalid2() {
+        q(2.0);
+    }
+
+    #[test]
+    fn test_fuzzing_bugs() {
+        assert!("99999;".parse::<QualityItem<String>>().is_err());
+        assert!("\x0d;;;=\u{d6aa}==".parse::<QualityItem<String>>().is_err())
+    }
+}

src/httpcodes.rs

@@ -19,7 +19,7 @@ pub const HttpMultiStatus: StaticResponse = StaticResponse(StatusCode::MULTI_STA
 pub const HttpAlreadyReported: StaticResponse = StaticResponse(StatusCode::ALREADY_REPORTED);
 
 pub const HttpMultipleChoices: StaticResponse = StaticResponse(StatusCode::MULTIPLE_CHOICES);
-pub const HttpMovedPermanenty: StaticResponse = StaticResponse(StatusCode::MOVED_PERMANENTLY);
+pub const HttpMovedPermanently: StaticResponse = StaticResponse(StatusCode::MOVED_PERMANENTLY);
 pub const HttpFound: StaticResponse = StaticResponse(StatusCode::FOUND);
 pub const HttpSeeOther: StaticResponse = StaticResponse(StatusCode::SEE_OTHER);
 pub const HttpNotModified: StaticResponse = StaticResponse(StatusCode::NOT_MODIFIED);

src/httpmessage.rs

@@ -12,6 +12,7 @@ use encoding::label::encoding_from_whatwg_label;
 use http::{header, HeaderMap};
 
 use json::JsonBody;
+use header::Header;
 use multipart::Multipart;
 use error::{ParseError, ContentTypeError,
             HttpRangeError, PayloadError, UrlencodedError};
@@ -23,6 +24,16 @@ pub trait HttpMessage {
     /// Read the message headers.
     fn headers(&self) -> &HeaderMap;
 
+    #[doc(hidden)]
+    /// Get a header
+    fn get_header<H: Header>(&self) -> Option<H> where Self: Sized {
+        if self.headers().contains_key(H::name()) {
+            H::parse(self).ok()
+        } else {
+            None
+        }
+    }
+    
     /// Read the request content type. If request does not contain
     /// *Content-Type* header, empty str get returned.
     fn content_type(&self) -> &str {

src/httprequest.rs

@@ -5,6 +5,7 @@ use std::net::SocketAddr;
 use bytes::Bytes;
 use cookie::Cookie;
 use futures::{Async, Stream, Poll};
+use futures_cpupool::CpuPool;
 use failure;
 use url::{Url, form_urlencoded};
 use http::{header, Uri, Method, Version, HeaderMap, Extensions};
@@ -96,7 +97,8 @@ impl HttpRequest<()> {
     /// Construct a new Request.
     #[inline]
     pub fn new(method: Method, uri: Uri,
-               version: Version, headers: HeaderMap, payload: Option<Payload>) -> HttpRequest
+               version: Version, headers: HeaderMap, payload: Option<Payload>)
+               -> HttpRequest
     {
         HttpRequest(
             SharedHttpInnerMessage::from_message(HttpInnerMessage {
@@ -119,7 +121,7 @@ impl HttpRequest<()> {
     }
 
     #[inline(always)]
-    #[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
+    #[cfg_attr(feature="cargo-clippy", allow(inline_always))]
     pub(crate) fn from_message(msg: SharedHttpInnerMessage) -> HttpRequest {
         HttpRequest(msg, None, None)
     }
@@ -129,12 +131,6 @@ impl HttpRequest<()> {
     pub fn with_state<S>(self, state: Rc<S>, router: Router) -> HttpRequest<S> {
         HttpRequest(self.0, Some(state), Some(router))
     }
-
-    #[cfg(test)]
-    /// Construct new http request with state.
-    pub(crate) fn with_state_no_router<S>(self, state: Rc<S>) -> HttpRequest<S> {
-        HttpRequest(self.0, Some(state), None)
-    }
 }
 
 
@@ -156,7 +152,7 @@ impl<S> HttpRequest<S> {
     #[inline]
     /// Construct new http request without state.
     pub(crate) fn without_state(&self) -> HttpRequest {
-        HttpRequest(self.0.clone(), None, None)
+        HttpRequest(self.0.clone(), None, self.2.clone())
     }
 
     /// get mutable reference for inner message
@@ -184,12 +180,20 @@ impl<S> HttpRequest<S> {
         self.1.as_ref().unwrap()
     }
 
-    /// Protocol extensions.
+    /// Request extensions
     #[inline]
     pub fn extensions(&mut self) -> &mut Extensions {
         &mut self.as_mut().extensions
     }
 
+    /// Default `CpuPool`
+    #[inline]
+    #[doc(hidden)]
+    pub fn cpu_pool(&self) -> &CpuPool {
+        self.router().expect("HttpRequest has to have Router instance")
+            .server_settings().cpu_pool()
+    }
+
     #[doc(hidden)]
     pub fn prefix_len(&self) -> usize {
         if let Some(router) = self.router() { router.prefix().len() } else { 0 }
@@ -330,11 +334,12 @@ impl<S> HttpRequest<S> {
         if self.as_ref().cookies.is_none() {
             let msg = self.as_mut();
             let mut cookies = Vec::new();
-            if let Some(val) = msg.headers.get(header::COOKIE) {
-                let s = str::from_utf8(val.as_bytes())
-                    .map_err(CookieParseError::from)?;
-                for cookie in s.split("; ") {
-                    cookies.push(Cookie::parse_encoded(cookie)?.into_owned());
+            for hdr in msg.headers.get_all(header::COOKIE) {
+                let s = str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
+                for cookie_str in s.split(';').map(|s| s.trim()) {
+                    if !cookie_str.is_empty() {
+                        cookies.push(Cookie::parse_encoded(cookie_str)?.into_owned());
+                    }
                 }
             }
             msg.cookies = Some(cookies)
@@ -365,7 +370,7 @@ impl<S> HttpRequest<S> {
 
     /// Get mutable reference to request's Params.
     #[inline]
-    pub(crate) fn match_info_mut(&mut self) -> &mut Params {
+    pub fn match_info_mut(&mut self) -> &mut Params {
         unsafe{ mem::transmute(&mut self.as_mut().params) }
     }
 
@@ -384,6 +389,15 @@ impl<S> HttpRequest<S> {
         self.as_ref().method == Method::CONNECT
     }
 
+    /// Set read buffer capacity
+    ///
+    /// Default buffer capacity is 32Kb.
+    pub fn set_read_buffer_capacity(&mut self, cap: usize) {
+        if let Some(ref mut payload) = self.as_mut().payload {
+            payload.set_read_buffer_capacity(cap)
+        }
+    }
+
     #[cfg(test)]
     pub(crate) fn payload(&self) -> &Payload {
         let msg = self.as_mut();
@@ -478,13 +492,8 @@ impl<S> fmt::Debug for HttpRequest<S> {
             let _ = write!(f, "  params: {:?}\n", self.as_ref().params);
         }
         let _ = write!(f, "  headers:\n");
-        for key in self.as_ref().headers.keys() {
-            let vals: Vec<_> = self.as_ref().headers.get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        for (key, val) in self.as_ref().headers.iter() {
+            let _ = write!(f, "    {:?}: {:?}\n", key, val);
         }
         res
     }
@@ -522,8 +531,10 @@ mod tests {
 
     #[test]
     fn test_request_cookies() {
-        let req = TestRequest::with_header(
-            header::COOKIE, "cookie1=value1; cookie2=value2").finish();
+        let req = TestRequest::default()
+            .header(header::COOKIE, "cookie1=value1")
+            .header(header::COOKIE, "cookie2=value2")
+            .finish();
         {
             let cookies = req.cookies().unwrap();
             assert_eq!(cookies.len(), 2);
@@ -567,8 +578,9 @@ mod tests {
 
     #[test]
     fn test_url_for() {
-        let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
-            .finish_no_router();
+        let req2 = HttpRequest::default();
+        assert_eq!(req2.url_for("unknown", &["test"]),
+                   Err(UrlGenerationError::RouterNotAvailable));
 
         let mut resource = Resource::<()>::default();
         resource.name("index");
@@ -577,10 +589,8 @@ mod tests {
         assert!(router.has_route("/user/test.html"));
         assert!(!router.has_route("/test/unknown"));
 
-        assert_eq!(req.url_for("unknown", &["test"]),
-                   Err(UrlGenerationError::RouterNotAvailable));
-
-        let req = req.with_state(Rc::new(()), router);
+        let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
+            .finish_with_router(router);
 
         assert_eq!(req.url_for("unknown", &["test"]),
                    Err(UrlGenerationError::ResourceNotFound));

src/httpresponse.rs

@@ -6,6 +6,7 @@ use std::collections::VecDeque;
 
 use cookie::{Cookie, CookieJar};
 use bytes::{Bytes, BytesMut, BufMut};
+use futures::Stream;
 use http::{StatusCode, Version, HeaderMap, HttpTryFrom, Error as HttpError};
 use http::header::{self, HeaderName, HeaderValue};
 use serde_json;
@@ -14,9 +15,13 @@ use serde::Serialize;
 use body::Body;
 use error::Error;
 use handler::Responder;
-use headers::ContentEncoding;
+use header::{Header, IntoHeaderValue, ContentEncoding};
 use httprequest::HttpRequest;
 
+/// max write buffer size 64k
+pub(crate) const MAX_WRITE_BUFFER_SIZE: usize = 65_536;
+
+
 /// Represents various types of connection
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum ConnectionType {
@@ -197,6 +202,16 @@ impl HttpResponse {
     pub(crate) fn set_response_size(&mut self, size: u64) {
         self.get_mut().response_size = size;
     }
+
+    /// Set write buffer capacity
+    pub fn write_buffer_capacity(&self) -> usize {
+        self.get_ref().write_capacity
+    }
+
+    /// Set write buffer capacity
+    pub fn set_write_buffer_capacity(&mut self, cap: usize) {
+        self.get_mut().write_capacity = cap;
+    }
 }
 
 impl fmt::Debug for HttpResponse {
@@ -206,13 +221,8 @@ impl fmt::Debug for HttpResponse {
                          self.get_ref().reason.unwrap_or(""));
         let _ = write!(f, "  encoding: {:?}\n", self.get_ref().encoding);
         let _ = write!(f, "  headers:\n");
-        for key in self.get_ref().headers.keys() {
-            let vals: Vec<_> = self.get_ref().headers.get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        for (key, val) in self.get_ref().headers.iter() {
+            let _ = write!(f, "    {:?}: {:?}\n", key, val);
         }
         res
     }
@@ -230,6 +240,15 @@ pub struct HttpResponseBuilder {
 }
 
 impl HttpResponseBuilder {
+    /// Set HTTP status code of this response.
+    #[inline]
+    pub fn status(&mut self, status: StatusCode) -> &mut Self {
+        if let Some(parts) = parts(&mut self.response, &self.err) {
+            parts.status = status;
+        }
+        self
+    }
+
     /// Set HTTP version of this response.
     ///
     /// By default response's http version depends on request's version.
@@ -241,6 +260,34 @@ impl HttpResponseBuilder {
         self
     }
 
+    /// Set a header.
+    ///
+    /// ```rust
+    /// # extern crate actix_web;
+    /// # use actix_web::*;
+    /// # use actix_web::httpcodes::*;
+    /// #
+    /// use actix_web::header;
+    ///
+    /// fn index(req: HttpRequest) -> Result<HttpResponse> {
+    ///     Ok(HttpOk.build()
+    ///         .set(header::IfModifiedSince("Sun, 07 Nov 1994 08:48:37 GMT".parse()?))
+    ///         .finish()?)
+    /// }
+    /// fn main() {}
+    /// ```
+    #[doc(hidden)]
+    pub fn set<H: Header>(&mut self, hdr: H) -> &mut Self
+    {
+        if let Some(parts) = parts(&mut self.response, &self.err) {
+            match hdr.try_into() {
+                Ok(value) => { parts.headers.append(H::name(), value); }
+                Err(e) => self.err = Some(e.into()),
+            }
+        }
+        self
+    }
+
     /// Set a header.
     ///
     /// ```rust
@@ -261,12 +308,12 @@ impl HttpResponseBuilder {
     /// ```
     pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
         where HeaderName: HttpTryFrom<K>,
-              HeaderValue: HttpTryFrom<V>
+              V: IntoHeaderValue,
     {
         if let Some(parts) = parts(&mut self.response, &self.err) {
             match HeaderName::try_from(key) {
                 Ok(key) => {
-                    match HeaderValue::try_from(value) {
+                    match value.try_into() {
                         Ok(value) => { parts.headers.append(key, value); }
                         Err(e) => self.err = Some(e.into()),
                     }
@@ -429,6 +476,20 @@ impl HttpResponseBuilder {
         self
     }
 
+    /// Set write buffer capacity
+    ///
+    /// This parameter makes sense only for streaming response
+    /// or actor. If write buffer reaches specified capacity, stream or actor get
+    /// paused.
+    ///
+    /// Default write buffer capacity is 64kb
+    pub fn write_buffer_capacity(&mut self, cap: usize) -> &mut Self {
+        if let Some(parts) = parts(&mut self.response, &self.err) {
+            parts.write_capacity = cap;
+        }
+        self
+    }
+
     /// Set a body and generate `HttpResponse`.
     ///
     /// `HttpResponseBuilder` can not be used after this call.
@@ -448,6 +509,15 @@ impl HttpResponseBuilder {
         Ok(HttpResponse(Some(response)))
     }
 
+    /// Set a streaming body and generate `HttpResponse`.
+    ///
+    /// `HttpResponseBuilder` can not be used after this call.
+    pub fn streaming<S>(&mut self, stream: S) -> Result<HttpResponse, HttpError>
+        where S: Stream<Item=Bytes, Error=Error> + 'static,
+    {
+        self.body(Body::Streaming(Box::new(stream)))
+    }
+
     /// Set a json body and generate `HttpResponse`
     ///
     /// `HttpResponseBuilder` can not be used after this call.
@@ -650,6 +720,7 @@ struct InnerHttpResponse {
     chunked: Option<bool>,
     encoding: Option<ContentEncoding>,
     connection_type: Option<ConnectionType>,
+    write_capacity: usize,
     response_size: u64,
     error: Option<Error>,
 }
@@ -668,6 +739,7 @@ impl InnerHttpResponse {
             encoding: None,
             connection_type: None,
             response_size: 0,
+            write_capacity: MAX_WRITE_BUFFER_SIZE,
             error: None,
         }
     }
@@ -721,6 +793,7 @@ impl Pool {
                 inner.connection_type = None;
                 inner.response_size = 0;
                 inner.error = None;
+                inner.write_capacity = MAX_WRITE_BUFFER_SIZE;
                 v.push_front(inner);
             }
         })
@@ -733,12 +806,16 @@ mod tests {
     use std::str::FromStr;
     use time::Duration;
     use http::{Method, Uri};
+    use http::header::{COOKIE, CONTENT_TYPE, HeaderValue};
     use body::Binary;
-    use {headers, httpcodes};
+    use {header, httpcodes};
 
     #[test]
     fn test_debug() {
-        let resp = HttpResponse::Ok().finish().unwrap();
+        let resp = HttpResponse::Ok()
+            .header(COOKIE, HeaderValue::from_static("cookie1=value1; "))
+            .header(COOKIE, HeaderValue::from_static("cookie2=value2; "))
+            .finish().unwrap();
         let dbg = format!("{:?}", resp);
         assert!(dbg.contains("HttpResponse"));
     }
@@ -746,8 +823,8 @@ mod tests {
     #[test]
     fn test_response_cookies() {
         let mut headers = HeaderMap::new();
-        headers.insert(header::COOKIE,
-                       header::HeaderValue::from_static("cookie1=value1; cookie2=value2"));
+        headers.insert(COOKIE, HeaderValue::from_static("cookie1=value1"));
+        headers.insert(COOKIE, HeaderValue::from_static("cookie2=value2"));
 
         let req = HttpRequest::new(
             Method::GET, Uri::from_str("/").unwrap(), Version::HTTP_11, headers, None);
@@ -755,7 +832,7 @@ mod tests {
 
         let resp = httpcodes::HttpOk
             .build()
-            .cookie(headers::Cookie::build("name", "value")
+            .cookie(header::Cookie::build("name", "value")
                     .domain("www.rust-lang.org")
                     .path("/test")
                     .http_only(true)
@@ -770,7 +847,7 @@ mod tests {
         let mut val: Vec<_> = resp.headers().get_all("Set-Cookie")
             .iter().map(|v| v.to_str().unwrap().to_owned()).collect();
         val.sort();
-        assert!(val[0].starts_with("cookie1=; Max-Age=0;"));
+        assert!(val[0].starts_with("cookie2=; Max-Age=0;"));
         assert_eq!(
             val[1],"name=value; HttpOnly; Path=/test; Domain=www.rust-lang.org; Max-Age=86400");
     }
@@ -803,7 +880,7 @@ mod tests {
     fn test_content_type() {
         let resp = HttpResponse::build(StatusCode::OK)
             .content_type("text/plain").body(Body::Empty).unwrap();
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/plain")
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/plain")
     }
 
     #[test]
@@ -820,18 +897,18 @@ mod tests {
     fn test_json() {
         let resp = HttpResponse::build(StatusCode::OK)
             .json(vec!["v1", "v2", "v3"]).unwrap();
-        let ct = resp.headers().get(header::CONTENT_TYPE).unwrap();
-        assert_eq!(ct, header::HeaderValue::from_static("application/json"));
+        let ct = resp.headers().get(CONTENT_TYPE).unwrap();
+        assert_eq!(ct, HeaderValue::from_static("application/json"));
         assert_eq!(*resp.body(), Body::from(Bytes::from_static(b"[\"v1\",\"v2\",\"v3\"]")));
     }
 
     #[test]
     fn test_json_ct() {
         let resp = HttpResponse::build(StatusCode::OK)
-            .header(header::CONTENT_TYPE, "text/json")
+            .header(CONTENT_TYPE, "text/json")
             .json(vec!["v1", "v2", "v3"]).unwrap();
-        let ct = resp.headers().get(header::CONTENT_TYPE).unwrap();
-        assert_eq!(ct, header::HeaderValue::from_static("text/json"));
+        let ct = resp.headers().get(CONTENT_TYPE).unwrap();
+        assert_eq!(ct, HeaderValue::from_static("text/json"));
         assert_eq!(*resp.body(), Body::from(Bytes::from_static(b"[\"v1\",\"v2\",\"v3\"]")));
     }
 
@@ -850,89 +927,89 @@ mod tests {
 
         let resp: HttpResponse = "test".into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test"));
 
         let resp: HttpResponse = "test".respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test"));
 
         let resp: HttpResponse = b"test".as_ref().into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(b"test".as_ref()));
 
         let resp: HttpResponse = b"test".as_ref().respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(b"test".as_ref()));
 
         let resp: HttpResponse = "test".to_owned().into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test".to_owned()));
 
         let resp: HttpResponse = "test".to_owned().respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from("test".to_owned()));
 
         let resp: HttpResponse = (&"test".to_owned()).into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(&"test".to_owned()));
 
         let resp: HttpResponse = (&"test".to_owned()).respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("text/plain; charset=utf-8"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("text/plain; charset=utf-8"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(&"test".to_owned()));
 
         let b = Bytes::from_static(b"test");
         let resp: HttpResponse = b.into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(Bytes::from_static(b"test")));
 
         let b = Bytes::from_static(b"test");
         let resp: HttpResponse = b.respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(Bytes::from_static(b"test")));
 
         let b = BytesMut::from("test");
         let resp: HttpResponse = b.into();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(BytesMut::from("test")));
 
         let b = BytesMut::from("test");
         let resp: HttpResponse = b.respond_to(req.clone()).ok().unwrap();
         assert_eq!(resp.status(), StatusCode::OK);
-        assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
-                   header::HeaderValue::from_static("application/octet-stream"));
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(),
+                   HeaderValue::from_static("application/octet-stream"));
         assert_eq!(resp.status(), StatusCode::OK);
         assert_eq!(resp.body().binary().unwrap(), &Binary::from(BytesMut::from("test")));
     }

src/json.rs

@@ -2,6 +2,7 @@ use bytes::{Bytes, BytesMut};
 use futures::{Poll, Future, Stream};
 use http::header::CONTENT_LENGTH;
 
+use mime;
 use serde_json;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
@@ -82,7 +83,6 @@ impl<T: Serialize> Responder for Json<T> {
 /// ```
 pub struct JsonBody<T, U: DeserializeOwned>{
     limit: usize,
-    ct: &'static str,
     req: Option<T>,
     fut: Option<Box<Future<Item=U, Error=JsonPayloadError>>>,
 }
@@ -95,7 +95,6 @@ impl<T, U: DeserializeOwned> JsonBody<T, U> {
             limit: 262_144,
             req: Some(req),
             fut: None,
-            ct: "application/json",
         }
     }
 
@@ -104,15 +103,6 @@ impl<T, U: DeserializeOwned> JsonBody<T, U> {
         self.limit = limit;
         self
     }
-
-    /// Set allowed content type.
-    ///
-    /// By default *application/json* content type is used. Set content type
-    /// to empty string if you want to disable content type check.
-    pub fn content_type(mut self, ct: &'static str) -> Self {
-        self.ct = ct;
-        self
-    }
 }
 
 impl<T, U: DeserializeOwned + 'static> Future for JsonBody<T, U>
@@ -135,7 +125,13 @@ impl<T, U: DeserializeOwned + 'static> Future for JsonBody<T, U>
                 }
             }
             // check content-type
-            if !self.ct.is_empty() && req.content_type() != self.ct {
+
+            let json = if let Ok(Some(mime)) = req.mime_type() {
+                mime.subtype() == mime::JSON || mime.suffix() == Some(mime::JSON)
+            } else {
+                false
+            };
+            if !json {
                 return Err(JsonPayloadError::ContentType)
             }
 
@@ -200,8 +196,8 @@ mod tests {
 
         let mut req = HttpRequest::default();
         req.headers_mut().insert(header::CONTENT_TYPE,
-                                 header::HeaderValue::from_static("application/json"));
-        let mut json = req.json::<MyObject>().content_type("text/json");
+                                 header::HeaderValue::from_static("application/text"));
+        let mut json = req.json::<MyObject>();
         assert_eq!(json.poll().err().unwrap(), JsonPayloadError::ContentType);
 
         let mut req = HttpRequest::default();

src/lib.rs

@@ -38,7 +38,7 @@
 //! * Graceful server shutdown
 //! * Multipart streams
 //! * SSL support with openssl or native-tls
-//! * Middlewares (`Logger`, `Session`, `CORS`, `DefaultHeaders`)
+//! * Middlewares (`Logger`, `Session`, `CORS`, `CSRF`, `DefaultHeaders`)
 //! * Built on top of [Actix actor framework](https://github.com/actix/actix).
 
 #![cfg_attr(actix_nightly, feature(
@@ -61,6 +61,7 @@ extern crate bitflags;
 extern crate failure;
 #[macro_use]
 extern crate futures;
+extern crate futures_cpupool;
 extern crate tokio_io;
 extern crate tokio_core;
 extern crate mio;
@@ -71,6 +72,7 @@ extern crate httparse;
 extern crate http_range;
 extern crate mime;
 extern crate mime_guess;
+extern crate language_tags;
 extern crate rand;
 extern crate url;
 extern crate libc;
@@ -120,6 +122,7 @@ pub mod client;
 pub mod fs;
 pub mod ws;
 pub mod error;
+pub mod header;
 pub mod httpcodes;
 pub mod multipart;
 pub mod middleware;
@@ -133,7 +136,7 @@ pub use application::Application;
 pub use httpmessage::HttpMessage;
 pub use httprequest::HttpRequest;
 pub use httpresponse::HttpResponse;
-pub use handler::{Reply, Responder, NormalizePath, AsyncResponder};
+pub use handler::{Either, Reply, Responder, NormalizePath, AsyncResponder};
 pub use route::Route;
 pub use resource::Resource;
 pub use context::HttpContext;
@@ -147,34 +150,20 @@ pub(crate) const HAS_OPENSSL: bool = true;
 #[cfg(not(feature="openssl"))]
 pub(crate) const HAS_OPENSSL: bool = false;
 
-// #[cfg(feature="tls")]
-// pub(crate) const HAS_TLS: bool = true;
-// #[cfg(not(feature="tls"))]
-// pub(crate) const HAS_TLS: bool = false;
-
+#[cfg(feature="tls")]
+pub(crate) const HAS_TLS: bool = true;
+#[cfg(not(feature="tls"))]
+pub(crate) const HAS_TLS: bool = false;
 
+#[doc(hidden)]
+#[deprecated(since="0.4.4", note="please use `actix::header` module")]
 pub mod headers {
 //! Headers implementation
 
     pub use httpresponse::ConnectionType;
-
     pub use cookie::{Cookie, CookieBuilder};
     pub use http_range::HttpRange;
-
-    /// Represents supported types of content encodings
-    #[derive(Copy, Clone, PartialEq, Debug)]
-    pub enum ContentEncoding {
-        /// Automatically select encoding based on encoding negotiation
-        Auto,
-        /// A format using the Brotli algorithm
-        Br,
-        /// A format using the zlib structure with deflate algorithm
-        Deflate,
-        /// Gzip algorithm
-        Gzip,
-        /// Indicates the identity function (i.e. no compression, nor modification)
-        Identity,
-    }
+    pub use header::ContentEncoding;
 }
 
 pub mod dev {

src/middleware/cors.rs

@@ -349,8 +349,7 @@ impl<S> Middleware<S> for Cors {
                 if self.send_wildcard {
                     resp.headers_mut().insert(
                         header::ACCESS_CONTROL_ALLOW_ORIGIN, HeaderValue::from_static("*"));
-                } else {
-                    let origin = req.headers().get(header::ORIGIN).unwrap();
+                } else if let Some(origin) = req.headers().get(header::ORIGIN) {
                     resp.headers_mut().insert(
                         header::ACCESS_CONTROL_ALLOW_ORIGIN, origin.clone());
                 }
@@ -807,6 +806,25 @@ mod tests {
         assert!(cors.start(&mut req).unwrap().is_done());
     }
 
+    #[test]
+    fn test_no_origin_response() {
+        let cors = Cors::build().finish().unwrap();
+
+        let mut req = TestRequest::default().method(Method::GET).finish();
+        let resp: HttpResponse = HttpOk.into();
+        let resp = cors.response(&mut req, resp).unwrap().response();
+        assert!(resp.headers().get(header::ACCESS_CONTROL_ALLOW_ORIGIN).is_none());
+
+        let mut req = TestRequest::with_header(
+            "Origin", "https://www.example.com")
+            .method(Method::OPTIONS)
+            .finish();
+        let resp = cors.response(&mut req, resp).unwrap().response();
+        assert_eq!(
+            &b"https://www.example.com"[..],
+            resp.headers().get(header::ACCESS_CONTROL_ALLOW_ORIGIN).unwrap().as_bytes());
+    }
+
     #[test]
     fn test_response() {
         let cors = Cors::build()

src/middleware/csrf.rs

@@ -0,0 +1,298 @@
+//! A filter for cross-site request forgery (CSRF).
+//!
+//! This middleware is stateless and [based on request
+//! headers](https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)_Prevention_Cheat_Sheet#Verifying_Same_Origin_with_Standard_Headers).
+//!
+//! By default requests are allowed only if one of these is true:
+//!
+//! * The request method is safe (`GET`, `HEAD`, `OPTIONS`). It is the
+//!   applications responsibility to ensure these methods cannot be used to
+//!   execute unwanted actions. Note that upgrade requests for websockets are
+//!   also considered safe.
+//! * The `Origin` header (added automatically by the browser) matches one
+//!   of the allowed origins.
+//! * There is no `Origin` header but the `Referer` header matches one of
+//!   the allowed origins.
+//!
+//! Use [`CsrfFilterBuilder::allow_xhr()`](struct.CsrfFilterBuilder.html#method.allow_xhr)
+//! if you want to allow requests with unsafe methods via
+//! [CORS](../cors/struct.Cors.html).
+//!
+//! # Example
+//!
+//! ```
+//! # extern crate actix_web;
+//! # use actix_web::*;
+//!
+//! use actix_web::middleware::csrf;
+//!
+//! fn handle_post(_req: HttpRequest) -> &'static str {
+//!     "This action should only be triggered with requests from the same site"
+//! }
+//!
+//! fn main() {
+//!     let app = Application::new()
+//!         .middleware(
+//!             csrf::CsrfFilter::build()
+//!                 .allowed_origin("https://www.example.com")
+//!                 .finish())
+//!         .resource("/", |r| {
+//!             r.method(Method::GET).f(|_| httpcodes::HttpOk);
+//!             r.method(Method::POST).f(handle_post);
+//!         })
+//!         .finish();
+//! }
+//! ```
+//!
+//! In this example the entire application is protected from CSRF.
+
+use std::borrow::Cow;
+use std::collections::HashSet;
+
+use bytes::Bytes;
+use error::{Result, ResponseError};
+use http::{HeaderMap, HttpTryFrom, Uri, header};
+use httprequest::HttpRequest;
+use httpresponse::HttpResponse;
+use httpmessage::HttpMessage;
+use httpcodes::HttpForbidden;
+use middleware::{Middleware, Started};
+
+/// Potential cross-site request forgery detected.
+#[derive(Debug, Fail)]
+pub enum CsrfError {
+    /// The HTTP request header `Origin` was required but not provided.
+    #[fail(display="Origin header required")]
+    MissingOrigin,
+    /// The HTTP request header `Origin` could not be parsed correctly.
+    #[fail(display="Could not parse Origin header")]
+    BadOrigin,
+    /// The cross-site request was denied.
+    #[fail(display="Cross-site request denied")]
+    CsrDenied,
+}
+
+impl ResponseError for CsrfError {
+    fn error_response(&self) -> HttpResponse {
+        HttpForbidden.build().body(self.to_string()).unwrap()
+    }
+}
+
+fn uri_origin(uri: &Uri) -> Option<String> {
+    match (uri.scheme_part(), uri.host(), uri.port()) {
+        (Some(scheme), Some(host), Some(port)) => {
+            Some(format!("{}://{}:{}", scheme, host, port))
+        }
+        (Some(scheme), Some(host), None) => {
+            Some(format!("{}://{}", scheme, host))
+        }
+        _ => None
+    }
+}
+
+fn origin(headers: &HeaderMap) -> Option<Result<Cow<str>, CsrfError>> {
+    headers.get(header::ORIGIN)
+        .map(|origin| {
+            origin
+                .to_str()
+                .map_err(|_| CsrfError::BadOrigin)
+                .map(|o| o.into())
+        })
+        .or_else(|| {
+            headers.get(header::REFERER)
+                .map(|referer| {
+                    Uri::try_from(Bytes::from(referer.as_bytes()))
+                        .ok()
+                        .as_ref()
+                        .and_then(uri_origin)
+                        .ok_or(CsrfError::BadOrigin)
+                        .map(|o| o.into())
+                })
+        })
+}
+
+/// A middleware that filters cross-site requests.
+pub struct CsrfFilter {
+    origins: HashSet<String>,
+    allow_xhr: bool,
+    allow_missing_origin: bool,
+    allow_upgrade: bool,
+}
+
+impl CsrfFilter {
+    /// Start building a `CsrfFilter`.
+    pub fn build() -> CsrfFilterBuilder {
+        CsrfFilterBuilder {
+            csrf: CsrfFilter {
+                origins: HashSet::new(),
+                allow_xhr: false,
+                allow_missing_origin: false,
+                allow_upgrade: false,
+            }
+        }
+    }
+
+    fn validate<S>(&self, req: &mut HttpRequest<S>) -> Result<(), CsrfError> {
+        let is_upgrade = req.headers().contains_key(header::UPGRADE);
+        let is_safe = req.method().is_safe() && (self.allow_upgrade || !is_upgrade);
+
+        if is_safe || (self.allow_xhr && req.headers().contains_key("x-requested-with")) {
+            Ok(())
+        } else if let Some(header) = origin(req.headers()) {
+            match header {
+                Ok(ref origin) if self.origins.contains(origin.as_ref()) => Ok(()),
+                Ok(_) => Err(CsrfError::CsrDenied),
+                Err(err) => Err(err),
+            }
+        } else if self.allow_missing_origin {
+            Ok(())
+        } else {
+            Err(CsrfError::MissingOrigin)
+        }
+    }
+}
+
+impl<S> Middleware<S> for CsrfFilter {
+    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
+        self.validate(req)?;
+        Ok(Started::Done)
+    }
+}
+
+/// Used to build a `CsrfFilter`.
+///
+/// To construct a CSRF filter:
+///
+/// 1. Call [`CsrfFilter::build`](struct.CsrfFilter.html#method.build) to
+///    start building.
+/// 2. [Add](struct.CsrfFilterBuilder.html#method.allowed_origin) allowed
+///    origins.
+/// 3. Call [finish](struct.CsrfFilterBuilder.html#method.finish) to retrieve
+///    the constructed filter.
+///
+/// # Example
+///
+/// ```
+/// use actix_web::middleware::csrf;
+///
+/// let csrf = csrf::CsrfFilter::build()
+///     .allowed_origin("https://www.example.com")
+///     .finish();
+/// ```
+pub struct CsrfFilterBuilder {
+    csrf: CsrfFilter,
+}
+
+impl CsrfFilterBuilder {
+    /// Add an origin that is allowed to make requests. Will be verified
+    /// against the `Origin` request header.
+    pub fn allowed_origin(mut self, origin: &str) -> CsrfFilterBuilder {
+        self.csrf.origins.insert(origin.to_owned());
+        self
+    }
+
+    /// Allow all requests with an `X-Requested-With` header.
+    ///
+    /// A cross-site attacker should not be able to send requests with custom
+    /// headers unless a CORS policy whitelists them. Therefore it should be
+    /// safe to allow requests with an `X-Requested-With` header (added
+    /// automatically by many JavaScript libraries).
+    ///
+    /// This is disabled by default, because in Safari it is possible to
+    /// circumvent this using redirects and Flash.
+    ///
+    /// Use this method to enable more lax filtering.
+    pub fn allow_xhr(mut self) -> CsrfFilterBuilder {
+        self.csrf.allow_xhr = true;
+        self
+    }
+
+    /// Allow requests if the expected `Origin` header is missing (and
+    /// there is no `Referer` to fall back on).
+    ///
+    /// The filter is conservative by default, but it should be safe to allow
+    /// missing `Origin` headers because a cross-site attacker cannot prevent
+    /// the browser from sending `Origin` on unsafe requests.
+    pub fn allow_missing_origin(mut self) -> CsrfFilterBuilder {
+        self.csrf.allow_missing_origin = true;
+        self
+    }
+
+    /// Allow cross-site upgrade requests (for example to open a WebSocket).
+    pub fn allow_upgrade(mut self) -> CsrfFilterBuilder {
+        self.csrf.allow_upgrade = true;
+        self
+    }
+
+    /// Finishes building the `CsrfFilter` instance.
+    pub fn finish(self) -> CsrfFilter {
+        self.csrf
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::Method;
+    use test::TestRequest;
+
+    #[test]
+    fn test_safe() {
+        let csrf = CsrfFilter::build()
+            .allowed_origin("https://www.example.com")
+            .finish();
+
+        let mut req = TestRequest::with_header("Origin", "https://www.w3.org")
+            .method(Method::HEAD)
+            .finish();
+
+        assert!(csrf.start(&mut req).is_ok());
+    }
+
+    #[test]
+    fn test_csrf() {
+        let csrf = CsrfFilter::build()
+            .allowed_origin("https://www.example.com")
+            .finish();
+
+        let mut req = TestRequest::with_header("Origin", "https://www.w3.org")
+            .method(Method::POST)
+            .finish();
+
+        assert!(csrf.start(&mut req).is_err());
+    }
+
+    #[test]
+    fn test_referer() {
+        let csrf = CsrfFilter::build()
+            .allowed_origin("https://www.example.com")
+            .finish();
+
+        let mut req = TestRequest::with_header("Referer", "https://www.example.com/some/path?query=param")
+            .method(Method::POST)
+            .finish();
+
+        assert!(csrf.start(&mut req).is_ok());
+    }
+
+    #[test]
+    fn test_upgrade() {
+        let strict_csrf = CsrfFilter::build()
+            .allowed_origin("https://www.example.com")
+            .finish();
+
+        let lax_csrf = CsrfFilter::build()
+            .allowed_origin("https://www.example.com")
+            .allow_upgrade()
+            .finish();
+
+        let mut req = TestRequest::with_header("Origin", "https://cswsh.com")
+            .header("Connection", "Upgrade")
+            .header("Upgrade", "websocket")
+            .method(Method::GET)
+            .finish();
+
+        assert!(strict_csrf.start(&mut req).is_err());
+        assert!(lax_csrf.start(&mut req).is_ok());
+    }
+}

src/middleware/mod.rs

@@ -6,11 +6,16 @@ use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
 
 mod logger;
+
+#[cfg(feature = "session")]
 mod session;
 mod defaultheaders;
 pub mod cors;
+pub mod csrf;
 pub use self::logger::Logger;
 pub use self::defaultheaders::{DefaultHeaders, DefaultHeadersBuilder};
+
+#[cfg(feature = "session")]
 pub use self::session::{RequestSession, Session, SessionImpl, SessionBackend, SessionStorage,
                         CookieSessionError, CookieSessionBackend, CookieSessionBackendBuilder};
 

src/multipart.rs

@@ -130,7 +130,7 @@ impl<S> InnerMultipart<S> where S: Stream<Item=Bytes, Error=PayloadError> {
 
     fn read_headers(payload: &mut PayloadHelper<S>) -> Poll<HeaderMap, MultipartError>
     {
-        match payload.readuntil(b"\r\n\r\n")? {
+        match payload.read_until(b"\r\n\r\n")? {
             Async::NotReady => Ok(Async::NotReady),
             Async::Ready(None) => Err(MultipartError::Incomplete),
             Async::Ready(Some(bytes)) => {
@@ -399,13 +399,8 @@ impl<S> fmt::Debug for Field<S> {
         let res = write!(f, "\nMultipartField: {}\n", self.ct);
         let _ = write!(f, "  boundary: {}\n", self.inner.borrow().boundary);
         let _ = write!(f, "  headers:\n");
-        for key in self.headers.keys() {
-            let vals: Vec<_> = self.headers.get_all(key).iter().collect();
-            if vals.len() > 1 {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals);
-            } else {
-                let _ = write!(f, "    {:?}: {:?}\n", key, vals[0]);
-            }
+        for (key, val) in self.headers.iter() {
+            let _ = write!(f, "    {:?}: {:?}\n", key, val);
         }
         res
     }
@@ -474,23 +469,23 @@ impl<S> InnerField<S> where S: Stream<Item=Bytes, Error=PayloadError> {
     fn read_stream(payload: &mut PayloadHelper<S>, boundary: &str)
                    -> Poll<Option<Bytes>, MultipartError>
     {
-        match payload.readuntil(b"\r")? {
+        match payload.read_until(b"\r")? {
             Async::NotReady => Ok(Async::NotReady),
             Async::Ready(None) => Err(MultipartError::Incomplete),
             Async::Ready(Some(mut chunk)) => {
                 if chunk.len() == 1 {
                     payload.unread_data(chunk);
-                    match payload.readexactly(boundary.len() + 4)? {
+                    match payload.read_exact(boundary.len() + 4)? {
                         Async::NotReady => Ok(Async::NotReady),
                         Async::Ready(None) => Err(MultipartError::Incomplete),
                         Async::Ready(Some(chunk)) => {
                             if &chunk[..2] == b"\r\n" && &chunk[2..4] == b"--" &&
                                 &chunk[4..] == boundary.as_bytes()
                             {
-                                payload.unread_data(chunk.freeze());
+                                payload.unread_data(chunk);
                                 Ok(Async::Ready(None))
                             } else {
-                                Ok(Async::Ready(Some(chunk.freeze())))
+                                Ok(Async::Ready(Some(chunk)))
                             }
                         }
                     }

src/payload.rs

@@ -8,6 +8,10 @@ use futures::{Async, Poll, Stream};
 
 use error::PayloadError;
 
+/// max buffer size 32k
+pub(crate) const MAX_BUFFER_SIZE: usize = 32_768;
+
+
 #[derive(Debug, PartialEq)]
 pub(crate) enum PayloadStatus {
     Read,
@@ -76,6 +80,14 @@ impl Payload {
     pub(crate) fn readall(&self) -> Option<Bytes> {
         self.inner.borrow_mut().readall()
     }
+
+    #[inline]
+    /// Set read buffer capacity
+    ///
+    /// Default buffer capacity is 32Kb.
+    pub fn set_read_buffer_capacity(&mut self, cap: usize) {
+        self.inner.borrow_mut().capacity = cap;
+    }
 }
 
 impl Stream for Payload {
@@ -117,18 +129,21 @@ pub struct PayloadSender {
 
 impl PayloadWriter for PayloadSender {
 
+    #[inline]
     fn set_error(&mut self, err: PayloadError) {
         if let Some(shared) = self.inner.upgrade() {
             shared.borrow_mut().set_error(err)
         }
     }
 
+    #[inline]
     fn feed_eof(&mut self) {
         if let Some(shared) = self.inner.upgrade() {
             shared.borrow_mut().feed_eof()
         }
     }
 
+    #[inline]
     fn feed_data(&mut self, data: Bytes) {
         if let Some(shared) = self.inner.upgrade() {
             shared.borrow_mut().feed_data(data)
@@ -158,6 +173,7 @@ struct Inner {
     err: Option<PayloadError>,
     need_read: bool,
     items: VecDeque<Bytes>,
+    capacity: usize,
 }
 
 impl Inner {
@@ -168,28 +184,34 @@ impl Inner {
             len: 0,
             err: None,
             items: VecDeque::new(),
-            need_read: false,
+            need_read: true,
+            capacity: MAX_BUFFER_SIZE,
         }
     }
 
+    #[inline]
     fn set_error(&mut self, err: PayloadError) {
         self.err = Some(err);
     }
 
+    #[inline]
     fn feed_eof(&mut self) {
         self.eof = true;
     }
 
+    #[inline]
     fn feed_data(&mut self, data: Bytes) {
         self.len += data.len();
-        self.need_read = false;
         self.items.push_back(data);
+        self.need_read = self.len < self.capacity;
     }
 
+    #[inline]
     fn eof(&self) -> bool {
         self.items.is_empty() && self.eof
     }
 
+    #[inline]
     fn len(&self) -> usize {
         self.len
     }
@@ -214,6 +236,7 @@ impl Inner {
     fn readany(&mut self) -> Poll<Option<Bytes>, PayloadError> {
         if let Some(data) = self.items.pop_front() {
             self.len -= data.len();
+            self.need_read = self.len < self.capacity;
             Ok(Async::Ready(Some(data)))
         } else if let Some(err) = self.err.take() {
             Err(err)
@@ -247,6 +270,7 @@ impl<S> PayloadHelper<S> where S: Stream<Item=Bytes, Error=PayloadError> {
         }
     }
 
+    #[inline]
     fn poll_stream(&mut self) -> Poll<bool, PayloadError> {
         self.stream.poll().map(|res| {
             match res {
@@ -261,6 +285,7 @@ impl<S> PayloadHelper<S> where S: Stream<Item=Bytes, Error=PayloadError> {
         })
     }
 
+    #[inline]
     pub fn readany(&mut self) -> Poll<Option<Bytes>, PayloadError> {
         if let Some(data) = self.items.pop_front() {
             self.len -= data.len();
@@ -274,25 +299,85 @@ impl<S> PayloadHelper<S> where S: Stream<Item=Bytes, Error=PayloadError> {
         }
     }
 
-    pub fn readexactly(&mut self, size: usize) -> Poll<Option<BytesMut>, PayloadError> {
+    #[inline]
+    pub fn can_read(&mut self, size: usize) -> Poll<Option<bool>, PayloadError> {
         if size <= self.len {
-            let mut buf = BytesMut::with_capacity(size);
-            while buf.len() < size {
+            Ok(Async::Ready(Some(true)))
+        } else {
+            match self.poll_stream()? {
+                Async::Ready(true) => self.can_read(size),
+                Async::Ready(false) => Ok(Async::Ready(None)),
+                Async::NotReady => Ok(Async::NotReady),
+            }
+        }
+    }
+
+    #[inline]
+    pub fn get_chunk(&mut self) -> Poll<Option<&[u8]>, PayloadError> {
+        if self.items.is_empty() {
+            match self.poll_stream()? {
+                Async::Ready(true) => (),
+                Async::Ready(false) => return Ok(Async::Ready(None)),
+                Async::NotReady => return Ok(Async::NotReady),
+            }
+        }
+        match self.items.front().map(|c| c.as_ref()) {
+            Some(chunk) => Ok(Async::Ready(Some(chunk))),
+            None => Ok(Async::NotReady),
+        }
+    }
+
+    #[inline]
+    pub fn read_exact(&mut self, size: usize) -> Poll<Option<Bytes>, PayloadError> {
+        if size <= self.len {
+            self.len -= size;
+            let mut chunk = self.items.pop_front().unwrap();
+            if size < chunk.len() {
+                let buf = chunk.split_to(size);
+                self.items.push_front(chunk);
+                Ok(Async::Ready(Some(buf)))
+            }
+            else if size == chunk.len() {
+                Ok(Async::Ready(Some(chunk)))
+            }
+            else {
+                let mut buf = BytesMut::with_capacity(size);
+                buf.extend_from_slice(&chunk);
+
+                while buf.len() < size {
+                    let mut chunk = self.items.pop_front().unwrap();
+                    let rem = cmp::min(size - buf.len(), chunk.len());
+                    buf.extend_from_slice(&chunk.split_to(rem));
+                    if !chunk.is_empty() {
+                        self.items.push_front(chunk);
+                    }
+                }
+                Ok(Async::Ready(Some(buf.freeze())))
+            }
+        } else {
+            match self.poll_stream()? {
+                Async::Ready(true) => self.read_exact(size),
+                Async::Ready(false) => Ok(Async::Ready(None)),
+                Async::NotReady => Ok(Async::NotReady),
+            }
+        }
+    }
+
+    #[inline]
+    pub fn drop_payload(&mut self, size: usize) {
+        if size <= self.len {
+            self.len -= size;
+
+            let mut len = 0;
+            while len < size {
                 let mut chunk = self.items.pop_front().unwrap();
-                let rem = cmp::min(size - buf.len(), chunk.len());
-                self.len -= rem;
-                buf.extend_from_slice(&chunk.split_to(rem));
-                if !chunk.is_empty() {
+                let rem = cmp::min(size-len, chunk.len());
+                len += rem;
+                if rem < chunk.len() {
+                    chunk.split_to(rem);
                     self.items.push_front(chunk);
                 }
             }
-            return Ok(Async::Ready(Some(buf)))
-        }
-
-        match self.poll_stream()? {
-            Async::Ready(true) => self.readexactly(size),
-            Async::Ready(false) => Ok(Async::Ready(None)),
-            Async::NotReady => Ok(Async::NotReady),
         }
     }
 
@@ -317,7 +402,7 @@ impl<S> PayloadHelper<S> where S: Stream<Item=Bytes, Error=PayloadError> {
         }
     }
 
-    pub fn readuntil(&mut self, line: &[u8]) -> Poll<Option<Bytes>, PayloadError> {
+    pub fn read_until(&mut self, line: &[u8]) -> Poll<Option<Bytes>, PayloadError> {
         let mut idx = 0;
         let mut num = 0;
         let mut offset = 0;
@@ -366,14 +451,14 @@ impl<S> PayloadHelper<S> where S: Stream<Item=Bytes, Error=PayloadError> {
         }
 
         match self.poll_stream()? {
-            Async::Ready(true) => self.readuntil(line),
+            Async::Ready(true) => self.read_until(line),
             Async::Ready(false) => Ok(Async::Ready(None)),
             Async::NotReady => Ok(Async::NotReady),
         }
     }
 
     pub fn readline(&mut self) -> Poll<Option<Bytes>, PayloadError> {
-        self.readuntil(b"\n")
+        self.read_until(b"\n")
     }
 
     pub fn unread_data(&mut self, data: Bytes) {
@@ -486,21 +571,21 @@ mod tests {
             let (mut sender, payload) = Payload::new(false);
             let mut payload = PayloadHelper::new(payload);
 
-            assert_eq!(Async::NotReady, payload.readexactly(2).ok().unwrap());
+            assert_eq!(Async::NotReady, payload.read_exact(2).ok().unwrap());
 
             sender.feed_data(Bytes::from("line1"));
             sender.feed_data(Bytes::from("line2"));
 
-            assert_eq!(Async::Ready(Some(BytesMut::from("li"))),
-                       payload.readexactly(2).ok().unwrap());
+            assert_eq!(Async::Ready(Some(Bytes::from_static(b"li"))),
+                       payload.read_exact(2).ok().unwrap());
             assert_eq!(payload.len, 3);
 
-            assert_eq!(Async::Ready(Some(BytesMut::from("ne1l"))),
-                       payload.readexactly(4).ok().unwrap());
+            assert_eq!(Async::Ready(Some(Bytes::from_static(b"ne1l"))),
+                       payload.read_exact(4).ok().unwrap());
             assert_eq!(payload.len, 4);
 
             sender.set_error(PayloadError::Incomplete);
-            payload.readexactly(10).err().unwrap();
+            payload.read_exact(10).err().unwrap();
 
             let res: Result<(), ()> = Ok(());
             result(res)
@@ -513,21 +598,21 @@ mod tests {
             let (mut sender, payload) = Payload::new(false);
             let mut payload = PayloadHelper::new(payload);
 
-            assert_eq!(Async::NotReady, payload.readuntil(b"ne").ok().unwrap());
+            assert_eq!(Async::NotReady, payload.read_until(b"ne").ok().unwrap());
 
             sender.feed_data(Bytes::from("line1"));
             sender.feed_data(Bytes::from("line2"));
 
             assert_eq!(Async::Ready(Some(Bytes::from("line"))),
-                       payload.readuntil(b"ne").ok().unwrap());
+                       payload.read_until(b"ne").ok().unwrap());
             assert_eq!(payload.len, 1);
 
             assert_eq!(Async::Ready(Some(Bytes::from("1line2"))),
-                       payload.readuntil(b"2").ok().unwrap());
+                       payload.read_until(b"2").ok().unwrap());
             assert_eq!(payload.len, 0);
 
             sender.set_error(PayloadError::Incomplete);
-            payload.readuntil(b"b").err().unwrap();
+            payload.read_until(b"b").err().unwrap();
 
             let res: Result<(), ()> = Ok(());
             result(res)

src/pipeline.rs

@@ -173,7 +173,8 @@ impl<S: 'static, H: PipelineHandler<S>> HttpHandlerTask for Pipeline<S, H> {
                 PipelineState::None =>
                     return Ok(Async::Ready(true)),
                 PipelineState::Error =>
-                    return Err(io::Error::new(io::ErrorKind::Other, "Internal error").into()),
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other, "Internal error").into()),
                 _ => (),
             }
 

src/resource.rs

@@ -1,6 +1,7 @@
 use std::rc::Rc;
 use std::marker::PhantomData;
 
+use smallvec::SmallVec;
 use http::{Method, StatusCode};
 
 use pred;
@@ -34,7 +35,7 @@ use httpresponse::HttpResponse;
 pub struct Resource<S=()> {
     name: String,
     state: PhantomData<S>,
-    routes: Vec<Route<S>>,
+    routes: SmallVec<[Route<S>; 3]>,
     middlewares: Rc<Vec<Box<Middleware<S>>>>,
 }
 
@@ -43,7 +44,7 @@ impl<S> Default for Resource<S> {
         Resource {
             name: String::new(),
             state: PhantomData,
-            routes: Vec::new(),
+            routes: SmallVec::new(),
             middlewares: Rc::new(Vec::new()) }
     }
 }
@@ -54,7 +55,7 @@ impl<S> Resource<S> {
         Resource {
             name: String::new(),
             state: PhantomData,
-            routes: Vec::new(),
+            routes: SmallVec::new(),
             middlewares: Rc::new(Vec::new()) }
     }
 

src/route.rs

@@ -84,13 +84,13 @@ impl<S: 'static> Route<S> {
     }
 
     /// Set handler object. Usually call to this method is last call
-    /// during route configuration, because it does not return reference to self.
+    /// during route configuration, so it does not return reference to self.
     pub fn h<H: Handler<S>>(&mut self, handler: H) {
         self.handler = InnerHandler::new(handler);
     }
 
     /// Set handler function. Usually call to this method is last call
-    /// during route configuration, because it does not return reference to self.
+    /// during route configuration, so it does not return reference to self.
     pub fn f<F, R>(&mut self, handler: F)
         where F: Fn(HttpRequest<S>) -> R + 'static,
               R: Responder + 'static,
@@ -133,7 +133,7 @@ impl<S: 'static> InnerHandler<S> {
     #[inline]
     pub fn handle(&self, req: HttpRequest<S>) -> Reply {
         // reason: handler is unique per thread,
-        // handler get called from async code, and handler doesn't have side effects
+        // handler get called from async code only
         #[allow(mutable_transmutes)]
         #[cfg_attr(feature = "cargo-clippy", allow(borrowed_box))]
         let h: &mut Box<RouteHandler<S>> = unsafe { mem::transmute(self.0.as_ref()) };

src/router.rs

@@ -148,7 +148,12 @@ impl Pattern {
     ///
     /// Panics if path pattern is wrong.
     pub fn new(name: &str, path: &str) -> Self {
-        let (pattern, elements, is_dynamic) = Pattern::parse(path);
+        Pattern::with_prefix(name, path, "/")
+    }
+
+    /// Parse path pattern and create new `Pattern` instance with custom prefix
+    pub fn with_prefix(name: &str, path: &str, prefix: &str) -> Self {
+        let (pattern, elements, is_dynamic) = Pattern::parse(path, prefix);
 
         let tp = if is_dynamic {
             let re = match Regex::new(&pattern) {
@@ -188,7 +193,9 @@ impl Pattern {
         }
     }
 
-    pub fn match_with_params<'a>(&'a self, path: &'a str, params: &'a mut Params<'a>) -> bool {
+    pub fn match_with_params<'a>(&'a self, path: &'a str, params: &'a mut Params<'a>)
+                                 -> bool
+    {
         match self.tp {
             PatternType::Static(ref s) => s == path,
             PatternType::Dynamic(ref re, ref names) => {
@@ -236,11 +243,11 @@ impl Pattern {
         Ok(path)
     }
 
-    fn parse(pattern: &str) -> (String, Vec<PatternElement>, bool) {
+    fn parse(pattern: &str, prefix: &str) -> (String, Vec<PatternElement>, bool) {
         const DEFAULT_PATTERN: &str = "[^/]+";
 
-        let mut re1 = String::from("^/");
-        let mut re2 = String::from("/");
+        let mut re1 = String::from("^") + prefix;
+        let mut re2 = String::from(prefix);
         let mut el = String::new();
         let mut in_param = false;
         let mut in_param_pattern = false;

src/server/channel.rs

@@ -18,15 +18,6 @@ enum HttpProtocol<T: IoStream, H: 'static> {
     Unknown(Rc<WorkerSettings<H>>, Option<SocketAddr>, T, BytesMut),
 }
 
-impl<T: IoStream, H: 'static> HttpProtocol<T, H> {
-    fn is_unknown(&self) -> bool {
-        match *self {
-            HttpProtocol::Unknown(_, _, _, _) => true,
-            _ => false
-        }
-    }
-}
-
 enum ProtocolKind {
     Http1,
     Http2,
@@ -41,18 +32,18 @@ pub struct HttpChannel<T, H> where T: IoStream, H: HttpHandler + 'static {
 impl<T, H> HttpChannel<T, H> where T: IoStream, H: HttpHandler + 'static
 {
     pub(crate) fn new(settings: Rc<WorkerSettings<H>>,
-                      io: T, peer: Option<SocketAddr>, http2: bool) -> HttpChannel<T, H>
+                      mut io: T, peer: Option<SocketAddr>, http2: bool) -> HttpChannel<T, H>
     {
         settings.add_channel();
+        let _ = io.set_nodelay(true);
+
         if http2 {
             HttpChannel {
-                node: None,
-                proto: Some(HttpProtocol::H2(
+                node: None, proto: Some(HttpProtocol::H2(
                     h2::Http2::new(settings, io, peer, Bytes::new()))) }
         } else {
             HttpChannel {
-                node: None,
-                proto: Some(HttpProtocol::Unknown(
+                node: None, proto: Some(HttpProtocol::Unknown(
                     settings, peer, io, BytesMut::with_capacity(4096))) }
         }
     }
@@ -78,15 +69,18 @@ impl<T, H> Future for HttpChannel<T, H> where T: IoStream, H: HttpHandler + 'sta
     type Error = ();
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if !self.proto.as_ref().map(|p| p.is_unknown()).unwrap_or(false) && self.node.is_none() {
-            self.node = Some(Node::new(self));
-            match self.proto {
+        if !self.node.is_none() {
+            let el = self as *mut _;
+            self.node = Some(Node::new(el));
+            let _ = match self.proto {
                 Some(HttpProtocol::H1(ref mut h1)) =>
-                    h1.settings().head().insert(self.node.as_ref().unwrap()),
+                    self.node.as_ref().map(|n| h1.settings().head().insert(n)),
                 Some(HttpProtocol::H2(ref mut h2)) =>
-                    h2.settings().head().insert(self.node.as_ref().unwrap()),
-                _ => (),
-            }
+                    self.node.as_ref().map(|n| h2.settings().head().insert(n)),
+                Some(HttpProtocol::Unknown(ref mut settings, _, _, _)) =>
+                    self.node.as_ref().map(|n| settings.head().insert(n)),
+                None => unreachable!(),
+            };
         }
 
         let kind = match self.proto {
@@ -95,7 +89,7 @@ impl<T, H> Future for HttpChannel<T, H> where T: IoStream, H: HttpHandler + 'sta
                 match result {
                     Ok(Async::Ready(())) | Err(_) => {
                         h1.settings().remove_channel();
-                        self.node.as_ref().unwrap().remove();
+                        self.node.as_mut().map(|n| n.remove());
                     },
                     _ => (),
                 }
@@ -106,7 +100,7 @@ impl<T, H> Future for HttpChannel<T, H> where T: IoStream, H: HttpHandler + 'sta
                 match result {
                     Ok(Async::Ready(())) | Err(_) => {
                         h2.settings().remove_channel();
-                        self.node.as_ref().unwrap().remove();
+                        self.node.as_mut().map(|n| n.remove());
                     },
                     _ => (),
                 }
@@ -117,6 +111,7 @@ impl<T, H> Future for HttpChannel<T, H> where T: IoStream, H: HttpHandler + 'sta
                     Ok(Async::Ready(0)) | Err(_) => {
                         debug!("Ignored premature client disconnection");
                         settings.remove_channel();
+                        self.node.as_mut().map(|n| n.remove());
                         return Err(())
                     },
                     _ => (),
@@ -163,11 +158,11 @@ pub(crate) struct Node<T>
 
 impl<T> Node<T>
 {
-    fn new(el: &mut T) -> Self {
+    fn new(el: *mut T) -> Self {
         Node {
             next: None,
             prev: None,
-            element: el as *mut _,
+            element: el,
         }
     }
 
@@ -186,13 +181,14 @@ impl<T> Node<T>
         }
     }
 
-    fn remove(&self) {
-        #[allow(mutable_transmutes)]
+    fn remove(&mut self) {
         unsafe {
-            if let Some(ref prev) = self.prev {
-                let p: &mut Node<()> = mem::transmute(prev.as_ref().unwrap());
-                let slf: &mut Node<T> = mem::transmute(self);
-                p.next = slf.next.take();
+            self.element = ptr::null_mut();
+            let next = self.next.take();
+            let mut prev = self.prev.take();
+
+            if let Some(ref mut prev) = prev {
+                prev.as_mut().unwrap().next = next;
             }
         }
     }

src/server/encoding.rs

@@ -11,9 +11,9 @@ use flate2::Compression;
 use flate2::read::GzDecoder;
 use flate2::write::{GzEncoder, DeflateDecoder, DeflateEncoder};
 use brotli2::write::{BrotliDecoder, BrotliEncoder};
-use bytes::{Bytes, BytesMut, BufMut, Writer};
+use bytes::{Bytes, BytesMut, BufMut};
 
-use headers::ContentEncoding;
+use header::ContentEncoding;
 use body::{Body, Binary};
 use error::PayloadError;
 use httprequest::HttpInnerMessage;
@@ -22,51 +22,6 @@ use payload::{PayloadSender, PayloadWriter, PayloadStatus};
 
 use super::shared::SharedBytes;
 
-
-impl ContentEncoding {
-
-    #[inline]
-    pub fn is_compression(&self) -> bool {
-        match *self {
-            ContentEncoding::Identity | ContentEncoding::Auto => false,
-            _ => true
-        }
-    }
-
-    #[inline]
-    pub fn as_str(&self) -> &'static str {
-        match *self {
-            ContentEncoding::Br => "br",
-            ContentEncoding::Gzip => "gzip",
-            ContentEncoding::Deflate => "deflate",
-            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
-        }
-    }
-    /// default quality value
-    fn quality(&self) -> f64 {
-        match *self {
-            ContentEncoding::Br => 1.1,
-            ContentEncoding::Gzip => 1.0,
-            ContentEncoding::Deflate => 0.9,
-            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
-        }
-    }
-}
-
-// TODO: remove memory allocation
-impl<'a> From<&'a str> for ContentEncoding {
-    fn from(s: &'a str) -> ContentEncoding {
-        match s.trim().to_lowercase().as_ref() {
-            "br" => ContentEncoding::Br,
-            "gzip" => ContentEncoding::Gzip,
-            "deflate" => ContentEncoding::Deflate,
-            "identity" => ContentEncoding::Identity,
-            _ => ContentEncoding::Auto,
-        }
-    }
-}
-
-
 pub(crate) enum PayloadType {
     Sender(PayloadSender),
     Encoding(Box<EncodedPayload>),
@@ -128,177 +83,6 @@ impl PayloadWriter for PayloadType {
     }
 }
 
-pub(crate) enum Decoder {
-    Deflate(Box<DeflateDecoder<Writer<BytesMut>>>),
-    Gzip(Option<Box<GzDecoder<Wrapper>>>),
-    Br(Box<BrotliDecoder<Writer<BytesMut>>>),
-    Identity,
-}
-
-// should go after write::GzDecoder get implemented
-#[derive(Debug)]
-pub(crate) struct Wrapper {
-    pub buf: BytesMut,
-    pub eof: bool,
-}
-
-impl io::Read for Wrapper {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let len = cmp::min(buf.len(), self.buf.len());
-        buf[..len].copy_from_slice(&self.buf[..len]);
-        self.buf.split_to(len);
-        if len == 0 {
-            if self.eof {
-                Ok(0)
-            } else {
-                Err(io::Error::new(io::ErrorKind::WouldBlock, ""))
-            }
-        } else {
-            Ok(len)
-        }
-    }
-}
-
-impl io::Write for Wrapper {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.buf.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-/// Payload stream with decompression support
-pub(crate) struct PayloadStream {
-    decoder: Decoder,
-    dst: BytesMut,
-}
-
-impl PayloadStream {
-    pub fn new(enc: ContentEncoding) -> PayloadStream {
-        let dec = match enc {
-            ContentEncoding::Br => Decoder::Br(
-                Box::new(BrotliDecoder::new(BytesMut::with_capacity(8192).writer()))),
-            ContentEncoding::Deflate => Decoder::Deflate(
-                Box::new(DeflateDecoder::new(BytesMut::with_capacity(8192).writer()))),
-            ContentEncoding::Gzip => Decoder::Gzip(None),
-            _ => Decoder::Identity,
-        };
-        PayloadStream{ decoder: dec, dst: BytesMut::new() }
-    }
-}
-
-impl PayloadStream {
-
-    pub fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
-        match self.decoder {
-            Decoder::Br(ref mut decoder) => {
-                match decoder.finish() {
-                    Ok(mut writer) => {
-                        let b = writer.get_mut().take().freeze();
-                        if !b.is_empty() {
-                            Ok(Some(b))
-                        } else {
-                            Ok(None)
-                        }
-                    },
-                    Err(err) => Err(err),
-                }
-            },
-            Decoder::Gzip(ref mut decoder) => {
-                if let Some(ref mut decoder) = *decoder {
-                    decoder.as_mut().get_mut().eof = true;
-
-                    loop {
-                        self.dst.reserve(8192);
-                        match decoder.read(unsafe{self.dst.bytes_mut()}) {
-                            Ok(n) =>  {
-                                if n == 0 {
-                                    return Ok(Some(self.dst.take().freeze()))
-                                } else {
-                                    unsafe{self.dst.set_len(n)};
-                                }
-                            }
-                            Err(err) => return Err(err),
-                        }
-                    }
-                } else {
-                    Ok(None)
-                }
-            },
-            Decoder::Deflate(ref mut decoder) => {
-                match decoder.try_finish() {
-                    Ok(_) => {
-                        let b = decoder.get_mut().get_mut().take().freeze();
-                        if !b.is_empty() {
-                            Ok(Some(b))
-                        } else {
-                            Ok(None)
-                        }
-                    },
-                    Err(err) => Err(err),
-                }
-            },
-            Decoder::Identity => Ok(None),
-        }
-    }
-
-    pub fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {
-        match self.decoder {
-            Decoder::Br(ref mut decoder) => {
-                match decoder.write(&data).and_then(|_| decoder.flush()) {
-                    Ok(_) => {
-                        let b = decoder.get_mut().get_mut().take().freeze();
-                        if !b.is_empty() {
-                            Ok(Some(b))
-                        } else {
-                            Ok(None)
-                        }
-                    },
-                    Err(err) => Err(err)
-                }
-            },
-            Decoder::Gzip(ref mut decoder) => {
-                if decoder.is_none() {
-                    *decoder = Some(
-                        Box::new(GzDecoder::new(
-                            Wrapper{buf: BytesMut::from(data), eof: false})));
-                } else {
-                    let _ = decoder.as_mut().unwrap().write(&data);
-                }
-
-                loop {
-                    self.dst.reserve(8192);
-                    match decoder.as_mut().as_mut().unwrap().read(unsafe{self.dst.bytes_mut()}) {
-                        Ok(n) =>  {
-                            if n == 0 {
-                                return Ok(Some(self.dst.split_to(n).freeze()));
-                            } else {
-                                unsafe{self.dst.set_len(n)};
-                            }
-                        }
-                        Err(e) => return Err(e),
-                    }
-                }
-            },
-            Decoder::Deflate(ref mut decoder) => {
-                match decoder.write(&data).and_then(|_| decoder.flush()) {
-                    Ok(_) => {
-                        let b = decoder.get_mut().get_mut().take().freeze();
-                        if !b.is_empty() {
-                            Ok(Some(b))
-                        } else {
-                            Ok(None)
-                        }
-                    },
-                    Err(e) => Err(e),
-                }
-            },
-            Decoder::Identity => Ok(Some(data)),
-        }
-    }
-}
 
 /// Payload wrapper with content decompression support
 pub(crate) struct EncodedPayload {
@@ -357,6 +141,208 @@ impl PayloadWriter for EncodedPayload {
     }
 }
 
+pub(crate) enum Decoder {
+    Deflate(Box<DeflateDecoder<Writer>>),
+    Gzip(Option<Box<GzDecoder<Wrapper>>>),
+    Br(Box<BrotliDecoder<Writer>>),
+    Identity,
+}
+
+// should go after write::GzDecoder get implemented
+#[derive(Debug)]
+pub(crate) struct Wrapper {
+    pub buf: BytesMut,
+    pub eof: bool,
+}
+
+impl io::Read for Wrapper {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let len = cmp::min(buf.len(), self.buf.len());
+        buf[..len].copy_from_slice(&self.buf[..len]);
+        self.buf.split_to(len);
+        if len == 0 {
+            if self.eof {
+                Ok(0)
+            } else {
+                Err(io::Error::new(io::ErrorKind::WouldBlock, ""))
+            }
+        } else {
+            Ok(len)
+        }
+    }
+}
+
+impl io::Write for Wrapper {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.buf.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+pub(crate) struct Writer {
+    buf: BytesMut,
+}
+
+impl Writer {
+    fn new() -> Writer {
+        Writer{buf: BytesMut::with_capacity(8192)}
+    }
+    fn take(&mut self) -> Bytes {
+        self.buf.take().freeze()
+    }
+}
+
+impl io::Write for Writer {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.buf.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Payload stream with decompression support
+pub(crate) struct PayloadStream {
+    decoder: Decoder,
+    dst: BytesMut,
+}
+
+impl PayloadStream {
+    pub fn new(enc: ContentEncoding) -> PayloadStream {
+        let dec = match enc {
+            ContentEncoding::Br => Decoder::Br(
+                Box::new(BrotliDecoder::new(Writer::new()))),
+            ContentEncoding::Deflate => Decoder::Deflate(
+                Box::new(DeflateDecoder::new(Writer::new()))),
+            ContentEncoding::Gzip => Decoder::Gzip(None),
+            _ => Decoder::Identity,
+        };
+        PayloadStream{ decoder: dec, dst: BytesMut::new() }
+    }
+}
+
+impl PayloadStream {
+
+    pub fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
+        match self.decoder {
+            Decoder::Br(ref mut decoder) => {
+                match decoder.finish() {
+                    Ok(mut writer) => {
+                        let b = writer.take();
+                        if !b.is_empty() {
+                            Ok(Some(b))
+                        } else {
+                            Ok(None)
+                        }
+                    },
+                    Err(e) => Err(e),
+                }
+            },
+            Decoder::Gzip(ref mut decoder) => {
+                if let Some(ref mut decoder) = *decoder {
+                    decoder.as_mut().get_mut().eof = true;
+
+                    self.dst.reserve(8192);
+                    match decoder.read(unsafe{self.dst.bytes_mut()}) {
+                        Ok(n) =>  {
+                            unsafe{self.dst.advance_mut(n)};
+                            return Ok(Some(self.dst.take().freeze()))
+                        }
+                        Err(e) =>
+                            return Err(e),
+                    }
+                } else {
+                    Ok(None)
+                }
+            },
+            Decoder::Deflate(ref mut decoder) => {
+                match decoder.try_finish() {
+                    Ok(_) => {
+                        let b = decoder.get_mut().take();
+                        if !b.is_empty() {
+                            Ok(Some(b))
+                        } else {
+                            Ok(None)
+                        }
+                    },
+                    Err(e) => Err(e),
+                }
+            },
+            Decoder::Identity => Ok(None),
+        }
+    }
+
+    pub fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {
+        match self.decoder {
+            Decoder::Br(ref mut decoder) => {
+                match decoder.write_all(&data) {
+                    Ok(_) => {
+                        decoder.flush()?;
+                        let b = decoder.get_mut().take();
+                        if !b.is_empty() {
+                            Ok(Some(b))
+                        } else {
+                            Ok(None)
+                        }
+                    },
+                    Err(e) => Err(e)
+                }
+            },
+            Decoder::Gzip(ref mut decoder) => {
+                if decoder.is_none() {
+                    *decoder = Some(
+                        Box::new(GzDecoder::new(
+                            Wrapper{buf: BytesMut::from(data), eof: false})));
+                } else {
+                    let _ = decoder.as_mut().unwrap().write(&data);
+                }
+
+                loop {
+                    self.dst.reserve(8192);
+                    match decoder.as_mut()
+                        .as_mut().unwrap().read(unsafe{self.dst.bytes_mut()})
+                    {
+                        Ok(n) =>  {
+                            if n != 0 {
+                                unsafe{self.dst.advance_mut(n)};
+                            }
+                            if n == 0 {
+                                return Ok(Some(self.dst.take().freeze()));
+                            }
+                        }
+                        Err(e) => {
+                            if e.kind() == io::ErrorKind::WouldBlock && !self.dst.is_empty()
+                            {
+                                return Ok(Some(self.dst.take().freeze()));
+                            }
+                            return Err(e)
+                        }
+                    }
+                }
+            },
+            Decoder::Deflate(ref mut decoder) => {
+                match decoder.write_all(&data) {
+                    Ok(_) => {
+                        decoder.flush()?;
+                        let b = decoder.get_mut().take();
+                        if !b.is_empty() {
+                            Ok(Some(b))
+                        } else {
+                            Ok(None)
+                        }
+                    },
+                    Err(e) => Err(e),
+                }
+            },
+            Decoder::Identity => Ok(Some(data)),
+        }
+    }
+}
+
 pub(crate) enum ContentEncoder {
     Deflate(DeflateEncoder<TransferEncoding>),
     Gzip(GzEncoder<TransferEncoding>),
@@ -480,8 +466,8 @@ impl ContentEncoder {
                 GzEncoder::new(transfer, Compression::default())),
             ContentEncoding::Br => ContentEncoder::Br(
                 BrotliEncoder::new(transfer, 5)),
-            ContentEncoding::Identity => ContentEncoder::Identity(transfer),
-            ContentEncoding::Auto => unreachable!()
+            ContentEncoding::Identity | ContentEncoding::Auto =>
+                ContentEncoder::Identity(transfer),
         }
     }
 
@@ -609,9 +595,8 @@ impl ContentEncoder {
     pub fn write(&mut self, data: Binary) -> Result<(), io::Error> {
         match *self {
             ContentEncoder::Br(ref mut encoder) => {
-                match encoder.write(data.as_ref()) {
-                    Ok(_) =>
-                        encoder.flush(),
+                match encoder.write_all(data.as_ref()) {
+                    Ok(_) => Ok(()),
                     Err(err) => {
                         trace!("Error decoding br encoding: {}", err);
                         Err(err)
@@ -619,9 +604,8 @@ impl ContentEncoder {
                 }
             },
             ContentEncoder::Gzip(ref mut encoder) => {
-                match encoder.write(data.as_ref()) {
-                    Ok(_) =>
-                        encoder.flush(),
+                match encoder.write_all(data.as_ref()) {
+                    Ok(_) => Ok(()),
                     Err(err) => {
                         trace!("Error decoding gzip encoding: {}", err);
                         Err(err)
@@ -629,9 +613,8 @@ impl ContentEncoder {
                 }
             }
             ContentEncoder::Deflate(ref mut encoder) => {
-                match encoder.write(data.as_ref()) {
-                    Ok(_) =>
-                        encoder.flush(),
+                match encoder.write_all(data.as_ref()) {
+                    Ok(_) => Ok(()),
                     Err(err) => {
                         trace!("Error decoding deflate encoding: {}", err);
                         Err(err)

src/server/h1.rs

@@ -10,7 +10,7 @@ use actix::Arbiter;
 use httparse;
 use http::{Uri, Method, Version, HttpTryFrom, HeaderMap};
 use http::header::{self, HeaderName, HeaderValue};
-use bytes::{Bytes, BytesMut, BufMut};
+use bytes::{Bytes, BytesMut};
 use futures::{Future, Poll, Async};
 use tokio_core::reactor::Timeout;
 
@@ -110,23 +110,11 @@ impl<T, H> Http1<T, H>
         }
     }
 
-    fn poll_completed(&mut self, shutdown: bool) -> Result<bool, ()> {
-        // check stream state
-        match self.stream.poll_completed(shutdown) {
-            Ok(Async::Ready(_)) => Ok(true),
-            Ok(Async::NotReady) => Ok(false),
-            Err(err) => {
-                debug!("Error sending data: {}", err);
-                Err(())
-            }
-        }
-    }
-
     // TODO: refactor
     pub fn poll_io(&mut self) -> Poll<bool, ()> {
         // read incoming data
-        let need_read =
-            if !self.flags.contains(Flags::ERROR) && self.tasks.len() < MAX_PIPELINED_MESSAGES
+        let need_read = if !self.flags.intersects(Flags::ERROR) &&
+            self.tasks.len() < MAX_PIPELINED_MESSAGES
         {
             'outer: loop {
                 match self.reader.parse(self.stream.get_mut(),
@@ -192,134 +180,117 @@ impl<T, H> Http1<T, H>
 
         let retry = self.reader.need_read() == PayloadStatus::Read;
 
-        loop {
-            // check in-flight messages
-            let mut io = false;
-            let mut idx = 0;
-            while idx < self.tasks.len() {
-                let item = &mut self.tasks[idx];
+        // check in-flight messages
+        let mut io = false;
+        let mut idx = 0;
+        while idx < self.tasks.len() {
+            let item = &mut self.tasks[idx];
 
-                if !io && !item.flags.contains(EntryFlags::EOF) {
-                    // io is corrupted, send buffer
-                    if item.flags.contains(EntryFlags::ERROR) {
+            if !io && !item.flags.contains(EntryFlags::EOF) {
+                // io is corrupted, send buffer
+                if item.flags.contains(EntryFlags::ERROR) {
+                    if let Ok(Async::NotReady) = self.stream.poll_completed(true) {
+                        return Ok(Async::NotReady)
+                    }
+                    return Err(())
+                }
+
+                match item.pipe.poll_io(&mut self.stream) {
+                    Ok(Async::Ready(ready)) => {
+                        // override keep-alive state
+                        if self.stream.keepalive() {
+                            self.flags.insert(Flags::KEEPALIVE);
+                        } else {
+                            self.flags.remove(Flags::KEEPALIVE);
+                        }
+                        // prepare stream for next response
+                        self.stream.reset();
+
+                        if ready {
+                            item.flags.insert(EntryFlags::EOF | EntryFlags::FINISHED);
+                        } else {
+                            item.flags.insert(EntryFlags::FINISHED);
+                        }
+                    },
+                    // no more IO for this iteration
+                    Ok(Async::NotReady) => {
+                        if self.reader.need_read() == PayloadStatus::Read && !retry {
+                            return Ok(Async::Ready(true));
+                        }
+                        io = true;
+                    }
+                    Err(err) => {
+                        // it is not possible to recover from error
+                        // during pipe handling, so just drop connection
+                        error!("Unhandled error: {}", err);
+                        item.flags.insert(EntryFlags::ERROR);
+
+                        // check stream state, we still can have valid data in buffer
                         if let Ok(Async::NotReady) = self.stream.poll_completed(true) {
                             return Ok(Async::NotReady)
                         }
                         return Err(())
                     }
-
-                    match item.pipe.poll_io(&mut self.stream) {
-                        Ok(Async::Ready(ready)) => {
-                            // override keep-alive state
-                            if self.stream.keepalive() {
-                                self.flags.insert(Flags::KEEPALIVE);
-                            } else {
-                                self.flags.remove(Flags::KEEPALIVE);
-                            }
-                            // prepare stream for next response
-                            self.stream.reset();
-
-                            if ready {
-                                item.flags.insert(EntryFlags::EOF | EntryFlags::FINISHED);
-                            } else {
-                                item.flags.insert(EntryFlags::FINISHED);
-                            }
-                        },
-                        // no more IO for this iteration
-                        Ok(Async::NotReady) => {
-                            if self.reader.need_read() == PayloadStatus::Read && !retry {
-                                return Ok(Async::Ready(true));
-                            }
-                            io = true;
-                        }
-                        Err(err) => {
-                            // it is not possible to recover from error
-                            // during pipe handling, so just drop connection
-                            error!("Unhandled error: {}", err);
-                            item.flags.insert(EntryFlags::ERROR);
-
-                            // check stream state, we still can have valid data in buffer
-                            if let Ok(Async::NotReady) = self.stream.poll_completed(true) {
-                                return Ok(Async::NotReady)
-                            }
-                            return Err(())
-                        }
-                    }
-                } else if !item.flags.contains(EntryFlags::FINISHED) {
-                    match item.pipe.poll() {
-                        Ok(Async::NotReady) => (),
-                        Ok(Async::Ready(_)) => item.flags.insert(EntryFlags::FINISHED),
-                        Err(err) => {
-                            item.flags.insert(EntryFlags::ERROR);
-                            error!("Unhandled error: {}", err);
-                        }
+                }
+            } else if !item.flags.contains(EntryFlags::FINISHED) {
+                match item.pipe.poll() {
+                    Ok(Async::NotReady) => (),
+                    Ok(Async::Ready(_)) => item.flags.insert(EntryFlags::FINISHED),
+                    Err(err) => {
+                        item.flags.insert(EntryFlags::ERROR);
+                        error!("Unhandled error: {}", err);
                     }
                 }
-                idx += 1;
             }
+            idx += 1;
+        }
 
-            // cleanup finished tasks
-            let mut popped = false;
-            while !self.tasks.is_empty() {
-                if self.tasks[0].flags.contains(EntryFlags::EOF | EntryFlags::FINISHED) {
-                    popped = true;
-                    self.tasks.pop_front();
-                } else {
-                    break
-                }
-            }
-            if need_read && popped {
-                return self.poll_io()
+        // cleanup finished tasks
+        let mut popped = false;
+        while !self.tasks.is_empty() {
+            if self.tasks[0].flags.contains(EntryFlags::EOF | EntryFlags::FINISHED) {
+                popped = true;
+                self.tasks.pop_front();
+            } else {
+                break
             }
+        }
+        if need_read && popped {
+            return self.poll_io()
+        }
 
-            // no keep-alive
-            if !self.flags.contains(Flags::KEEPALIVE) && self.tasks.is_empty() {
-                // check stream state
-                if !self.poll_completed(true)? {
-                    return Ok(Async::NotReady)
-                }
+        // check stream state
+        match self.stream.poll_completed(self.tasks.is_empty()) {
+            Ok(Async::NotReady) => return Ok(Async::NotReady),
+            Err(err) => {
+                debug!("Error sending data: {}", err);
+                return Err(())
+            }
+            _ => (),
+        }
+
+        // deal with keep-alive
+        if self.tasks.is_empty() {
+            // no keep-alive situations
+            if self.flags.contains(Flags::ERROR)
+                || !self.flags.contains(Flags::KEEPALIVE)
+                || !self.settings.keep_alive_enabled()
+            {
                 return Ok(Async::Ready(false))
             }
 
-            // start keep-alive timer, this also is slow request timeout
-            if self.tasks.is_empty() {
-                // check stream state
-                if self.flags.contains(Flags::ERROR) {
-                    return Ok(Async::Ready(false))
-                }
-
-                if self.settings.keep_alive_enabled() {
-                    let keep_alive = self.settings.keep_alive();
-                    if keep_alive > 0 && self.flags.contains(Flags::KEEPALIVE) {
-                        if self.keepalive_timer.is_none() {
-                            trace!("Start keep-alive timer");
-                            let mut to = Timeout::new(
-                                Duration::new(keep_alive, 0), Arbiter::handle()).unwrap();
-                            // register timeout
-                            let _ = to.poll();
-                            self.keepalive_timer = Some(to);
-                        }
-                    } else {
-                        // check stream state
-                        if !self.poll_completed(true)? {
-                            return Ok(Async::NotReady)
-                        }
-                        // keep-alive is disabled, drop connection
-                        return Ok(Async::Ready(false))
-                    }
-                } else if !self.poll_completed(false)? ||
-                    self.flags.contains(Flags::KEEPALIVE) {
-                        // check stream state or
-                        // if keep-alive unset, rely on operating system
-                        return Ok(Async::NotReady)
-                    } else {
-                        return Ok(Async::Ready(false))
-                    }
-            } else {
-                self.poll_completed(false)?;
-                return Ok(Async::NotReady)
+            // start keep-alive timer
+            let keep_alive = self.settings.keep_alive();
+            if self.keepalive_timer.is_none() && keep_alive > 0 {
+                trace!("Start keep-alive timer");
+                let mut timer = Timeout::new(
+                    Duration::new(keep_alive, 0), Arbiter::handle()).unwrap();
+                // register timer
+                let _ = timer.poll();
+                self.keepalive_timer = Some(timer);
             }
         }
+        Ok(Async::NotReady)
     }
 }
 
@@ -402,40 +373,49 @@ impl Reader {
         // read payload
         let done = {
             if let Some(ref mut payload) = self.payload {
-                match utils::read_from_io(io, buf) {
-                    Ok(Async::Ready(0)) => {
-                        payload.tx.set_error(PayloadError::Incomplete);
+                'buf: loop {
+                    let not_ready = match utils::read_from_io(io, buf) {
+                        Ok(Async::Ready(0)) => {
+                            payload.tx.set_error(PayloadError::Incomplete);
 
-                        // http channel should not deal with payload errors
-                        return Err(ReaderError::Payload)
-                    },
-                    Err(err) => {
-                        payload.tx.set_error(err.into());
-
-                        // http channel should not deal with payload errors
-                        return Err(ReaderError::Payload)
-                    }
-                    _ => (),
-                }
-                loop {
-                    match payload.decoder.decode(buf) {
-                        Ok(Async::Ready(Some(bytes))) => {
-                            payload.tx.feed_data(bytes);
-                            if payload.decoder.is_eof() {
-                                payload.tx.feed_eof();
-                                break true
-                            }
+                            // http channel should not deal with payload errors
+                            return Err(ReaderError::Payload)
                         },
-                        Ok(Async::Ready(None)) => {
-                            payload.tx.feed_eof();
-                            break true
-                        },
-                        Ok(Async::NotReady) =>
-                            return Ok(Async::NotReady),
+                        Ok(Async::NotReady) => true,
                         Err(err) => {
                             payload.tx.set_error(err.into());
+
+                            // http channel should not deal with payload errors
                             return Err(ReaderError::Payload)
                         }
+                        _ => false,
+                    };
+                    loop {
+                        match payload.decoder.decode(buf) {
+                            Ok(Async::Ready(Some(bytes))) => {
+                                payload.tx.feed_data(bytes);
+                                if payload.decoder.is_eof() {
+                                    payload.tx.feed_eof();
+                                    break 'buf true
+                                }
+                            },
+                            Ok(Async::Ready(None)) => {
+                                payload.tx.feed_eof();
+                                break 'buf true
+                            },
+                            Ok(Async::NotReady) => {
+                                // if buffer is full then
+                                // socket still can contain more data
+                                if not_ready {
+                                    return Ok(Async::NotReady)
+                                }
+                                continue 'buf
+                            },
+                            Err(err) => {
+                                payload.tx.set_error(err.into());
+                                return Err(ReaderError::Payload)
+                            }
+                        }
                     }
                 }
             } else {
@@ -445,16 +425,13 @@ impl Reader {
         if done { self.payload = None }
 
         // if buf is empty parse_message will always return NotReady, let's avoid that
-        let read = if buf.is_empty() {
+        if buf.is_empty() {
             match utils::read_from_io(io, buf) {
                 Ok(Async::Ready(0)) => return Err(ReaderError::Disconnect),
                 Ok(Async::Ready(_)) => (),
                 Ok(Async::NotReady) => return Ok(Async::NotReady),
                 Err(err) => return Err(ReaderError::Error(err.into()))
             }
-            false
-        } else {
-            true
         };
 
         loop {
@@ -470,22 +447,18 @@ impl Reader {
                     return Ok(Async::Ready(msg));
                 },
                 Async::NotReady => {
-                    if buf.capacity() >= MAX_BUFFER_SIZE {
+                    if buf.len() >= MAX_BUFFER_SIZE {
                         error!("MAX_BUFFER_SIZE unprocessed data reached, closing");
                         return Err(ReaderError::Error(ParseError::TooLarge));
                     }
-                    if read || buf.remaining_mut() == 0 {
-                        match utils::read_from_io(io, buf) {
-                            Ok(Async::Ready(0)) => {
-                                debug!("Ignored premature client disconnection");
-                                return Err(ReaderError::Disconnect);
-                            },
-                            Ok(Async::Ready(_)) => (),
-                            Ok(Async::NotReady) => return Ok(Async::NotReady),
-                            Err(err) => return Err(ReaderError::Error(err.into())),
-                        }
-                    } else {
-                        return Ok(Async::NotReady)
+                    match utils::read_from_io(io, buf) {
+                        Ok(Async::Ready(0)) => {
+                            debug!("Ignored premature client disconnection");
+                            return Err(ReaderError::Disconnect);
+                        },
+                        Ok(Async::Ready(_)) => (),
+                        Ok(Async::NotReady) => return Ok(Async::NotReady),
+                        Err(err) => return Err(ReaderError::Error(err.into())),
                     }
                 },
             }
@@ -866,7 +839,7 @@ mod tests {
     use httpmessage::HttpMessage;
     use application::HttpApplication;
     use server::settings::WorkerSettings;
-    use server::IoStream;
+    use server::{IoStream, KeepAlive};
 
     struct Buffer {
         buf: Bytes,
@@ -937,7 +910,8 @@ mod tests {
 
     macro_rules! parse_ready {
         ($e:expr) => ({
-            let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+            let settings = WorkerSettings::<HttpApplication>::new(
+                Vec::new(), KeepAlive::Os);
             match Reader::new().parse($e, &mut BytesMut::new(), &settings) {
                 Ok(Async::Ready(req)) => req,
                 Ok(_) => panic!("Eof during parsing http request"),
@@ -959,7 +933,8 @@ mod tests {
     macro_rules! expect_parse_err {
         ($e:expr) => ({
             let mut buf = BytesMut::new();
-            let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+            let settings = WorkerSettings::<HttpApplication>::new(
+                Vec::new(), KeepAlive::Os);
 
             match Reader::new().parse($e, &mut buf, &settings) {
                 Err(err) => match err {
@@ -977,7 +952,8 @@ mod tests {
     fn test_parse() {
         let mut buf = Buffer::new("GET /test HTTP/1.1\r\n\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         match reader.parse(&mut buf, &mut readbuf, &settings) {
@@ -994,7 +970,8 @@ mod tests {
     fn test_parse_partial() {
         let mut buf = Buffer::new("PUT /test HTTP/1");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         match reader.parse(&mut buf, &mut readbuf, &settings) {
@@ -1017,7 +994,8 @@ mod tests {
     fn test_parse_post() {
         let mut buf = Buffer::new("POST /test2 HTTP/1.0\r\n\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         match reader.parse(&mut buf, &mut readbuf, &settings) {
@@ -1034,7 +1012,8 @@ mod tests {
     fn test_parse_body() {
         let mut buf = Buffer::new("GET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         match reader.parse(&mut buf, &mut readbuf, &settings) {
@@ -1053,7 +1032,8 @@ mod tests {
         let mut buf = Buffer::new(
             "\r\nGET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         match reader.parse(&mut buf, &mut readbuf, &settings) {
@@ -1071,7 +1051,8 @@ mod tests {
     fn test_parse_partial_eof() {
         let mut buf = Buffer::new("GET /test HTTP/1.1\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         not_ready!{ reader.parse(&mut buf, &mut readbuf, &settings) }
@@ -1091,7 +1072,8 @@ mod tests {
     fn test_headers_split_field() {
         let mut buf = Buffer::new("GET /test HTTP/1.1\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         not_ready!{ reader.parse(&mut buf, &mut readbuf, &settings) }
@@ -1121,7 +1103,8 @@ mod tests {
              Set-Cookie: c1=cookie1\r\n\
              Set-Cookie: c2=cookie2\r\n\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         match reader.parse(&mut buf, &mut readbuf, &settings) {
@@ -1356,7 +1339,8 @@ mod tests {
             "GET /test HTTP/1.1\r\n\
              transfer-encoding: chunked\r\n\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         let mut req = reader_parse_ready!(reader.parse(&mut buf, &mut readbuf, &settings));
@@ -1377,7 +1361,8 @@ mod tests {
             "GET /test HTTP/1.1\r\n\
              transfer-encoding: chunked\r\n\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
 
@@ -1406,13 +1391,19 @@ mod tests {
             "GET /test HTTP/1.1\r\n\
              transfer-encoding: chunked\r\n\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         let mut req = reader_parse_ready!(reader.parse(&mut buf, &mut readbuf, &settings));
+        let _ = req.payload_mut().set_read_buffer_capacity(0);
         assert!(req.chunked().unwrap());
         assert!(!req.payload().eof());
 
+        buf.feed_data("4\r\n1111\r\n");
+        not_ready!(reader.parse(&mut buf, &mut readbuf, &settings));
+        assert_eq!(req.payload_mut().readall().unwrap().as_ref(), b"1111");
+
         buf.feed_data("4\r\ndata\r");
         not_ready!(reader.parse(&mut buf, &mut readbuf, &settings));
 
@@ -1430,6 +1421,7 @@ mod tests {
         buf.feed_data("ne\r\n0\r\n");
         not_ready!(reader.parse(&mut buf, &mut readbuf, &settings));
 
+        //trailers
         //buf.feed_data("test: test\r\n");
         //not_ready!(reader.parse(&mut buf, &mut readbuf));
 
@@ -1451,7 +1443,8 @@ mod tests {
             "GET /test HTTP/1.1\r\n\
              transfer-encoding: chunked\r\n\r\n");
         let mut readbuf = BytesMut::new();
-        let settings = WorkerSettings::<HttpApplication>::new(Vec::new(), None);
+        let settings = WorkerSettings::<HttpApplication>::new(
+            Vec::new(), KeepAlive::Os);
 
         let mut reader = Reader::new();
         let mut req = reader_parse_ready!(reader.parse(&mut buf, &mut readbuf, &settings));

src/server/h1writer.rs

@@ -34,6 +34,7 @@ pub(crate) struct H1Writer<T: AsyncWrite> {
     written: u64,
     headers_size: u32,
     buffer: SharedBytes,
+    buffer_capacity: usize,
 }
 
 impl<T: AsyncWrite> H1Writer<T> {
@@ -45,6 +46,7 @@ impl<T: AsyncWrite> H1Writer<T> {
             written: 0,
             headers_size: 0,
             buffer: buf,
+            buffer_capacity: 0,
             stream,
         }
     }
@@ -66,27 +68,22 @@ impl<T: AsyncWrite> H1Writer<T> {
         self.flags.contains(Flags::KEEPALIVE) && !self.flags.contains(Flags::UPGRADE)
     }
 
-    fn write_to_stream(&mut self) -> io::Result<WriterState> {
-        while !self.buffer.is_empty() {
-            match self.stream.write(self.buffer.as_ref()) {
+    fn write_data(&mut self, data: &[u8]) -> io::Result<usize> {
+        let mut written = 0;
+        while written < data.len() {
+            match self.stream.write(&data[written..]) {
                 Ok(0) => {
                     self.disconnected();
-                    return Ok(WriterState::Done);
-                },
-                Ok(n) => {
-                    let _ = self.buffer.split_to(n);
+                    return Err(io::Error::new(io::ErrorKind::WriteZero, ""))
                 },
+                Ok(n) => written += n,
                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                    if self.buffer.len() > MAX_WRITE_BUFFER_SIZE {
-                        return Ok(WriterState::Pause)
-                    } else {
-                        return Ok(WriterState::Done)
-                    }
+                    return Ok(written)
                 }
                 Err(err) => return Err(err),
             }
         }
-        Ok(WriterState::Done)
+        Ok(written)
     }
 }
 
@@ -199,6 +196,9 @@ impl<T: AsyncWrite> Writer for H1Writer<T> {
             self.written = bytes.len() as u64;
             self.encoder.write(bytes)?;
         } else {
+            // capacity, makes sense only for streaming or actor
+            self.buffer_capacity = msg.write_buffer_capacity();
+
             msg.replace_body(body);
         }
         Ok(WriterState::Done)
@@ -211,18 +211,10 @@ impl<T: AsyncWrite> Writer for H1Writer<T> {
                 // shortcut for upgraded connection
                 if self.flags.contains(Flags::UPGRADE) {
                     if self.buffer.is_empty() {
-                        match self.stream.write(payload.as_ref()) {
-                            Ok(0) => {
-                                self.disconnected();
-                                return Ok(WriterState::Done);
-                            },
-                            Ok(n) => if payload.len() < n {
-                                self.buffer.extend_from_slice(&payload.as_ref()[n..])
-                            },
-                            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                                return Ok(WriterState::Done)
-                            }
-                            Err(err) => return Err(err),
+                        let n = self.write_data(payload.as_ref())?;
+                        if payload.len() < n {
+                            self.buffer.extend_from_slice(&payload.as_ref()[n..]);
+                            return Ok(WriterState::Done);
                         }
                     } else {
                         self.buffer.extend(payload);
@@ -237,7 +229,7 @@ impl<T: AsyncWrite> Writer for H1Writer<T> {
             }
         }
 
-        if self.buffer.len() > MAX_WRITE_BUFFER_SIZE {
+        if self.buffer.len() > self.buffer_capacity {
             Ok(WriterState::Pause)
         } else {
             Ok(WriterState::Done)
@@ -259,16 +251,18 @@ impl<T: AsyncWrite> Writer for H1Writer<T> {
 
     #[inline]
     fn poll_completed(&mut self, shutdown: bool) -> Poll<(), io::Error> {
-        match self.write_to_stream() {
-            Ok(WriterState::Done) => {
-                if shutdown {
-                    self.stream.shutdown()
-                } else {
-                    Ok(Async::Ready(()))
-                }
-            },
-            Ok(WriterState::Pause) => Ok(Async::NotReady),
-            Err(err) => Err(err)
+        if !self.buffer.is_empty() {
+            let buf: &[u8] = unsafe{mem::transmute(self.buffer.as_ref())};
+            let written = self.write_data(buf)?;
+            let _ = self.buffer.split_to(written);
+            if self.buffer.len() > self.buffer_capacity {
+                return Ok(Async::NotReady)
+            }
+        }
+        if shutdown {
+            self.stream.shutdown()
+        } else {
+            Ok(Async::Ready(()))
         }
     }
 }

src/server/h2.rs

@@ -26,7 +26,7 @@ use payload::{Payload, PayloadWriter, PayloadStatus};
 use super::h2writer::H2Writer;
 use super::encoding::PayloadType;
 use super::settings::WorkerSettings;
-use super::{HttpHandler, HttpHandlerTask};
+use super::{HttpHandler, HttpHandlerTask, Writer};
 
 bitflags! {
     struct Flags: u8 {
@@ -109,22 +109,27 @@ impl<T, H> Http2<T, H>
                         loop {
                             match item.task.poll_io(&mut item.stream) {
                                 Ok(Async::Ready(ready)) => {
-                                    item.flags.insert(EntryFlags::EOF);
                                     if ready {
-                                        item.flags.insert(EntryFlags::FINISHED);
+                                        item.flags.insert(
+                                            EntryFlags::EOF | EntryFlags::FINISHED);
+                                    } else {
+                                        item.flags.insert(EntryFlags::EOF);
                                     }
                                     not_ready = false;
                                 },
                                 Ok(Async::NotReady) => {
-                                    if item.payload.need_read() == PayloadStatus::Read && !retry
+                                    if item.payload.need_read() == PayloadStatus::Read
+                                        && !retry
                                     {
                                         continue
                                     }
                                 },
                                 Err(err) => {
                                     error!("Unhandled error: {}", err);
-                                    item.flags.insert(EntryFlags::EOF);
-                                    item.flags.insert(EntryFlags::ERROR);
+                                    item.flags.insert(
+                                        EntryFlags::EOF |
+                                        EntryFlags::ERROR |
+                                        EntryFlags::WRITE_DONE);
                                     item.stream.reset(Reason::INTERNAL_ERROR);
                                 }
                             }
@@ -138,18 +143,32 @@ impl<T, H> Http2<T, H>
                                 item.flags.insert(EntryFlags::FINISHED);
                             },
                             Err(err) => {
-                                item.flags.insert(EntryFlags::ERROR);
-                                item.flags.insert(EntryFlags::FINISHED);
+                                item.flags.insert(
+                                    EntryFlags::ERROR | EntryFlags::WRITE_DONE |
+                                    EntryFlags::FINISHED);
                                 error!("Unhandled error: {}", err);
                             }
                         }
                     }
+
+                    if !item.flags.contains(EntryFlags::WRITE_DONE) {
+                        match item.stream.poll_completed(false) {
+                            Ok(Async::NotReady) => (),
+                            Ok(Async::Ready(_)) => {
+                                not_ready = false;
+                                item.flags.insert(EntryFlags::WRITE_DONE);
+                            }
+                            Err(_err) => {
+                                item.flags.insert(EntryFlags::ERROR);
+                            }
+                        }
+                    }
                 }
 
                 // cleanup finished tasks
                 while !self.tasks.is_empty() {
                     if self.tasks[0].flags.contains(EntryFlags::EOF) &&
-                        self.tasks[0].flags.contains(EntryFlags::FINISHED) ||
+                        self.tasks[0].flags.contains(EntryFlags::WRITE_DONE) ||
                         self.tasks[0].flags.contains(EntryFlags::ERROR)
                     {
                         self.tasks.pop_front();
@@ -251,6 +270,7 @@ bitflags! {
         const REOF = 0b0000_0010;
         const ERROR = 0b0000_0100;
         const FINISHED = 0b0000_1000;
+        const WRITE_DONE = 0b0001_0000;
     }
 }
 

src/server/h2writer.rs

@@ -24,6 +24,7 @@ bitflags! {
         const STARTED = 0b0000_0001;
         const DISCONNECTED = 0b0000_0010;
         const EOF = 0b0000_0100;
+        const RESERVED = 0b0000_1000;
     }
 }
 
@@ -34,6 +35,7 @@ pub(crate) struct H2Writer {
     flags: Flags,
     written: u64,
     buffer: SharedBytes,
+    buffer_capacity: usize,
 }
 
 impl H2Writer {
@@ -46,6 +48,7 @@ impl H2Writer {
             flags: Flags::empty(),
             written: 0,
             buffer: buf,
+            buffer_capacity: 0,
         }
     }
 
@@ -54,55 +57,6 @@ impl H2Writer {
             stream.send_reset(reason)
         }
     }
-
-    fn write_to_stream(&mut self) -> io::Result<WriterState> {
-        if !self.flags.contains(Flags::STARTED) {
-            return Ok(WriterState::Done)
-        }
-
-        if let Some(ref mut stream) = self.stream {
-            if self.buffer.is_empty() {
-                if self.flags.contains(Flags::EOF) {
-                    let _ = stream.send_data(Bytes::new(), true);
-                }
-                return Ok(WriterState::Done)
-            }
-
-            loop {
-                match stream.poll_capacity() {
-                    Ok(Async::NotReady) => {
-                        if self.buffer.len() > MAX_WRITE_BUFFER_SIZE {
-                            return Ok(WriterState::Pause)
-                        } else {
-                            return Ok(WriterState::Done)
-                        }
-                    }
-                    Ok(Async::Ready(None)) => {
-                        return Ok(WriterState::Done)
-                    }
-                    Ok(Async::Ready(Some(cap))) => {
-                        let len = self.buffer.len();
-                        let bytes = self.buffer.split_to(cmp::min(cap, len));
-                        let eof = self.buffer.is_empty() && self.flags.contains(Flags::EOF);
-                        self.written += bytes.len() as u64;
-
-                        if let Err(err) = stream.send_data(bytes.freeze(), eof) {
-                            return Err(io::Error::new(io::ErrorKind::Other, err))
-                        } else if !self.buffer.is_empty() {
-                            let cap = cmp::min(self.buffer.len(), CHUNK_SIZE);
-                            stream.reserve_capacity(cap);
-                        } else {
-                            return Ok(WriterState::Pause)
-                        }
-                    }
-                    Err(_) => {
-                        return Err(io::Error::new(io::ErrorKind::Other, ""))
-                    }
-                }
-            }
-        }
-        Ok(WriterState::Done)
-    }
 }
 
 impl Writer for H2Writer {
@@ -111,8 +65,11 @@ impl Writer for H2Writer {
         self.written
     }
 
-    fn start(&mut self, req: &mut HttpInnerMessage, msg: &mut HttpResponse, encoding: ContentEncoding)
-             -> io::Result<WriterState> {
+    fn start(&mut self,
+             req: &mut HttpInnerMessage,
+             msg: &mut HttpResponse,
+             encoding: ContentEncoding) -> io::Result<WriterState>
+    {
         // prepare response
         self.flags.insert(Flags::STARTED);
         self.encoder = ContentEncoder::for_server(self.buffer.clone(), req, msg, encoding);
@@ -167,11 +124,13 @@ impl Writer for H2Writer {
             self.written = bytes.len() as u64;
             self.encoder.write(bytes)?;
             if let Some(ref mut stream) = self.stream {
+                self.flags.insert(Flags::RESERVED);
                 stream.reserve_capacity(cmp::min(self.buffer.len(), CHUNK_SIZE));
             }
             Ok(WriterState::Pause)
         } else {
             msg.replace_body(body);
+            self.buffer_capacity = msg.write_buffer_capacity();
             Ok(WriterState::Done)
         }
     }
@@ -189,7 +148,7 @@ impl Writer for H2Writer {
             }
         }
 
-        if self.buffer.len() > MAX_WRITE_BUFFER_SIZE {
+        if self.buffer.len() > self.buffer_capacity {
             Ok(WriterState::Pause)
         } else {
             Ok(WriterState::Done)
@@ -211,10 +170,41 @@ impl Writer for H2Writer {
     }
 
     fn poll_completed(&mut self, _shutdown: bool) -> Poll<(), io::Error> {
-        match self.write_to_stream() {
-            Ok(WriterState::Done) => Ok(Async::Ready(())),
-            Ok(WriterState::Pause) => Ok(Async::NotReady),
-            Err(err) => Err(err)
+        if !self.flags.contains(Flags::STARTED) {
+            return Ok(Async::NotReady);
         }
+
+        if let Some(ref mut stream) = self.stream {
+            // reserve capacity
+            if !self.flags.contains(Flags::RESERVED) && !self.buffer.is_empty() {
+                self.flags.insert(Flags::RESERVED);
+                stream.reserve_capacity(cmp::min(self.buffer.len(), CHUNK_SIZE));
+            }
+
+            loop {
+                match stream.poll_capacity() {
+                    Ok(Async::NotReady) => return Ok(Async::NotReady),
+                    Ok(Async::Ready(None)) => return Ok(Async::Ready(())),
+                    Ok(Async::Ready(Some(cap))) => {
+                        let len = self.buffer.len();
+                        let bytes = self.buffer.split_to(cmp::min(cap, len));
+                        let eof = self.buffer.is_empty() && self.flags.contains(Flags::EOF);
+                        self.written += bytes.len() as u64;
+
+                        if let Err(e) = stream.send_data(bytes.freeze(), eof) {
+                            return Err(io::Error::new(io::ErrorKind::Other, e))
+                        } else if !self.buffer.is_empty() {
+                            let cap = cmp::min(self.buffer.len(), CHUNK_SIZE);
+                            stream.reserve_capacity(cap);
+                        } else {
+                            self.flags.remove(Flags::RESERVED);
+                            return Ok(Async::NotReady)
+                        }
+                    }
+                    Err(e) => return Err(io::Error::new(io::ErrorKind::Other, e)),
+                }
+            }
+        }
+        Ok(Async::NotReady)
     }
 }

src/server/mod.rs

@@ -31,6 +31,35 @@ use httpresponse::HttpResponse;
 /// max buffer size 64k
 pub(crate) const MAX_WRITE_BUFFER_SIZE: usize = 65_536;
 
+#[derive(Debug, PartialEq, Clone, Copy)]
+/// Server keep-alive setting
+pub enum KeepAlive {
+    /// Keep alive in seconds
+    Timeout(usize),
+    /// Use `SO_KEEPALIVE` socket option, value in seconds
+    Tcp(usize),
+    /// Relay on OS to shutdown tcp connection
+    Os,
+    /// Disabled
+    Disabled,
+}
+
+impl From<usize> for KeepAlive {
+    fn from(keepalive: usize) -> Self {
+        KeepAlive::Timeout(keepalive)
+    }
+}
+
+impl From<Option<usize>> for KeepAlive {
+    fn from(keepalive: Option<usize>) -> Self {
+        if let Some(keepalive) = keepalive {
+            KeepAlive::Timeout(keepalive)
+        } else {
+            KeepAlive::Disabled
+        }
+    }
+}
+
 /// Pause accepting incoming connections
 ///
 /// If socket contains some pending connection, they might be dropped.

src/server/settings.rs

@@ -1,8 +1,11 @@
-use std::net;
+use std::{fmt, net};
 use std::rc::Rc;
-use std::cell::{Cell, RefCell, RefMut};
+use std::sync::Arc;
+use std::cell::{Cell, RefCell, RefMut, UnsafeCell};
+use futures_cpupool::{Builder, CpuPool};
 
 use helpers;
+use super::KeepAlive;
 use super::channel::Node;
 use super::shared::{SharedBytes, SharedBytesPool};
 
@@ -12,14 +15,45 @@ pub struct ServerSettings {
     addr: Option<net::SocketAddr>,
     secure: bool,
     host: String,
+    cpu_pool: Arc<InnerCpuPool>,
 }
 
+struct InnerCpuPool {
+    cpu_pool: UnsafeCell<Option<CpuPool>>,
+}
+
+impl fmt::Debug for InnerCpuPool {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CpuPool")
+    }
+}
+
+impl InnerCpuPool {
+    fn new() -> Self {
+        InnerCpuPool {
+            cpu_pool: UnsafeCell::new(None),
+        }
+    }
+    fn cpu_pool(&self) -> &CpuPool {
+        unsafe {
+            let val = &mut *self.cpu_pool.get();
+            if val.is_none() {
+                *val = Some(Builder::new().create());
+            }
+            val.as_ref().unwrap()
+        }
+    }
+}
+
+unsafe impl Sync for InnerCpuPool {}
+
 impl Default for ServerSettings {
     fn default() -> Self {
         ServerSettings {
             addr: None,
             secure: false,
             host: "localhost:8080".to_owned(),
+            cpu_pool: Arc::new(InnerCpuPool::new()),
         }
     }
 }
@@ -36,7 +70,8 @@ impl ServerSettings {
         } else {
             "localhost".to_owned()
         };
-        ServerSettings { addr, secure, host }
+        let cpu_pool = Arc::new(InnerCpuPool::new());
+        ServerSettings { addr, secure, host, cpu_pool }
     }
 
     /// Returns the socket address of the local half of this TCP connection
@@ -53,29 +88,39 @@ impl ServerSettings {
     pub fn host(&self) -> &str {
         &self.host
     }
+
+    /// Returns default `CpuPool` for server
+    pub fn cpu_pool(&self) -> &CpuPool {
+        self.cpu_pool.cpu_pool()
+    }
 }
 
 
 pub(crate) struct WorkerSettings<H> {
     h: RefCell<Vec<H>>,
-    enabled: bool,
     keep_alive: u64,
+    ka_enabled: bool,
     bytes: Rc<SharedBytesPool>,
     messages: Rc<helpers::SharedMessagePool>,
     channels: Cell<usize>,
-    node: Node<()>,
+    node: Box<Node<()>>,
 }
 
 impl<H> WorkerSettings<H> {
-    pub(crate) fn new(h: Vec<H>, keep_alive: Option<u64>) -> WorkerSettings<H> {
+    pub(crate) fn new(h: Vec<H>, keep_alive: KeepAlive) -> WorkerSettings<H> {
+        let (keep_alive, ka_enabled) = match keep_alive {
+            KeepAlive::Timeout(val) => (val as u64, true),
+            KeepAlive::Os | KeepAlive::Tcp(_) => (0, true),
+            KeepAlive::Disabled => (0, false),
+        };
+
         WorkerSettings {
+            keep_alive, ka_enabled,
             h: RefCell::new(h),
-            enabled: if let Some(ka) = keep_alive { ka > 0 } else { false },
-            keep_alive: keep_alive.unwrap_or(0),
             bytes: Rc::new(SharedBytesPool::new()),
             messages: Rc::new(helpers::SharedMessagePool::new()),
             channels: Cell::new(0),
-            node: Node::head(),
+            node: Box::new(Node::head()),
         }
     }
 
@@ -96,7 +141,7 @@ impl<H> WorkerSettings<H> {
     }
 
     pub fn keep_alive_enabled(&self) -> bool {
-        self.enabled
+        self.ka_enabled
     }
 
     pub fn get_shared_bytes(&self) -> SharedBytes {

src/server/shared.rs

@@ -27,7 +27,7 @@ impl SharedBytesPool {
     pub fn release_bytes(&self, mut bytes: Rc<BytesMut>) {
         let v = &mut self.0.borrow_mut();
         if v.len() < 128 {
-            Rc::get_mut(&mut bytes).unwrap().take();
+            Rc::get_mut(&mut bytes).unwrap().clear();
             v.push_front(bytes);
         }
     }
@@ -62,7 +62,7 @@ impl SharedBytes {
     #[inline(always)]
     #[allow(mutable_transmutes)]
     #[cfg_attr(feature = "cargo-clippy", allow(mut_from_ref, inline_always))]
-    pub fn get_mut(&self) -> &mut BytesMut {
+    pub(crate) fn get_mut(&self) -> &mut BytesMut {
         let r: &BytesMut = self.0.as_ref().unwrap().as_ref();
         unsafe{mem::transmute(r)}
     }

src/server/srv.rs

@@ -2,7 +2,6 @@ use std::{io, net, thread};
 use std::rc::Rc;
 use std::sync::{Arc, mpsc as sync_mpsc};
 use std::time::Duration;
-use std::collections::HashMap;
 
 use actix::prelude::*;
 use actix::actors::signal;
@@ -20,13 +19,12 @@ use native_tls::TlsAcceptor;
 use openssl::ssl::{AlpnError, SslAcceptorBuilder};
 
 use helpers;
-use super::{IntoHttpHandler, IoStream};
+use super::{IntoHttpHandler, IoStream, KeepAlive};
 use super::{PauseServer, ResumeServer, StopServer};
 use super::channel::{HttpChannel, WrapperStream};
 use super::worker::{Conn, Worker, StreamHandlerType, StopWorker};
 use super::settings::{ServerSettings, WorkerSettings};
 
-
 /// An HTTP Server
 pub struct HttpServer<H> where H: IntoHttpHandler + 'static
 {
@@ -34,10 +32,11 @@ pub struct HttpServer<H> where H: IntoHttpHandler + 'static
     threads: usize,
     backlog: i32,
     host: Option<String>,
-    keep_alive: Option<u64>,
+    keep_alive: KeepAlive,
     factory: Arc<Fn() -> Vec<H> + Send + Sync>,
-    workers: Vec<Addr<Syn, Worker<H::Handler>>>,
-    sockets: HashMap<net::SocketAddr, net::TcpListener>,
+    #[cfg_attr(feature="cargo-clippy", allow(type_complexity))]
+    workers: Vec<(usize, Addr<Syn, Worker<H::Handler>>)>,
+    sockets: Vec<(net::SocketAddr, net::TcpListener)>,
     accept: Vec<(mio::SetReadiness, sync_mpsc::Sender<Command>)>,
     exit: bool,
     shutdown_timeout: u16,
@@ -48,6 +47,15 @@ pub struct HttpServer<H> where H: IntoHttpHandler + 'static
 unsafe impl<H> Sync for HttpServer<H> where H: IntoHttpHandler {}
 unsafe impl<H> Send for HttpServer<H> where H: IntoHttpHandler {}
 
+#[derive(Clone)]
+struct Info {
+    addr: net::SocketAddr,
+    handler: StreamHandlerType,
+}
+
+enum ServerCommand {
+    WorkerDied(usize, Info),
+}
 
 impl<H> Actor for HttpServer<H> where H: IntoHttpHandler
 {
@@ -68,15 +76,15 @@ impl<H> HttpServer<H> where H: IntoHttpHandler + 'static
         let f = move || {
             (factory)().into_iter().collect()
         };
-        
+
         HttpServer{ h: None,
                     threads: num_cpus::get(),
                     backlog: 2048,
                     host: None,
-                    keep_alive: None,
+                    keep_alive: KeepAlive::Os,
                     factory: Arc::new(f),
                     workers: Vec::new(),
-                    sockets: HashMap::new(),
+                    sockets: Vec::new(),
                     accept: Vec::new(),
                     exit: false,
                     shutdown_timeout: 30,
@@ -114,15 +122,9 @@ impl<H> HttpServer<H> where H: IntoHttpHandler + 'static
 
     /// Set server keep-alive setting.
     ///
-    /// By default keep alive is enabled.
-    ///
-    ///  - `Some(75)` - enable
-    ///
-    ///  - `Some(0)` - disable
-    ///
-    ///  - `None` - use `SO_KEEPALIVE` socket option
-    pub fn keep_alive(mut self, val: Option<u64>) -> Self {
-        self.keep_alive = val;
+    /// By default keep alive is set to a `Os`.
+    pub fn keep_alive<T: Into<KeepAlive>>(mut self, val: T) -> Self {
+        self.keep_alive = val.into();
         self
     }
 
@@ -170,7 +172,16 @@ impl<H> HttpServer<H> where H: IntoHttpHandler + 'static
 
     /// Get addresses of bound sockets.
     pub fn addrs(&self) -> Vec<net::SocketAddr> {
-        self.sockets.keys().cloned().collect()
+        self.sockets.iter().map(|s| s.0).collect()
+    }
+
+    /// Use listener for accepting incoming connection requests
+    ///
+    /// HttpServer does not change any configuration for TcpListener,
+    /// it needs to be configured before passing it to listen() method.
+    pub fn listen(mut self, lst: net::TcpListener) -> Self {
+        self.sockets.push((lst.local_addr().unwrap(), lst));
+        self
     }
 
     /// The socket address to bind
@@ -183,7 +194,7 @@ impl<H> HttpServer<H> where H: IntoHttpHandler + 'static
             match create_tcp_listener(addr, self.backlog) {
                 Ok(lst) => {
                     succ = true;
-                    self.sockets.insert(lst.local_addr().unwrap(), lst);
+                    self.sockets.push((lst.local_addr().unwrap(), lst));
                 },
                 Err(e) => err = Some(e),
             }
@@ -201,11 +212,11 @@ impl<H> HttpServer<H> where H: IntoHttpHandler + 'static
     }
 
     fn start_workers(&mut self, settings: &ServerSettings, handler: &StreamHandlerType)
-                     -> Vec<mpsc::UnboundedSender<Conn<net::TcpStream>>>
+                     -> Vec<(usize, mpsc::UnboundedSender<Conn<net::TcpStream>>)>
     {
         // start workers
         let mut workers = Vec::new();
-        for _ in 0..self.threads {
+        for idx in 0..self.threads {
             let s = settings.clone();
             let (tx, rx) = mpsc::unbounded::<Conn<net::TcpStream>>();
 
@@ -219,8 +230,8 @@ impl<H> HttpServer<H> where H: IntoHttpHandler + 'static
                 ctx.add_message_stream(rx);
                 Worker::new(apps, h, ka)
             });
-            workers.push(tx);
-            self.workers.push(addr);
+            workers.push((idx, tx));
+            self.workers.push((idx, addr));
         }
         info!("Starting {} http workers", self.threads);
         workers
@@ -274,21 +285,28 @@ impl<H: IntoHttpHandler> HttpServer<H>
         if self.sockets.is_empty() {
             panic!("HttpServer::bind() has to be called before start()");
         } else {
+            let (tx, rx) = mpsc::unbounded();
             let addrs: Vec<(net::SocketAddr, net::TcpListener)> =
-                self.sockets.drain().collect();
+                self.sockets.drain(..).collect();
             let settings = ServerSettings::new(Some(addrs[0].0), &self.host, false);
             let workers = self.start_workers(&settings, &StreamHandlerType::Normal);
+            let info = Info{addr: addrs[0].0, handler: StreamHandlerType::Normal};
 
             // start acceptors threads
             for (addr, sock) in addrs {
-                info!("Starting http server on {}", addr);
+                info!("Starting server on http://{}", addr);
                 self.accept.push(
-                    start_accept_thread(sock, addr, self.backlog, workers.clone()));
+                    start_accept_thread(
+                        sock, addr, self.backlog,
+                        tx.clone(), info.clone(), workers.clone()));
             }
 
             // start http server actor
             let signals = self.subscribe_to_signals();
-            let addr: Addr<Syn, _> = Actor::start(self);
+            let addr: Addr<Syn, _> = Actor::create(move |ctx| {
+                ctx.add_stream(rx);
+                self
+            });
             signals.map(|signals| signals.do_send(
                 signal::Subscribe(addr.clone().recipient())));
             addr
@@ -337,20 +355,28 @@ impl<H: IntoHttpHandler> HttpServer<H>
         if self.sockets.is_empty() {
             Err(io::Error::new(io::ErrorKind::Other, "No socket addresses are bound"))
         } else {
-            let addrs: Vec<(net::SocketAddr, net::TcpListener)> = self.sockets.drain().collect();
+            let (tx, rx) = mpsc::unbounded();
+            let addrs: Vec<(net::SocketAddr, net::TcpListener)> = self.sockets.drain(..).collect();
             let settings = ServerSettings::new(Some(addrs[0].0), &self.host, false);
-            let workers = self.start_workers(&settings, &StreamHandlerType::Tls(acceptor));
+            let workers = self.start_workers(
+                &settings, &StreamHandlerType::Tls(acceptor.clone()));
+            let info = Info{addr: addrs[0].0, handler: StreamHandlerType::Tls(acceptor)};
 
             // start acceptors threads
             for (addr, sock) in addrs {
-                info!("Starting tls http server on {}", addr);
+                info!("Starting server on https://{}", addr);
                 self.accept.push(
-                    start_accept_thread(sock, addr, self.backlog, workers.clone()));
+                    start_accept_thread(
+                        sock, addr, self.backlog,
+                        tx.clone(), info.clone(), workers.clone()));
             }
 
             // start http server actor
             let signals = self.subscribe_to_signals();
-            let addr: Addr<Syn, _> = Actor::start(self);
+            let addr: Addr<Syn, _> = Actor::create(|ctx| {
+                ctx.add_stream(rx);
+                self
+            });
             signals.map(|signals| signals.do_send(
                 signal::Subscribe(addr.clone().recipient())));
             Ok(addr)
@@ -380,21 +406,29 @@ impl<H: IntoHttpHandler> HttpServer<H>
                 }
             });
 
+            let (tx, rx) = mpsc::unbounded();
             let acceptor = builder.build();
-            let addrs: Vec<(net::SocketAddr, net::TcpListener)> = self.sockets.drain().collect();
+            let addrs: Vec<(net::SocketAddr, net::TcpListener)> = self.sockets.drain(..).collect();
             let settings = ServerSettings::new(Some(addrs[0].0), &self.host, false);
-            let workers = self.start_workers(&settings, &StreamHandlerType::Alpn(acceptor));
+            let workers = self.start_workers(
+                &settings, &StreamHandlerType::Alpn(acceptor.clone()));
+            let info = Info{addr: addrs[0].0, handler: StreamHandlerType::Alpn(acceptor)};
 
             // start acceptors threads
             for (addr, sock) in addrs {
-                info!("Starting tls http server on {}", addr);
+                info!("Starting server on https://{}", addr);
                 self.accept.push(
-                    start_accept_thread(sock, addr, self.backlog, workers.clone()));
+                    start_accept_thread(
+                        sock, addr, self.backlog,
+                        tx.clone(), info.clone(), workers.clone()));
             }
 
             // start http server actor
             let signals = self.subscribe_to_signals();
-            let addr: Addr<Syn, _> = Actor::start(self);
+            let addr: Addr<Syn, _> = Actor::create(|ctx| {
+                ctx.add_stream(rx);
+                self
+            });
             signals.map(|signals| signals.do_send(
                 signal::Subscribe(addr.clone().recipient())));
             Ok(addr)
@@ -412,17 +446,22 @@ impl<H: IntoHttpHandler> HttpServer<H>
               T: AsyncRead + AsyncWrite + 'static,
               A: 'static
     {
+        let (tx, rx) = mpsc::unbounded();
+
         if !self.sockets.is_empty() {
             let addrs: Vec<(net::SocketAddr, net::TcpListener)> =
-                self.sockets.drain().collect();
+                self.sockets.drain(..).collect();
             let settings = ServerSettings::new(Some(addrs[0].0), &self.host, false);
             let workers = self.start_workers(&settings, &StreamHandlerType::Normal);
+            let info = Info{addr: addrs[0].0, handler: StreamHandlerType::Normal};
 
             // start acceptors threads
             for (addr, sock) in addrs {
-                info!("Starting http server on {}", addr);
+                info!("Starting server on http://{}", addr);
                 self.accept.push(
-                    start_accept_thread(sock, addr, self.backlog, workers.clone()));
+                    start_accept_thread(
+                        sock, addr, self.backlog,
+                        tx.clone(), info.clone(), workers.clone()));
             }
         }
 
@@ -436,6 +475,7 @@ impl<H: IntoHttpHandler> HttpServer<H>
         // start server
         let signals = self.subscribe_to_signals();
         let addr: Addr<Syn, _> = HttpServer::create(move |ctx| {
+            ctx.add_stream(rx);
             ctx.add_message_stream(
                 stream
                     .map_err(|_| ())
@@ -477,6 +517,61 @@ impl<H: IntoHttpHandler> Handler<signal::Signal> for HttpServer<H>
     }
 }
 
+/// Commands from accept threads
+impl<H: IntoHttpHandler> StreamHandler<ServerCommand, ()> for HttpServer<H>
+{
+    fn finished(&mut self, _: &mut Context<Self>) {}
+    fn handle(&mut self, msg: ServerCommand, _: &mut Context<Self>) {
+        match msg {
+            ServerCommand::WorkerDied(idx, info) => {
+                let mut found = false;
+                for i in 0..self.workers.len() {
+                    if self.workers[i].0 == idx {
+                        self.workers.swap_remove(i);
+                        found = true;
+                        break
+                    }
+                }
+
+                if found {
+                    error!("Worker has died {:?}, restarting", idx);
+                    let (tx, rx) = mpsc::unbounded::<Conn<net::TcpStream>>();
+
+                    let mut new_idx = self.workers.len();
+                    'found: loop {
+                        for i in 0..self.workers.len() {
+                            if self.workers[i].0 == new_idx {
+                                new_idx += 1;
+                                continue 'found
+                            }
+                        }
+                        break
+                    }
+
+                    let h = info.handler;
+                    let ka = self.keep_alive;
+                    let factory = Arc::clone(&self.factory);
+                    let settings = ServerSettings::new(Some(info.addr), &self.host, false);
+
+                    let addr = Arbiter::start(move |ctx: &mut Context<_>| {
+                        let apps: Vec<_> = (*factory)()
+                            .into_iter()
+                            .map(|h| h.into_handler(settings.clone())).collect();
+                        ctx.add_message_stream(rx);
+                        Worker::new(apps, h, ka)
+                    });
+                    for item in &self.accept {
+                        let _ = item.1.send(Command::Worker(new_idx, tx.clone()));
+                        let _ = item.0.set_readiness(mio::Ready::readable());
+                    }
+
+                    self.workers.push((new_idx, addr));
+                }
+            },
+        }
+    }
+}
+
 impl<T, H> Handler<Conn<T>> for HttpServer<H>
     where T: IoStream,
           H: IntoHttpHandler,
@@ -536,7 +631,7 @@ impl<H: IntoHttpHandler> Handler<StopServer> for HttpServer<H>
         };
         for worker in &self.workers {
             let tx2 = tx.clone();
-            let fut = worker.send(StopWorker{graceful: dur}).into_actor(self);
+            let fut = worker.1.send(StopWorker{graceful: dur}).into_actor(self);
             ActorFuture::then(fut, move |_, slf, _| {
                 slf.workers.pop();
                 if slf.workers.is_empty() {
@@ -568,16 +663,20 @@ enum Command {
     Pause,
     Resume,
     Stop,
+    Worker(usize, mpsc::UnboundedSender<Conn<net::TcpStream>>),
 }
 
-fn start_accept_thread(sock: net::TcpListener, addr: net::SocketAddr, backlog: i32,
-                       workers: Vec<mpsc::UnboundedSender<Conn<net::TcpStream>>>)
-                       -> (mio::SetReadiness, sync_mpsc::Sender<Command>)
+fn start_accept_thread(
+    sock: net::TcpListener, addr: net::SocketAddr, backlog: i32,
+    srv: mpsc::UnboundedSender<ServerCommand>, info: Info,
+    mut workers: Vec<(usize, mpsc::UnboundedSender<Conn<net::TcpStream>>)>)
+    -> (mio::SetReadiness, sync_mpsc::Sender<Command>)
 {
     let (tx, rx) = sync_mpsc::channel();
     let (reg, readiness) = mio::Registration::new2();
 
     // start accept thread
+    #[cfg_attr(feature="cargo-clippy", allow(cyclomatic_complexity))]
     let _ = thread::Builder::new().name(format!("Accept on {}", addr)).spawn(move || {
         const SRV: mio::Token = mio::Token(0);
         const CMD: mio::Token = mio::Token(1);
@@ -609,6 +708,9 @@ fn start_accept_thread(sock: net::TcpListener, addr: net::SocketAddr, backlog: i
         // Create storage for events
         let mut events = mio::Events::with_capacity(128);
 
+        // Sleep on error
+        let sleep = Duration::from_millis(100);
+
         let mut next = 0;
         loop {
             if let Err(err) = poll.poll(&mut events, None) {
@@ -617,23 +719,37 @@ fn start_accept_thread(sock: net::TcpListener, addr: net::SocketAddr, backlog: i
 
             for event in events.iter() {
                 match event.token() {
-                    SRV => {
-                        if let Some(ref server) = server {
-                            loop {
-                                match server.accept_std() {
-                                    Ok((sock, addr)) => {
-                                        let msg = Conn{
-                                            io: sock, peer: Some(addr), http2: false};
-                                        workers[next].unbounded_send(msg)
-                                            .expect("worker thread died");
-                                        next = (next + 1) % workers.len();
-                                    },
-                                    Err(err) => {
-                                        if err.kind() != io::ErrorKind::WouldBlock {
-                                            error!("Error accepting connection: {:?}", err);
+                    SRV => if let Some(ref server) = server {
+                        loop {
+                            match server.accept_std() {
+                                Ok((sock, addr)) => {
+                                    let mut msg = Conn{
+                                        io: sock, peer: Some(addr), http2: false};
+                                    while !workers.is_empty() {
+                                        match workers[next].1.unbounded_send(msg) {
+                                            Ok(_) => (),
+                                            Err(err) => {
+                                                let _ = srv.unbounded_send(
+                                                    ServerCommand::WorkerDied(
+                                                        workers[next].0, info.clone()));
+                                                msg = err.into_inner();
+                                                workers.swap_remove(next);
+                                                continue
+                                            }
                                         }
+                                        next = (next + 1) % workers.len();
                                         break
                                     }
+                                },
+                                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock =>
+                                    break,
+                                Err(ref e) if connection_error(e) =>
+                                    continue,
+                                Err(e) => {
+                                    error!("Error accepting connection: {}", e);
+                                    // sleep after error
+                                    thread::sleep(sleep);
+                                    break
                                 }
                             }
                         }
@@ -672,6 +788,9 @@ fn start_accept_thread(sock: net::TcpListener, addr: net::SocketAddr, backlog: i
                                 }
                                 return
                             },
+                            Command::Worker(idx, addr) => {
+                                workers.push((idx, addr));
+                            },
                         },
                         Err(err) => match err {
                             sync_mpsc::TryRecvError::Empty => (),
@@ -697,7 +816,20 @@ fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result<net::T
         net::SocketAddr::V4(_) => TcpBuilder::new_v4()?,
         net::SocketAddr::V6(_) => TcpBuilder::new_v6()?,
     };
-    builder.bind(addr)?;
     builder.reuse_address(true)?;
+    builder.bind(addr)?;
     Ok(builder.listen(backlog)?)
 }
+
+/// This function defines errors that are per-connection. Which basically
+/// means that if we get this error from `accept()` system call it means
+/// next connection might be ready to be accepted.
+///
+/// All other errors will incur a timeout before next `accept()` is performed.
+/// The timeout is useful to handle resource exhaustion errors like ENFILE
+/// and EMFILE. Otherwise, could enter into tight loop.
+fn connection_error(e: &io::Error) -> bool {
+    e.kind() == io::ErrorKind::ConnectionRefused ||
+        e.kind() == io::ErrorKind::ConnectionAborted ||
+        e.kind() == io::ErrorKind::ConnectionReset
+}

src/server/worker.rs

@@ -23,7 +23,7 @@ use actix::*;
 use actix::msgs::StopArbiter;
 
 use helpers;
-use server::HttpHandler;
+use server::{HttpHandler, KeepAlive};
 use server::channel::HttpChannel;
 use server::settings::WorkerSettings;
 
@@ -48,21 +48,30 @@ impl Message for StopWorker {
 /// Http worker
 ///
 /// Worker accepts Socket objects via unbounded channel and start requests processing.
-pub(crate) struct Worker<H> where H: HttpHandler + 'static {
+pub(crate)
+struct Worker<H> where H: HttpHandler + 'static {
     settings: Rc<WorkerSettings<H>>,
     hnd: Handle,
     handler: StreamHandlerType,
+    tcp_ka: Option<time::Duration>,
 }
 
 impl<H: HttpHandler + 'static> Worker<H> {
 
-    pub(crate) fn new(h: Vec<H>, handler: StreamHandlerType, keep_alive: Option<u64>)
+    pub(crate) fn new(h: Vec<H>, handler: StreamHandlerType, keep_alive: KeepAlive)
                       -> Worker<H>
     {
+        let tcp_ka = if let KeepAlive::Tcp(val) = keep_alive {
+            Some(time::Duration::new(val as u64, 0))
+        } else {
+            None
+        };
+
         Worker {
             settings: Rc::new(WorkerSettings::new(h, keep_alive)),
             hnd: Arbiter::handle().clone(),
             handler,
+            tcp_ka,
         }
     }
 
@@ -106,9 +115,7 @@ impl<H> Handler<Conn<net::TcpStream>> for Worker<H>
 
     fn handle(&mut self, msg: Conn<net::TcpStream>, _: &mut Context<Self>)
     {
-        if !self.settings.keep_alive_enabled() &&
-            msg.io.set_keepalive(Some(time::Duration::new(75, 0))).is_err()
-        {
+        if self.tcp_ka.is_some() && msg.io.set_keepalive(self.tcp_ka).is_err() {
             error!("Can not set socket keep-alive option");
         }
         self.handler.handle(Rc::clone(&self.settings), &self.hnd, msg);

src/test.rs

@@ -8,14 +8,16 @@ use std::str::FromStr;
 use actix::{Arbiter, Addr, Syn, System, SystemRunner, msgs};
 use cookie::Cookie;
 use http::{Uri, Method, Version, HeaderMap, HttpTryFrom};
-use http::header::{HeaderName, HeaderValue};
+use http::header::HeaderName;
 use futures::Future;
 use tokio_core::net::TcpListener;
 use tokio_core::reactor::Core;
 use net2::TcpBuilder;
 
+use ws;
 use body::Binary;
 use error::Error;
+use header::{Header, IntoHeaderValue};
 use handler::{Handler, Responder, ReplyItem};
 use middleware::Middleware;
 use application::{Application, HttpApplication};
@@ -25,7 +27,6 @@ use payload::Payload;
 use httprequest::HttpRequest;
 use httpresponse::HttpResponse;
 use server::{HttpServer, IntoHttpHandler, ServerSettings};
-use ws::{WsClient, WsClientError, WsClientReader, WsClientWriter};
 use client::{ClientRequest, ClientRequestBuilder};
 
 /// The `TestServer` type.
@@ -180,9 +181,9 @@ impl TestServer {
     }
 
     /// Connect to websocket server
-    pub fn ws(&mut self) -> Result<(WsClientReader, WsClientWriter), WsClientError> {
+    pub fn ws(&mut self) -> Result<(ws::ClientReader, ws::ClientWriter), ws::ClientError> {
         let url = self.url("/");
-        self.system.run_until_complete(WsClient::new(url).connect())
+        self.system.run_until_complete(ws::Client::new(url).connect())
     }
 
     /// Create `GET` request
@@ -332,10 +333,15 @@ impl TestRequest<()> {
         TestRequest::default().uri(path)
     }
 
+    /// Create TestRequest and set header
+    pub fn with_hdr<H: Header>(hdr: H) -> TestRequest<()>
+    {
+        TestRequest::default().set(hdr)
+    }
+
     /// Create TestRequest and set header
     pub fn with_header<K, V>(key: K, value: V) -> TestRequest<()>
-        where HeaderName: HttpTryFrom<K>,
-              HeaderValue: HttpTryFrom<V>
+        where HeaderName: HttpTryFrom<K>, V: IntoHeaderValue,
     {
         TestRequest::default().header(key, value)
     }
@@ -375,13 +381,22 @@ impl<S> TestRequest<S> {
         self
     }
 
+    /// Set a header
+    pub fn set<H: Header>(mut self, hdr: H) -> Self
+    {
+        if let Ok(value) = hdr.try_into() {
+            self.headers.append(H::name(), value);
+            return self
+        }
+        panic!("Can not set header");
+    }
+
     /// Set a header
     pub fn header<K, V>(mut self, key: K, value: V) -> Self
-        where HeaderName: HttpTryFrom<K>,
-              HeaderValue: HttpTryFrom<V>
+        where HeaderName: HttpTryFrom<K>, V: IntoHeaderValue
     {
         if let Ok(key) = HeaderName::try_from(key) {
-            if let Ok(value) = HeaderValue::try_from(value) {
+            if let Ok(value) = value.try_into() {
                 self.headers.append(key, value);
                 return self
             }
@@ -416,12 +431,14 @@ impl<S> TestRequest<S> {
 
     #[cfg(test)]
     /// Complete request creation and generate `HttpRequest` instance
-    pub(crate) fn finish_no_router(self) -> HttpRequest<S> {
-        let TestRequest { state, method, uri, version, headers, params, cookies, payload } = self;
+    pub(crate) fn finish_with_router(self, router: Router) -> HttpRequest<S> {
+        let TestRequest { state, method, uri,
+                          version, headers, params, cookies, payload } = self;
+
         let req = HttpRequest::new(method, uri, version, headers, payload);
         req.as_mut().cookies = cookies;
         req.as_mut().params = params;
-        req.with_state_no_router(Rc::new(state))
+        req.with_state(Rc::new(state), router)
     }
 
     /// This method generates `HttpRequest` instance and runs handler

src/ws/client.rs

@@ -2,22 +2,24 @@
 use std::{fmt, io, str};
 use std::rc::Rc;
 use std::cell::UnsafeCell;
+use std::time::Duration;
 
 use base64;
 use rand;
 use bytes::Bytes;
 use cookie::Cookie;
+use byteorder::{ByteOrder, NetworkEndian};
 use http::{HttpTryFrom, StatusCode, Error as HttpError};
 use http::header::{self, HeaderName, HeaderValue};
 use sha1::Sha1;
 use futures::{Async, Future, Poll, Stream};
 use futures::unsync::mpsc::{unbounded, UnboundedSender};
-use byteorder::{ByteOrder, NetworkEndian};
 
 use actix::prelude::*;
 
 use body::{Body, Binary};
 use error::UrlParseError;
+use header::IntoHeaderValue;
 use payload::PayloadHelper;
 use httpmessage::HttpMessage;
 
@@ -25,14 +27,32 @@ use client::{ClientRequest, ClientRequestBuilder, ClientResponse,
              ClientConnector, SendRequest, SendRequestError,
              HttpResponseParserError};
 
-use super::{Message, WsError};
+use super::{Message, ProtocolError};
 use super::frame::Frame;
 use super::proto::{CloseCode, OpCode};
 
 
+/// Backward compatibility
+#[doc(hidden)]
+#[deprecated(since="0.4.2", note="please use `ws::Client` instead")]
+pub type WsClient = Client;
+#[doc(hidden)]
+#[deprecated(since="0.4.2", note="please use `ws::ClientError` instead")]
+pub type WsClientError = ClientError;
+#[doc(hidden)]
+#[deprecated(since="0.4.2", note="please use `ws::ClientReader` instead")]
+pub type WsClientReader = ClientReader;
+#[doc(hidden)]
+#[deprecated(since="0.4.2", note="please use `ws::ClientWriter` instead")]
+pub type WsClientWriter = ClientWriter;
+#[doc(hidden)]
+#[deprecated(since="0.4.2", note="please use `ws::ClientHandshake` instead")]
+pub type WsClientHandshake = ClientHandshake;
+
+
 /// Websocket client error
 #[derive(Fail, Debug)]
-pub enum WsClientError {
+pub enum ClientError {
     #[fail(display="Invalid url")]
     InvalidUrl,
     #[fail(display="Invalid response status")]
@@ -56,46 +76,46 @@ pub enum WsClientError {
     #[fail(display="{}", _0)]
     SendRequest(SendRequestError),
     #[fail(display="{}", _0)]
-    Protocol(#[cause] WsError),
+    Protocol(#[cause] ProtocolError),
     #[fail(display="{}", _0)]
     Io(io::Error),
     #[fail(display="Disconnected")]
     Disconnected,
 }
 
-impl From<HttpError> for WsClientError {
-    fn from(err: HttpError) -> WsClientError {
-        WsClientError::Http(err)
+impl From<HttpError> for ClientError {
+    fn from(err: HttpError) -> ClientError {
+        ClientError::Http(err)
     }
 }
 
-impl From<UrlParseError> for WsClientError {
-    fn from(err: UrlParseError) -> WsClientError {
-        WsClientError::Url(err)
+impl From<UrlParseError> for ClientError {
+    fn from(err: UrlParseError) -> ClientError {
+        ClientError::Url(err)
     }
 }
 
-impl From<SendRequestError> for WsClientError {
-    fn from(err: SendRequestError) -> WsClientError {
-        WsClientError::SendRequest(err)
+impl From<SendRequestError> for ClientError {
+    fn from(err: SendRequestError) -> ClientError {
+        ClientError::SendRequest(err)
     }
 }
 
-impl From<WsError> for WsClientError {
-    fn from(err: WsError) -> WsClientError {
-        WsClientError::Protocol(err)
+impl From<ProtocolError> for ClientError {
+    fn from(err: ProtocolError) -> ClientError {
+        ClientError::Protocol(err)
     }
 }
 
-impl From<io::Error> for WsClientError {
-    fn from(err: io::Error) -> WsClientError {
-        WsClientError::Io(err)
+impl From<io::Error> for ClientError {
+    fn from(err: io::Error) -> ClientError {
+        ClientError::Io(err)
     }
 }
 
-impl From<HttpResponseParserError> for WsClientError {
-    fn from(err: HttpResponseParserError) -> WsClientError {
-        WsClientError::ResponseParseError(err)
+impl From<HttpResponseParserError> for ClientError {
+    fn from(err: HttpResponseParserError) -> ClientError {
+        ClientError::ResponseParseError(err)
     }
 }
 
@@ -104,9 +124,9 @@ impl From<HttpResponseParserError> for WsClientError {
 /// Example of `WebSocket` client usage is available in
 /// [websocket example](
 /// https://github.com/actix/actix-web/blob/master/examples/websocket/src/client.rs#L24)
-pub struct WsClient {
+pub struct Client {
     request: ClientRequestBuilder,
-    err: Option<WsClientError>,
+    err: Option<ClientError>,
     http_err: Option<HttpError>,
     origin: Option<HeaderValue>,
     protocols: Option<String>,
@@ -114,16 +134,16 @@ pub struct WsClient {
     max_size: usize,
 }
 
-impl WsClient {
+impl Client {
 
     /// Create new websocket connection
-    pub fn new<S: AsRef<str>>(uri: S) -> WsClient {
-        WsClient::with_connector(uri, ClientConnector::from_registry())
+    pub fn new<S: AsRef<str>>(uri: S) -> Client {
+        Client::with_connector(uri, ClientConnector::from_registry())
     }
 
     /// Create new websocket connection with custom `ClientConnector`
-    pub fn with_connector<S: AsRef<str>>(uri: S, conn: Addr<Unsync, ClientConnector>) -> WsClient {
-        let mut cl = WsClient {
+    pub fn with_connector<S: AsRef<str>>(uri: S, conn: Addr<Unsync, ClientConnector>) -> Client {
+        let mut cl = Client {
             request: ClientRequest::build(),
             err: None,
             http_err: None,
@@ -173,21 +193,29 @@ impl WsClient {
         self
     }
 
+    /// Set write buffer capacity
+    ///
+    /// Default buffer capacity is 32kb
+    pub fn write_buffer_capacity(mut self, cap: usize) -> Self {
+        self.request.write_buffer_capacity(cap);
+        self
+    }
+
     /// Set request header
     pub fn header<K, V>(mut self, key: K, value: V) -> Self
-        where HeaderName: HttpTryFrom<K>, HeaderValue: HttpTryFrom<V>
+        where HeaderName: HttpTryFrom<K>, V: IntoHeaderValue
     {
         self.request.header(key, value);
         self
     }
 
     /// Connect to websocket server and do ws handshake
-    pub fn connect(&mut self) -> WsClientHandshake {
+    pub fn connect(&mut self) -> ClientHandshake {
         if let Some(e) = self.err.take() {
-            WsClientHandshake::error(e)
+            ClientHandshake::error(e)
         }
         else if let Some(e) = self.http_err.take() {
-            WsClientHandshake::error(e.into())
+            ClientHandshake::error(e.into())
         } else {
             // origin
             if let Some(origin) = self.origin.take() {
@@ -205,42 +233,42 @@ impl WsClient {
             }
             let request = match self.request.finish() {
                 Ok(req) => req,
-                Err(err) => return WsClientHandshake::error(err.into()),
+                Err(err) => return ClientHandshake::error(err.into()),
             };
 
             if request.uri().host().is_none() {
-                return WsClientHandshake::error(WsClientError::InvalidUrl)
+                return ClientHandshake::error(ClientError::InvalidUrl)
             }
             if let Some(scheme) = request.uri().scheme_part() {
                 if scheme != "http" && scheme != "https" && scheme != "ws" && scheme != "wss" {
-                    return WsClientHandshake::error(WsClientError::InvalidUrl)
+                    return ClientHandshake::error(ClientError::InvalidUrl)
                 }
             } else {
-                return WsClientHandshake::error(WsClientError::InvalidUrl)
+                return ClientHandshake::error(ClientError::InvalidUrl)
             }
 
             // start handshake
-            WsClientHandshake::new(request, self.max_size)
+            ClientHandshake::new(request, self.max_size)
         }
     }
 }
 
-struct WsInner {
+struct Inner {
     tx: UnboundedSender<Bytes>,
     rx: PayloadHelper<ClientResponse>,
     closed: bool,
 }
 
-pub struct WsClientHandshake {
+pub struct ClientHandshake {
     request: Option<SendRequest>,
     tx: Option<UnboundedSender<Bytes>>,
     key: String,
-    error: Option<WsClientError>,
+    error: Option<ClientError>,
     max_size: usize,
 }
 
-impl WsClientHandshake {
-    fn new(mut request: ClientRequest, max_size: usize) -> WsClientHandshake
+impl ClientHandshake {
+    fn new(mut request: ClientRequest, max_size: usize) -> ClientHandshake
     {
         // Generate a random key for the `Sec-WebSocket-Key` header.
         // a base64-encoded (see Section 4 of [RFC4648]) value that,
@@ -257,7 +285,7 @@ impl WsClientHandshake {
             Box::new(rx.map_err(|_| io::Error::new(
                 io::ErrorKind::Other, "disconnected").into()))));
 
-        WsClientHandshake {
+        ClientHandshake {
             key,
             max_size,
             request: Some(request.send()),
@@ -266,20 +294,43 @@ impl WsClientHandshake {
         }
     }
 
-    fn error(err: WsClientError) -> WsClientHandshake {
-        WsClientHandshake {
+    fn error(err: ClientError) -> ClientHandshake {
+        ClientHandshake {
             key: String::new(),
             request: None,
             tx: None,
             error: Some(err),
-            max_size: 0
+            max_size: 0,
         }
     }
+
+    /// Set handshake timeout
+    ///
+    /// Handshake timeout is a total time before handshake should be completed.
+    /// Default value is 5 seconds.
+    pub fn timeout(mut self, timeout: Duration) -> Self {
+        if let Some(request) = self.request.take() {
+            self.request = Some(request.timeout(timeout));
+        }
+        self
+    }
+
+    /// Set connection timeout
+    ///
+    /// Connection timeout includes resolving hostname and actual connection to
+    /// the host.
+    /// Default value is 1 second.
+    pub fn conn_timeout(mut self, timeout: Duration) -> Self {
+        if let Some(request) = self.request.take() {
+            self.request = Some(request.conn_timeout(timeout));
+        }
+        self
+    }
 }
 
-impl Future for WsClientHandshake {
-    type Item = (WsClientReader, WsClientWriter);
-    type Error = WsClientError;
+impl Future for ClientHandshake {
+    type Item = (ClientReader, ClientWriter);
+    type Error = ClientError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         if let Some(err) = self.error.take() {
@@ -296,7 +347,7 @@ impl Future for WsClientHandshake {
 
         // verify response
         if resp.status() != StatusCode::SWITCHING_PROTOCOLS {
-            return Err(WsClientError::InvalidResponseStatus(resp.status()))
+            return Err(ClientError::InvalidResponseStatus(resp.status()))
         }
         // Check for "UPGRADE" to websocket header
         let has_hdr = if let Some(hdr) = resp.headers().get(header::UPGRADE) {
@@ -310,22 +361,22 @@ impl Future for WsClientHandshake {
         };
         if !has_hdr {
             trace!("Invalid upgrade header");
-            return Err(WsClientError::InvalidUpgradeHeader)
+            return Err(ClientError::InvalidUpgradeHeader)
         }
         // Check for "CONNECTION" header
         if let Some(conn) = resp.headers().get(header::CONNECTION) {
             if let Ok(s) = conn.to_str() {
                 if !s.to_lowercase().contains("upgrade") {
                     trace!("Invalid connection header: {}", s);
-                    return Err(WsClientError::InvalidConnectionHeader(conn.clone()))
+                    return Err(ClientError::InvalidConnectionHeader(conn.clone()))
                 }
             } else {
                 trace!("Invalid connection header: {:?}", conn);
-                return Err(WsClientError::InvalidConnectionHeader(conn.clone()))
+                return Err(ClientError::InvalidConnectionHeader(conn.clone()))
             }
         } else {
             trace!("Missing connection header");
-            return Err(WsClientError::MissingConnectionHeader)
+            return Err(ClientError::MissingConnectionHeader)
         }
 
         if let Some(key) = resp.headers().get(header::SEC_WEBSOCKET_ACCEPT)
@@ -341,14 +392,14 @@ impl Future for WsClientHandshake {
                 trace!(
                     "Invalid challenge response: expected: {} received: {:?}",
                     encoded, key);
-                return Err(WsClientError::InvalidChallengeResponse(encoded, key.clone()));
+                return Err(ClientError::InvalidChallengeResponse(encoded, key.clone()));
             }
         } else {
             trace!("Missing SEC-WEBSOCKET-ACCEPT header");
-            return Err(WsClientError::MissingWebSocketAcceptHeader)
+            return Err(ClientError::MissingWebSocketAcceptHeader)
         };
 
-        let inner = WsInner {
+        let inner = Inner {
             tx: self.tx.take().unwrap(),
             rx: PayloadHelper::new(resp),
             closed: false,
@@ -356,33 +407,33 @@ impl Future for WsClientHandshake {
 
         let inner = Rc::new(UnsafeCell::new(inner));
         Ok(Async::Ready(
-            (WsClientReader{inner: Rc::clone(&inner), max_size: self.max_size},
-             WsClientWriter{inner})))
+            (ClientReader{inner: Rc::clone(&inner), max_size: self.max_size},
+             ClientWriter{inner})))
     }
 }
 
 
-pub struct WsClientReader {
-    inner: Rc<UnsafeCell<WsInner>>,
+pub struct ClientReader {
+    inner: Rc<UnsafeCell<Inner>>,
     max_size: usize,
 }
 
-impl fmt::Debug for WsClientReader {
+impl fmt::Debug for ClientReader {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "WsClientReader()")
+        write!(f, "ws::ClientReader()")
     }
 }
 
-impl WsClientReader {
+impl ClientReader {
     #[inline]
-    fn as_mut(&mut self) -> &mut WsInner {
+    fn as_mut(&mut self) -> &mut Inner {
         unsafe{ &mut *self.inner.get() }
     }
 }
 
-impl Stream for WsClientReader {
+impl Stream for ClientReader {
     type Item = Message;
-    type Error = WsError;
+    type Error = ProtocolError;
 
     fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
         let max_size = self.max_size;
@@ -399,14 +450,14 @@ impl Stream for WsClientReader {
                 // continuation is not supported
                 if !finished {
                     inner.closed = true;
-                    return Err(WsError::NoContinuation)
+                    return Err(ProtocolError::NoContinuation)
                 }
 
                 match opcode {
                     OpCode::Continue => unimplemented!(),
                     OpCode::Bad => {
                         inner.closed = true;
-                        Err(WsError::BadOpCode)
+                        Err(ProtocolError::BadOpCode)
                     },
                     OpCode::Close => {
                         inner.closed = true;
@@ -430,7 +481,7 @@ impl Stream for WsClientReader {
                                 Ok(Async::Ready(Some(Message::Text(s)))),
                             Err(_) => {
                                 inner.closed = true;
-                                Err(WsError::BadEncoding)
+                                Err(ProtocolError::BadEncoding)
                             }
                         }
                     }
@@ -446,18 +497,18 @@ impl Stream for WsClientReader {
     }
 }
 
-pub struct WsClientWriter {
-    inner: Rc<UnsafeCell<WsInner>>
+pub struct ClientWriter {
+    inner: Rc<UnsafeCell<Inner>>
 }
 
-impl WsClientWriter {
+impl ClientWriter {
     #[inline]
-    fn as_mut(&mut self) -> &mut WsInner {
+    fn as_mut(&mut self) -> &mut Inner {
         unsafe{ &mut *self.inner.get() }
     }
 }
 
-impl WsClientWriter {
+impl ClientWriter {
 
     /// Write payload
     #[inline]
@@ -471,7 +522,7 @@ impl WsClientWriter {
 
     /// Send text frame
     #[inline]
-    pub fn text<T: Into<String>>(&mut self, text: T) {
+    pub fn text<T: Into<Binary>>(&mut self, text: T) {
         self.write(Frame::message(text.into(), OpCode::Text, true, true));
     }
 

src/ws/context.rs

@@ -132,7 +132,7 @@ impl<A, S> WebsocketContext<A, S> where A: Actor<Context=Self> {
 
     /// Send text frame
     #[inline]
-    pub fn text<T: Into<String>>(&mut self, text: T) {
+    pub fn text<T: Into<Binary>>(&mut self, text: T) {
         self.write(Frame::message(text.into(), OpCode::Text, true, false));
     }
 

src/ws/frame.rs

@@ -1,4 +1,4 @@
-use std::{fmt, mem};
+use std::{fmt, mem, ptr};
 use std::iter::FromIterator;
 use bytes::{Bytes, BytesMut, BufMut};
 use byteorder::{ByteOrder, BigEndian, NetworkEndian};
@@ -9,17 +9,14 @@ use body::Binary;
 use error::{PayloadError};
 use payload::PayloadHelper;
 
-use ws::WsError;
+use ws::ProtocolError;
 use ws::proto::{OpCode, CloseCode};
 use ws::mask::apply_mask;
 
 /// A struct representing a `WebSocket` frame.
 #[derive(Debug)]
-pub(crate) struct Frame {
+pub struct Frame {
     finished: bool,
-    rsv1: bool,
-    rsv2: bool,
-    rsv3: bool,
     opcode: OpCode,
     payload: Binary,
 }
@@ -51,9 +48,11 @@ impl Frame {
         Frame::message(payload, OpCode::Close, true, genmask)
     }
 
-    /// Parse the input stream into a frame.
-    pub fn parse<S>(pl: &mut PayloadHelper<S>, server: bool, max_size: usize)
-                    -> Poll<Option<Frame>, WsError>
+    #[cfg_attr(feature="cargo-clippy", allow(type_complexity))]
+    fn read_copy_md<S>(pl: &mut PayloadHelper<S>,
+                       server: bool,
+                       max_size: usize
+    ) -> Poll<Option<(usize, bool, OpCode, usize, Option<u32>)>, ProtocolError>
         where S: Stream<Item=Bytes, Error=PayloadError>
     {
         let mut idx = 2;
@@ -69,17 +68,19 @@ impl Frame {
         // check masking
         let masked = second & 0x80 != 0;
         if !masked && server {
-            return Err(WsError::UnmaskedFrame)
+            return Err(ProtocolError::UnmaskedFrame)
         } else if masked && !server {
-            return Err(WsError::MaskedFrame)
+            return Err(ProtocolError::MaskedFrame)
         }
 
-        let rsv1 = first & 0x40 != 0;
-        let rsv2 = first & 0x20 != 0;
-        let rsv3 = first & 0x10 != 0;
+        // Op code
         let opcode = OpCode::from(first & 0x0F);
-        let len = second & 0x7F;
 
+        if let OpCode::Bad = opcode {
+            return Err(ProtocolError::InvalidOpcode(first & 0x0F))
+        }
+
+        let len = second & 0x7F;
         let length = if len == 126 {
             let buf = match pl.copy(4)? {
                 Async::Ready(Some(buf)) => buf,
@@ -104,7 +105,7 @@ impl Frame {
 
         // check for max allowed size
         if length > max_size {
-            return Err(WsError::Overflow)
+            return Err(ProtocolError::Overflow)
         }
 
         let mask = if server {
@@ -114,32 +115,133 @@ impl Frame {
                 Async::NotReady => return Ok(Async::NotReady),
             };
 
-            let mut mask_bytes = [0u8; 4];
-            mask_bytes.copy_from_slice(&buf[idx..idx+4]);
+            let mask: &[u8] = &buf[idx..idx+4];
+            let mask_u32: u32 = unsafe {ptr::read_unaligned(mask.as_ptr() as *const u32)};
             idx += 4;
-            Some(mask_bytes)
+            Some(mask_u32)
         } else {
             None
         };
 
-        let mut data = match pl.readexactly(idx + length)? {
-            Async::Ready(Some(buf)) => buf,
-            Async::Ready(None) => return Ok(Async::Ready(None)),
-            Async::NotReady => return Ok(Async::NotReady),
+        Ok(Async::Ready(Some((idx, finished, opcode, length, mask))))
+    }
+
+    fn read_chunk_md(chunk: &[u8], server: bool, max_size: usize)
+                     -> Poll<(usize, bool, OpCode, usize, Option<u32>), ProtocolError>
+    {
+        let chunk_len = chunk.len();
+
+        let mut idx = 2;
+        if chunk_len < 2 {
+            return Ok(Async::NotReady)
+        }
+
+        let first = chunk[0];
+        let second = chunk[1];
+        let finished = first & 0x80 != 0;
+
+        // check masking
+        let masked = second & 0x80 != 0;
+        if !masked && server {
+            return Err(ProtocolError::UnmaskedFrame)
+        } else if masked && !server {
+            return Err(ProtocolError::MaskedFrame)
+        }
+
+        // Op code
+        let opcode = OpCode::from(first & 0x0F);
+
+        if let OpCode::Bad = opcode {
+            return Err(ProtocolError::InvalidOpcode(first & 0x0F))
+        }
+
+        let len = second & 0x7F;
+        let length = if len == 126 {
+            if chunk_len < 4 {
+                return Ok(Async::NotReady)
+            }
+            let len = NetworkEndian::read_uint(&chunk[idx..], 2) as usize;
+            idx += 2;
+            len
+        } else if len == 127 {
+            if chunk_len < 10 {
+                return Ok(Async::NotReady)
+            }
+            let len = NetworkEndian::read_uint(&chunk[idx..], 8) as usize;
+            idx += 8;
+            len
+        } else {
+            len as usize
         };
 
-        // get body
-        data.split_to(idx);
-
-        // Disallow bad opcode
-        if let OpCode::Bad = opcode {
-            return Err(WsError::InvalidOpcode(first & 0x0F))
+        // check for max allowed size
+        if length > max_size {
+            return Err(ProtocolError::Overflow)
         }
 
+        let mask = if server {
+            if chunk_len < idx + 4 {
+                return Ok(Async::NotReady)
+            }
+
+            let mask: &[u8] = &chunk[idx..idx+4];
+            let mask_u32: u32 = unsafe {ptr::read_unaligned(mask.as_ptr() as *const u32)};
+            idx += 4;
+            Some(mask_u32)
+        } else {
+            None
+        };
+
+        Ok(Async::Ready((idx, finished, opcode, length, mask)))
+    }
+
+    /// Parse the input stream into a frame.
+    pub fn parse<S>(pl: &mut PayloadHelper<S>, server: bool, max_size: usize)
+                    -> Poll<Option<Frame>, ProtocolError>
+        where S: Stream<Item=Bytes, Error=PayloadError>
+    {
+        // try to parse ws frame md from one chunk
+        let result = match pl.get_chunk()? {
+            Async::NotReady => return Ok(Async::NotReady),
+            Async::Ready(None) => return Ok(Async::Ready(None)),
+            Async::Ready(Some(chunk)) => Frame::read_chunk_md(chunk, server, max_size)?,
+        };
+
+        let (idx, finished, opcode, length, mask) = match result {
+            // we may need to join several chunks
+            Async::NotReady => match Frame::read_copy_md(pl, server, max_size)? {
+                Async::Ready(Some(item)) => item,
+                Async::NotReady => return Ok(Async::NotReady),
+                Async::Ready(None) => return Ok(Async::Ready(None)),
+            },
+            Async::Ready(item) => item,
+        };
+
+        match pl.can_read(idx + length)? {
+            Async::Ready(Some(true)) => (),
+            Async::Ready(None) => return Ok(Async::Ready(None)),
+            Async::Ready(Some(false)) | Async::NotReady => return Ok(Async::NotReady),
+        }
+
+        // remove prefix
+        pl.drop_payload(idx);
+
+        // no need for body
+        if length == 0 {
+            return Ok(Async::Ready(Some(Frame {
+                finished, opcode, payload: Binary::from("") })));
+        }
+
+        let data = match pl.read_exact(length)? {
+            Async::Ready(Some(buf)) => buf,
+            Async::Ready(None) => return Ok(Async::Ready(None)),
+            Async::NotReady => panic!(),
+        };
+
         // control frames must have length <= 125
         match opcode {
             OpCode::Ping | OpCode::Pong if length > 125 => {
-                return Err(WsError::InvalidLength(length))
+                return Err(ProtocolError::InvalidLength(length))
             }
             OpCode::Close if length > 125 => {
                 debug!("Received close frame with payload length exceeding 125. Morphing to protocol close frame.");
@@ -149,12 +251,14 @@ impl Frame {
         }
 
         // unmask
-        if let Some(ref mask) = mask {
-            apply_mask(&mut data, mask);
+        if let Some(mask) = mask {
+            #[allow(mutable_transmutes)]
+            let p: &mut [u8] = unsafe{let ptr: &[u8] = &data; mem::transmute(ptr)};
+            apply_mask(p, mask);
         }
 
         Ok(Async::Ready(Some(Frame {
-            finished, rsv1, rsv2, rsv3, opcode, payload: data.into() })))
+            finished, opcode, payload: data.into() })))
     }
 
     /// Generate binary representation
@@ -199,13 +303,13 @@ impl Frame {
         };
 
         if genmask {
-            let mask: [u8; 4] = rand::random();
+            let mask = rand::random::<u32>();
             unsafe {
                 {
                     let buf_mut = buf.bytes_mut();
-                    buf_mut[..4].copy_from_slice(&mask);
+                    *(buf_mut as *mut _ as *mut u32) = mask;
                     buf_mut[4..payload_len+4].copy_from_slice(payload.as_ref());
-                    apply_mask(&mut buf_mut[4..], &mask);
+                    apply_mask(&mut buf_mut[4..], mask);
                 }
                 buf.advance_mut(payload_len + 4);
             }
@@ -221,9 +325,6 @@ impl Default for Frame {
     fn default() -> Frame {
         Frame {
             finished: true,
-            rsv1: false,
-            rsv2: false,
-            rsv3: false,
             opcode: OpCode::Close,
             payload: Binary::from(&b""[..]),
         }
@@ -236,15 +337,11 @@ impl fmt::Display for Frame {
             "
 <FRAME>
     final: {}
-    reserved: {} {} {}
     opcode: {}
     payload length: {}
     payload: 0x{}
 </FRAME>",
                self.finished,
-               self.rsv1,
-               self.rsv2,
-               self.rsv3,
                self.opcode,
                self.payload.len(),
                self.payload.as_ref().iter().map(
@@ -257,14 +354,14 @@ mod tests {
     use super::*;
     use futures::stream::once;
 
-    fn is_none(frm: Poll<Option<Frame>, WsError>) -> bool {
+    fn is_none(frm: Poll<Option<Frame>, ProtocolError>) -> bool {
         match frm {
             Ok(Async::Ready(None)) => true,
             _ => false,
         }
     }
     
-    fn extract(frm: Poll<Option<Frame>, WsError>) -> Frame {
+    fn extract(frm: Poll<Option<Frame>, ProtocolError>) -> Frame {
         match frm {
             Ok(Async::Ready(Some(frame))) => frame,
             _ => panic!("error"),
@@ -282,7 +379,6 @@ mod tests {
         let mut buf = PayloadHelper::new(once(Ok(buf.freeze())));
 
         let frame = extract(Frame::parse(&mut buf, false, 1024));
-        println!("FRAME: {}", frame);
         assert!(!frame.finished);
         assert_eq!(frame.opcode, OpCode::Text);
         assert_eq!(frame.payload.as_ref(), &b"1"[..]);
@@ -370,7 +466,7 @@ mod tests {
 
         assert!(Frame::parse(&mut buf, true, 1).is_err());
 
-        if let Err(WsError::Overflow) = Frame::parse(&mut buf, false, 0) {
+        if let Err(ProtocolError::Overflow) = Frame::parse(&mut buf, false, 0) {
         } else {
             panic!("error");
         }

src/ws/mask.rs

@@ -5,7 +5,7 @@ use std::ptr::copy_nonoverlapping;
 
 /// Mask/unmask a frame.
 #[inline]
-pub fn apply_mask(buf: &mut [u8], mask: &[u8; 4]) {
+pub fn apply_mask(buf: &mut [u8], mask: u32) {
     apply_mask_fast32(buf, mask)
 }
 
@@ -18,34 +18,41 @@ fn apply_mask_fallback(buf: &mut [u8], mask: &[u8; 4]) {
     }
 }
 
-/// Faster version of `apply_mask()` which operates on 4-byte blocks.
+/// Faster version of `apply_mask()` which operates on 8-byte blocks.
 #[inline]
-#[allow(dead_code)]
-fn apply_mask_fast32(buf: &mut [u8], mask: &[u8; 4]) {
-    // TODO replace this with read_unaligned() as it stabilizes.
-    let mask_u32 = unsafe {
-        let mut m: u32 = uninitialized();
-        #[allow(trivial_casts)]
-        copy_nonoverlapping(mask.as_ptr(), &mut m as *mut _ as *mut u8, 4);
-        m
-    };
-
+#[cfg_attr(feature="cargo-clippy", allow(cast_lossless))]
+fn apply_mask_fast32(buf: &mut [u8], mask_u32: u32) {
     let mut ptr = buf.as_mut_ptr();
     let mut len = buf.len();
 
     // Possible first unaligned block.
-    let head = min(len, (4 - (ptr as usize & 3)) & 3);
+    let head = min(len, (8 - (ptr as usize & 0x7)) & 0x3);
     let mask_u32 = if head > 0 {
-        unsafe {
-            xor_mem(ptr, mask_u32, head);
-            ptr = ptr.offset(head as isize);
-        }
-        len -= head;
-        if cfg!(target_endian = "big") {
-            mask_u32.rotate_left(8 * head as u32)
+        let n = if head > 4 { head - 4 } else { head };
+
+        let mask_u32 = if n > 0 {
+            unsafe {
+                xor_mem(ptr, mask_u32, n);
+                ptr = ptr.offset(head as isize);
+            }
+            len -= n;
+            if cfg!(target_endian = "big") {
+                mask_u32.rotate_left(8 * n as u32)
+            } else {
+                mask_u32.rotate_right(8 * n as u32)
+            }
         } else {
-            mask_u32.rotate_right(8 * head as u32)
+            mask_u32
+        };
+
+        if head > 4 {
+            unsafe {
+                *(ptr as *mut u32) ^= mask_u32;
+                ptr = ptr.offset(4);
+                len -= 4;
+            }
         }
+        mask_u32
     } else {
         mask_u32
     };
@@ -55,7 +62,20 @@ fn apply_mask_fast32(buf: &mut [u8], mask: &[u8; 4]) {
     }
 
     // Properly aligned middle of the data.
-    while len > 4 {
+    if len >= 8 {
+        let mut mask_u64 = mask_u32 as u64;
+        mask_u64 = mask_u64 << 32 | mask_u32 as u64;
+
+        while len >= 8 {
+            unsafe {
+                *(ptr as *mut u64) ^= mask_u64;
+                ptr = ptr.offset(8);
+                len -= 8;
+            }
+        }
+    }
+
+    while len >= 4 {
         unsafe {
             *(ptr as *mut u32) ^= mask_u32;
             ptr = ptr.offset(4);
@@ -83,6 +103,7 @@ unsafe fn xor_mem(ptr: *mut u8, mask: u32, len: usize) {
 
 #[cfg(test)]
 mod tests {
+    use std::ptr;
  use super::{apply_mask_fallback, apply_mask_fast32};
 
     #[test]
@@ -90,6 +111,8 @@ mod tests {
         let mask = [
             0x6d, 0xb6, 0xb2, 0x80,
         ];
+        let mask_u32: u32 = unsafe {ptr::read_unaligned(mask.as_ptr() as *const u32)};
+
         let unmasked = vec![
             0xf3, 0x00, 0x01, 0x02,  0x03, 0x80, 0x81, 0x82,
             0xff, 0xfe, 0x00, 0x17,  0x74, 0xf9, 0x12, 0x03,
@@ -101,7 +124,7 @@ mod tests {
             apply_mask_fallback(&mut masked, &mask);
 
             let mut masked_fast = unmasked.clone();
-            apply_mask_fast32(&mut masked_fast, &mask);
+            apply_mask_fast32(&mut masked_fast, mask_u32);
 
             assert_eq!(masked, masked_fast);
         }
@@ -112,7 +135,7 @@ mod tests {
             apply_mask_fallback(&mut masked[1..], &mask);
 
             let mut masked_fast = unmasked.clone();
-            apply_mask_fast32(&mut masked_fast[1..], &mask);
+            apply_mask_fast32(&mut masked_fast[1..], mask_u32);
 
             assert_eq!(masked, masked_fast);
         }

src/ws/mod.rs

@@ -63,17 +63,28 @@ mod context;
 mod mask;
 mod client;
 
-use self::frame::Frame;
-use self::proto::{hash_key, OpCode};
+pub use self::frame::Frame;
+pub use self::proto::OpCode;
 pub use self::proto::CloseCode;
 pub use self::context::WebsocketContext;
+pub use self::client::{Client, ClientError,
+                       ClientReader, ClientWriter, ClientHandshake};
+
+#[allow(deprecated)]
 pub use self::client::{WsClient, WsClientError,
                        WsClientReader, WsClientWriter, WsClientHandshake};
 
+/// Backward compatibility
+#[doc(hidden)]
+#[deprecated(since="0.4.2", note="please use `ws::ProtocolError` instead")]
+pub type WsError = ProtocolError;
+#[doc(hidden)]
+#[deprecated(since="0.4.2", note="please use `ws::HandshakeError` instead")]
+pub type WsHandshakeError = HandshakeError;
 
 /// Websocket errors
 #[derive(Fail, Debug)]
-pub enum WsError {
+pub enum ProtocolError {
     /// Received an unmasked frame from client
     #[fail(display="Received an unmasked frame from client")]
     UnmaskedFrame,
@@ -103,17 +114,17 @@ pub enum WsError {
     Payload(#[cause] PayloadError),
 }
 
-impl ResponseError for WsError {}
+impl ResponseError for ProtocolError {}
 
-impl From<PayloadError> for WsError {
-    fn from(err: PayloadError) -> WsError {
-        WsError::Payload(err)
+impl From<PayloadError> for ProtocolError {
+    fn from(err: PayloadError) -> ProtocolError {
+        ProtocolError::Payload(err)
     }
 }
 
 /// Websocket handshake errors
 #[derive(Fail, PartialEq, Debug)]
-pub enum WsHandshakeError {
+pub enum HandshakeError {
     /// Only get method is allowed
     #[fail(display="Method not allowed")]
     GetMethodRequired,
@@ -134,26 +145,26 @@ pub enum WsHandshakeError {
     BadWebsocketKey,
 }
 
-impl ResponseError for WsHandshakeError {
+impl ResponseError for HandshakeError {
 
     fn error_response(&self) -> HttpResponse {
         match *self {
-            WsHandshakeError::GetMethodRequired => {
+            HandshakeError::GetMethodRequired => {
                 HttpMethodNotAllowed
                     .build()
                     .header(header::ALLOW, "GET")
                     .finish()
                     .unwrap()
             }
-            WsHandshakeError::NoWebsocketUpgrade =>
+            HandshakeError::NoWebsocketUpgrade =>
                 HttpBadRequest.with_reason("No WebSocket UPGRADE header found"),
-            WsHandshakeError::NoConnectionUpgrade =>
+            HandshakeError::NoConnectionUpgrade =>
                 HttpBadRequest.with_reason("No CONNECTION upgrade"),
-            WsHandshakeError::NoVersionHeader =>
+            HandshakeError::NoVersionHeader =>
                 HttpBadRequest.with_reason("Websocket version header is required"),
-            WsHandshakeError::UnsupportedVersion =>
+            HandshakeError::UnsupportedVersion =>
                 HttpBadRequest.with_reason("Unsupported version"),
-            WsHandshakeError::BadWebsocketKey =>
+            HandshakeError::BadWebsocketKey =>
                 HttpBadRequest.with_reason("Handshake error"),
         }
     }
@@ -171,7 +182,7 @@ pub enum Message {
 
 /// Do websocket handshake and start actor
 pub fn start<A, S>(req: HttpRequest<S>, actor: A) -> Result<HttpResponse, Error>
-    where A: Actor<Context=WebsocketContext<A, S>> + StreamHandler<Message, WsError>,
+    where A: Actor<Context=WebsocketContext<A, S>> + StreamHandler<Message, ProtocolError>,
           S: 'static
 {
     let mut resp = handshake(&req)?;
@@ -191,10 +202,10 @@ pub fn start<A, S>(req: HttpRequest<S>, actor: A) -> Result<HttpResponse, Error>
 // /// `protocols` is a sequence of known protocols. On successful handshake,
 // /// the returned response headers contain the first protocol in this list
 // /// which the server also knows.
-pub fn handshake<S>(req: &HttpRequest<S>) -> Result<HttpResponseBuilder, WsHandshakeError> {
+pub fn handshake<S>(req: &HttpRequest<S>) -> Result<HttpResponseBuilder, HandshakeError> {
     // WebSocket accepts only GET
     if *req.method() != Method::GET {
-        return Err(WsHandshakeError::GetMethodRequired)
+        return Err(HandshakeError::GetMethodRequired)
     }
 
     // Check for "UPGRADE" to websocket header
@@ -208,17 +219,17 @@ pub fn handshake<S>(req: &HttpRequest<S>) -> Result<HttpResponseBuilder, WsHands
         false
     };
     if !has_hdr {
-        return Err(WsHandshakeError::NoWebsocketUpgrade)
+        return Err(HandshakeError::NoWebsocketUpgrade)
     }
 
     // Upgrade connection
     if !req.upgrade() {
-        return Err(WsHandshakeError::NoConnectionUpgrade)
+        return Err(HandshakeError::NoConnectionUpgrade)
     }
 
     // check supported version
     if !req.headers().contains_key(header::SEC_WEBSOCKET_VERSION) {
-        return Err(WsHandshakeError::NoVersionHeader)
+        return Err(HandshakeError::NoVersionHeader)
     }
     let supported_ver = {
         if let Some(hdr) = req.headers().get(header::SEC_WEBSOCKET_VERSION) {
@@ -228,16 +239,16 @@ pub fn handshake<S>(req: &HttpRequest<S>) -> Result<HttpResponseBuilder, WsHands
         }
     };
     if !supported_ver {
-        return Err(WsHandshakeError::UnsupportedVersion)
+        return Err(HandshakeError::UnsupportedVersion)
     }
 
     // check client handshake for validity
     if !req.headers().contains_key(header::SEC_WEBSOCKET_KEY) {
-        return Err(WsHandshakeError::BadWebsocketKey)
+        return Err(HandshakeError::BadWebsocketKey)
     }
     let key = {
         let key = req.headers().get(header::SEC_WEBSOCKET_KEY).unwrap();
-        hash_key(key.as_ref())
+        proto::hash_key(key.as_ref())
     };
 
     Ok(HttpResponse::build(StatusCode::SWITCHING_PROTOCOLS)
@@ -275,7 +286,7 @@ impl<S> WsStream<S> where S: Stream<Item=Bytes, Error=PayloadError> {
 
 impl<S> Stream for WsStream<S> where S: Stream<Item=Bytes, Error=PayloadError> {
     type Item = Message;
-    type Error = WsError;
+    type Error = ProtocolError;
 
     fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
         if self.closed {
@@ -289,14 +300,14 @@ impl<S> Stream for WsStream<S> where S: Stream<Item=Bytes, Error=PayloadError> {
                 // continuation is not supported
                 if !finished {
                     self.closed = true;
-                    return Err(WsError::NoContinuation)
+                    return Err(ProtocolError::NoContinuation)
                 }
 
                 match opcode {
-                    OpCode::Continue => unimplemented!(),
+                    OpCode::Continue => Err(ProtocolError::NoContinuation),
                     OpCode::Bad => {
                         self.closed = true;
-                        Err(WsError::BadOpCode)
+                        Err(ProtocolError::BadOpCode)
                     }
                     OpCode::Close => {
                         self.closed = true;
@@ -320,7 +331,7 @@ impl<S> Stream for WsStream<S> where S: Stream<Item=Bytes, Error=PayloadError> {
                                 Ok(Async::Ready(Some(Message::Text(s)))),
                             Err(_) => {
                                 self.closed = true;
-                                Err(WsError::BadEncoding)
+                                Err(ProtocolError::BadEncoding)
                             }
                         }
                     }
@@ -346,25 +357,25 @@ mod tests {
     fn test_handshake() {
         let req = HttpRequest::new(Method::POST, Uri::from_str("/").unwrap(),
                                    Version::HTTP_11, HeaderMap::new(), None);
-        assert_eq!(WsHandshakeError::GetMethodRequired, handshake(&req).err().unwrap());
+        assert_eq!(HandshakeError::GetMethodRequired, handshake(&req).err().unwrap());
 
         let req = HttpRequest::new(Method::GET, Uri::from_str("/").unwrap(),
                                    Version::HTTP_11, HeaderMap::new(), None);
-        assert_eq!(WsHandshakeError::NoWebsocketUpgrade, handshake(&req).err().unwrap());
+        assert_eq!(HandshakeError::NoWebsocketUpgrade, handshake(&req).err().unwrap());
 
         let mut headers = HeaderMap::new();
         headers.insert(header::UPGRADE,
                        header::HeaderValue::from_static("test"));
         let req = HttpRequest::new(Method::GET, Uri::from_str("/").unwrap(),
                                    Version::HTTP_11, headers, None);
-        assert_eq!(WsHandshakeError::NoWebsocketUpgrade, handshake(&req).err().unwrap());
+        assert_eq!(HandshakeError::NoWebsocketUpgrade, handshake(&req).err().unwrap());
 
         let mut headers = HeaderMap::new();
         headers.insert(header::UPGRADE,
                        header::HeaderValue::from_static("websocket"));
         let req = HttpRequest::new(Method::GET, Uri::from_str("/").unwrap(),
                                    Version::HTTP_11, headers, None);
-        assert_eq!(WsHandshakeError::NoConnectionUpgrade, handshake(&req).err().unwrap());
+        assert_eq!(HandshakeError::NoConnectionUpgrade, handshake(&req).err().unwrap());
 
         let mut headers = HeaderMap::new();
         headers.insert(header::UPGRADE,
@@ -373,7 +384,7 @@ mod tests {
                        header::HeaderValue::from_static("upgrade"));
         let req = HttpRequest::new(Method::GET, Uri::from_str("/").unwrap(),
                                    Version::HTTP_11, headers, None);
-        assert_eq!(WsHandshakeError::NoVersionHeader, handshake(&req).err().unwrap());
+        assert_eq!(HandshakeError::NoVersionHeader, handshake(&req).err().unwrap());
 
         let mut headers = HeaderMap::new();
         headers.insert(header::UPGRADE,
@@ -384,7 +395,7 @@ mod tests {
                        header::HeaderValue::from_static("5"));
         let req = HttpRequest::new(Method::GET, Uri::from_str("/").unwrap(),
                                    Version::HTTP_11, headers, None);
-        assert_eq!(WsHandshakeError::UnsupportedVersion, handshake(&req).err().unwrap());
+        assert_eq!(HandshakeError::UnsupportedVersion, handshake(&req).err().unwrap());
 
         let mut headers = HeaderMap::new();
         headers.insert(header::UPGRADE,
@@ -395,7 +406,7 @@ mod tests {
                        header::HeaderValue::from_static("13"));
         let req = HttpRequest::new(Method::GET, Uri::from_str("/").unwrap(),
                                    Version::HTTP_11, headers, None);
-        assert_eq!(WsHandshakeError::BadWebsocketKey, handshake(&req).err().unwrap());
+        assert_eq!(HandshakeError::BadWebsocketKey, handshake(&req).err().unwrap());
 
         let mut headers = HeaderMap::new();
         headers.insert(header::UPGRADE,
@@ -414,17 +425,17 @@ mod tests {
 
     #[test]
     fn test_wserror_http_response() {
-        let resp: HttpResponse = WsHandshakeError::GetMethodRequired.error_response();
+        let resp: HttpResponse = HandshakeError::GetMethodRequired.error_response();
         assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
-        let resp: HttpResponse = WsHandshakeError::NoWebsocketUpgrade.error_response();
+        let resp: HttpResponse = HandshakeError::NoWebsocketUpgrade.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::NoConnectionUpgrade.error_response();
+        let resp: HttpResponse = HandshakeError::NoConnectionUpgrade.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::NoVersionHeader.error_response();
+        let resp: HttpResponse = HandshakeError::NoVersionHeader.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::UnsupportedVersion.error_response();
+        let resp: HttpResponse = HandshakeError::UnsupportedVersion.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-        let resp: HttpResponse = WsHandshakeError::BadWebsocketKey.error_response();
+        let resp: HttpResponse = HandshakeError::BadWebsocketKey.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
 }

src/ws/proto.rs

@@ -6,7 +6,7 @@ use base64;
 use self::OpCode::*;
 /// Operation codes as part of rfc6455.
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
-pub(crate) enum OpCode {
+pub enum OpCode {
     /// Indicates a continuation frame of a fragmented message.
     Continue,
     /// Indicates a text data frame.

tests/test_client.rs

@@ -3,6 +3,7 @@ extern crate actix_web;
 extern crate bytes;
 extern crate futures;
 extern crate flate2;
+extern crate rand;
 
 use std::io::Read;
 
@@ -10,6 +11,7 @@ use bytes::Bytes;
 use futures::Future;
 use futures::stream::once;
 use flate2::read::GzDecoder;
+use rand::Rng;
 
 use actix_web::*;
 
@@ -117,7 +119,9 @@ fn test_client_gzip_encoding() {
 }
 
 #[test]
-fn test_client_brotli_encoding() {
+fn test_client_gzip_encoding_large() {
+    let data = STR.repeat(10);
+
     let mut srv = test::TestServer::new(|app| app.handler(|req: HttpRequest| {
         req.body()
             .and_then(|bytes: Bytes| {
@@ -128,6 +132,59 @@ fn test_client_brotli_encoding() {
             }).responder()}
     ));
 
+    // client request
+    let request = srv.post()
+        .content_encoding(headers::ContentEncoding::Gzip)
+        .body(data.clone()).unwrap();
+    let response = srv.execute(request.send()).unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = srv.execute(response.body()).unwrap();
+    assert_eq!(bytes, Bytes::from(data));
+}
+
+#[test]
+fn test_client_gzip_encoding_large_random() {
+    let data = rand::thread_rng()
+        .gen_ascii_chars()
+        .take(100_000)
+        .collect::<String>();
+
+    let mut srv = test::TestServer::new(|app| app.handler(|req: HttpRequest| {
+        req.body()
+            .and_then(|bytes: Bytes| {
+                Ok(httpcodes::HTTPOk
+                   .build()
+                   .content_encoding(headers::ContentEncoding::Deflate)
+                   .body(bytes))
+            }).responder()}
+    ));
+
+    // client request
+    let request = srv.post()
+        .content_encoding(headers::ContentEncoding::Gzip)
+        .body(data.clone()).unwrap();
+    let response = srv.execute(request.send()).unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = srv.execute(response.body()).unwrap();
+    assert_eq!(bytes, Bytes::from(data));
+}
+
+#[test]
+fn test_client_brotli_encoding() {
+    let mut srv = test::TestServer::new(|app| app.handler(|req: HttpRequest| {
+        req.body()
+            .and_then(|bytes: Bytes| {
+                Ok(httpcodes::HTTPOk
+                   .build()
+                   .content_encoding(headers::ContentEncoding::Gzip)
+                   .body(bytes))
+            }).responder()}
+    ));
+
     // client request
     let request = srv.client(Method::POST, "/")
         .content_encoding(headers::ContentEncoding::Br)
@@ -140,6 +197,36 @@ fn test_client_brotli_encoding() {
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }
 
+#[test]
+fn test_client_brotli_encoding_large_random() {
+    let data = rand::thread_rng()
+        .gen_ascii_chars()
+        .take(70_000)
+        .collect::<String>();
+
+    let mut srv = test::TestServer::new(|app| app.handler(|req: HttpRequest| {
+        req.body()
+            .and_then(move |bytes: Bytes| {
+                Ok(httpcodes::HTTPOk
+                   .build()
+                   .content_encoding(headers::ContentEncoding::Gzip)
+                   .body(bytes))
+            }).responder()}
+        ));
+
+    // client request
+    let request = srv.client(Method::POST, "/")
+        .content_encoding(headers::ContentEncoding::Br)
+        .body(data.clone()).unwrap();
+    let response = srv.execute(request.send()).unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = srv.execute(response.body()).unwrap();
+    assert_eq!(bytes.len(), data.len());
+    assert_eq!(bytes, Bytes::from(data));
+}
+
 #[test]
 fn test_client_deflate_encoding() {
     let mut srv = test::TestServer::new(|app| app.handler(|req: HttpRequest| {
@@ -164,6 +251,35 @@ fn test_client_deflate_encoding() {
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }
 
+#[test]
+fn test_client_deflate_encoding_large_random() {
+    let data = rand::thread_rng()
+        .gen_ascii_chars()
+        .take(70_000)
+        .collect::<String>();
+
+    let mut srv = test::TestServer::new(|app| app.handler(|req: HttpRequest| {
+        req.body()
+            .and_then(|bytes: Bytes| {
+                Ok(httpcodes::HTTPOk
+                   .build()
+                   .content_encoding(headers::ContentEncoding::Br)
+                   .body(bytes))
+            }).responder()}
+    ));
+
+    // client request
+    let request = srv.post()
+        .content_encoding(headers::ContentEncoding::Deflate)
+        .body(data.clone()).unwrap();
+    let response = srv.execute(request.send()).unwrap();
+    assert!(response.status().is_success());
+
+    // read response
+    let bytes = srv.execute(response.body()).unwrap();
+    assert_eq!(bytes, Bytes::from(data));
+}
+
 #[test]
 fn test_client_streaming_explicit() {
     let mut srv = test::TestServer::new(
@@ -205,3 +321,62 @@ fn test_body_streaming_implicit() {
     let bytes = srv.execute(response.body()).unwrap();
     assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }
+
+#[test]
+fn test_client_cookie_handling() {
+    use actix_web::header::Cookie;
+    fn err() -> Error {
+        use std::io::{ErrorKind, Error as IoError};
+        // stub some generic error
+        Error::from(IoError::from(ErrorKind::NotFound))
+    }
+    let cookie1 = Cookie::build("cookie1", "value1").finish();
+    let cookie2 = Cookie::build("cookie2", "value2")
+        .domain("www.example.org")
+        .path("/")
+        .secure(true)
+        .http_only(true)
+        .finish();
+    // Q: are all these clones really necessary? A: Yes, possibly
+    let cookie1b = cookie1.clone();
+    let cookie2b = cookie2.clone();
+    let mut srv = test::TestServer::new(
+        move |app| {
+            let cookie1 = cookie1b.clone();
+            let cookie2 = cookie2b.clone();
+            app.handler(move |req: HttpRequest| {
+                // Check cookies were sent correctly
+                req.cookie("cookie1").ok_or_else(err)
+                    .and_then(|c1| if c1.value() == "value1" {
+                        Ok(())
+                    } else {
+                        Err(err())
+                    })
+                    .and_then(|()| req.cookie("cookie2").ok_or_else(err))
+                    .and_then(|c2| if c2.value() == "value2" {
+                        Ok(())
+                    } else {
+                        Err(err())
+                    })
+                    // Send some cookies back
+                    .map(|_|
+                         httpcodes::HTTPOk.build()
+                         .cookie(cookie1.clone())
+                         .cookie(cookie2.clone())
+                         .finish()
+                    )
+            })
+        });
+
+    let request = srv.get()
+        .cookie(cookie1.clone())
+        .cookie(cookie2.clone())
+        .finish()
+        .unwrap();
+    let response = srv.execute(request.send()).unwrap();
+    assert!(response.status().is_success());
+    let c1 = response.cookie("cookie1").expect("Missing cookie1");
+    assert_eq!(c1, &cookie1);
+    let c2 = response.cookie("cookie2").expect("Missing cookie2");
+    assert_eq!(c2, &cookie2);
+}