prepare actix-web release

Add on-connect callback #946
update actix-http changes
2025-07-06 02:45:21 +02:00 · 2019-06-28 14:41:56 +06:00 · 2019-06-28 14:34:26 +06:00 · 2019-06-28 12:34:43 +06:00 · 2019-06-28 11:42:20 +06:00 · 2019-06-28 10:54:23 +06:00
200 changed files with 19011 additions and 6933 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -10,9 +10,9 @@ matrix:
  include:
    - rust: stable
    - rust: beta
-    - rust: nightly-2019-03-02
+    - rust: nightly-2019-04-02
  allow_failures:
-    - rust: nightly-2019-03-02
+    - rust: nightly-2019-04-02

 env:
  global:
@ -25,8 +25,8 @@ before_install:
  - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev

 before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-03-02" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install cargo-tarpaulin
+  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-04-02" ]]; then
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
  fi

 # Add clippy
@ -34,21 +34,22 @@ before_script:
  - export PATH=$PATH:~/.cargo/bin

 script:
-  - cargo clean
+  - cargo update
+  - cargo check --all --no-default-features
  - cargo test --all-features --all -- --nocapture

 # Upload docs
 after_success:
  - |
    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "stable" ]]; then
-      cargo doc --all-features --no-deps &&
+      cargo doc --no-deps --all-features &&
      echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
      git clone https://github.com/davisp/ghp-import.git &&
      ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
      echo "Uploaded documentation"
    fi
  - |
-    if [[ "$TRAVIS_RUST_VERSION" ==  "nightly-2019-03-02" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" ==  "nightly-2019-04-02" ]]; then
        taskset -c 0 cargo tarpaulin --out Xml --all --all-features
        bash <(curl -s https://codecov.io/bash)
        echo "Uploaded code coverage"
--- a/CHANGES.md
+++ b/CHANGES.md
@ -1,7 +1,257 @@
 # Changes

-## [1.0.0-alpha.1] - 2019-03-x
+## [1.0.3] - 2019-06-28
+
+### Added
+
+* Support asynchronous data factories #850

 ### Changed

+*  Use `encoding_rs` crate instead of unmaintained `encoding` crate
+
+
+## [1.0.2] - 2019-06-17
+
+### Changed
+
+* Move cors middleware to `actix-cors` crate.
+
+* Move identity middleware to `actix-identity` crate.
+
+
+## [1.0.1] - 2019-06-17
+
+### Added
+
+* Add support for PathConfig #903
+
+* Add `middleware::identity::RequestIdentity` trait to `get_identity` from `HttpMessage`.
+
+### Changed
+
+* Move cors middleware to `actix-cors` crate.
+
+* Move identity middleware to `actix-identity` crate.
+
+* Disable default feature `secure-cookies`.
+
+* Allow to test an app that uses async actors #897
+
+* Re-apply patch from #637 #894
+
+### Fixed
+
+* HttpRequest::url_for is broken with nested scopes #915
+
+
+## [1.0.0] - 2019-06-05
+
+### Added
+
+* Add `Scope::configure()` method.
+
+* Add `ServiceRequest::set_payload()` method.
+
+* Add `test::TestRequest::set_json()` convenience method to automatically
+  serialize data and set header in test requests.
+
+* Add macros for head, options, trace, connect and patch http methods
+
+### Changed
+
+* Drop an unnecessary `Option<_>` indirection around `ServerBuilder` from `HttpServer`. #863
+
+### Fixed
+
+* Fix Logger request time format, and use rfc3339. #867
+
+* Clear http requests pool on app service drop #860
+
+
+## [1.0.0-rc] - 2019-05-18
+
+### Add
+
+* Add `Query<T>::from_query()` to extract parameters from a query string. #846
+* `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
+
+### Changed
+
+* `JsonConfig` is now `Send + Sync`, this implies that `error_handler` must be `Send + Sync` too.
+
+### Fixed
+
+* Codegen with parameters in the path only resolves the first registered endpoint #841
+
+
+## [1.0.0-beta.4] - 2019-05-12
+
+### Add
+
+* Allow to set/override app data on scope level
+
+### Changed
+
+* `App::configure` take an `FnOnce` instead of `Fn`
+* Upgrade actix-net crates
+
+
+## [1.0.0-beta.3] - 2019-05-04
+
+### Added
+
+* Add helper function for executing futures `test::block_fn()`
+
+### Changed
+
+* Extractor configuration could be registered with `App::data()`
+  or with `Resource::data()` #775
+
+* Route data is unified with app data, `Route::data()` moved to resource
+  level to `Resource::data()`
+
+* CORS handling without headers #702
+
+* Allow to construct `Data` instances to avoid double `Arc` for `Send + Sync` types.
+
+### Fixed
+
+* Fix `NormalizePath` middleware impl #806
+
+### Deleted
+
+* `App::data_factory()` is deleted.
+
+
+## [1.0.0-beta.2] - 2019-04-24
+
+### Added
+
+* Add raw services support via `web::service()`
+
+* Add helper functions for reading response body `test::read_body()`
+
+* Add support for `remainder match` (i.e "/path/{tail}*")
+
+* Extend `Responder` trait, allow to override status code and headers.
+
+* Store visit and login timestamp in the identity cookie #502
+
+### Changed
+
+* `.to_async()` handler can return `Responder` type #792
+
+### Fixed
+
+* Fix async web::Data factory handling
+
+
+## [1.0.0-beta.1] - 2019-04-20
+
+### Added
+
+* Add helper functions for reading test response body,
+ `test::read_response()` and test::read_response_json()`
+
+* Add `.peer_addr()` #744
+
+* Add `NormalizePath` middleware
+
+### Changed
+
+* Rename `RouterConfig` to `ServiceConfig`
+
+* Rename `test::call_success` to `test::call_service`
+
+* Removed `ServiceRequest::from_parts()` as it is unsafe to create from parts.
+
+* `CookieIdentityPolicy::max_age()` accepts value in seconds
+
+### Fixed
+
+* Fixed `TestRequest::app_data()`
+
+
+## [1.0.0-alpha.6] - 2019-04-14
+
+### Changed
+
+* Allow to use any service as default service.
+
+* Remove generic type for request payload, always use default.
+
+* Removed `Decompress` middleware. Bytes, String, Json, Form extractors
+  automatically decompress payload.
+
+* Make extractor config type explicit. Add `FromRequest::Config` associated type.
+
+
+## [1.0.0-alpha.5] - 2019-04-12
+
+### Added
+
+* Added async io `TestBuffer` for testing.
+
+### Deleted
+
+* Removed native-tls support
+
+
+## [1.0.0-alpha.4] - 2019-04-08
+
+### Added
+
+* `App::configure()` allow to offload app configuration to different methods
+
+* Added `URLPath` option for logger
+
+* Added `ServiceRequest::app_data()`, returns `Data<T>`
+
+* Added `ServiceFromRequest::app_data()`, returns `Data<T>`
+
+### Changed
+
+* `FromRequest` trait refactoring
+
+* Move multipart support to actix-multipart crate
+
+### Fixed
+
+* Fix body propagation in Response::from_error. #760
+
+
+## [1.0.0-alpha.3] - 2019-04-02
+
+### Changed
+
+* Renamed `TestRequest::to_service()` to `TestRequest::to_srv_request()`
+
+* Renamed `TestRequest::to_response()` to `TestRequest::to_srv_response()`
+
+* Removed `Deref` impls
+
+### Removed
+
+* Removed unused `actix_web::web::md()`
+
+
+## [1.0.0-alpha.2] - 2019-03-29
+
+### Added
+
+* rustls support
+
+### Changed
+
+* use forked cookie
+
+* multipart::Field renamed to MultipartField
+
+## [1.0.0-alpha.1] - 2019-03-28
+
+### Changed
+
+* Complete architecture re-design.
+
 * Return 405 response if no matching route found within resource #538
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,10 +1,10 @@
 [package]
 name = "actix-web"
-version = "1.0.0-alpha.1"
+version = "1.0.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
-keywords = ["http", "web", "framework", "async", "futures"]
+keywords = ["actix", "http", "web", "framework", "async"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
 documentation = "https://docs.rs/actix-web/"
@ -15,9 +15,11 @@ license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"

+[package.metadata.docs.rs]
+features = ["ssl", "brotli", "flate2-zlib", "secure-cookies", "client", "rust-tls"]
+
 [badges]
 travis-ci = { repository = "actix/actix-web", branch = "master" }
-appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
 codecov = { repository = "actix/actix-web", branch = "master", service = "github" }

 [lib]
@ -29,23 +31,25 @@ members = [
  ".",
  "awc",
  "actix-http",
+  "actix-cors",
  "actix-files",
+  "actix-framed",
  "actix-session",
+  "actix-identity",
+  "actix-multipart",
  "actix-web-actors",
  "actix-web-codegen",
+  "test-server",
 ]

-[package.metadata.docs.rs]
-features = ["ssl", "tls", "rust-tls", "brotli", "flate2-zlib", "cookies", "client"]
-
 [features]
-default = ["brotli", "flate2-zlib", "cookies", "client"]
+default = ["brotli", "flate2-zlib", "client", "fail"]

 # http client
 client = ["awc"]

 # brotli encoding, requires c compiler
-brotli = ["actix-http/brotli2"]
+brotli = ["actix-http/brotli"]

 # miniz-sys backend for flate2 crate
 flate2-zlib = ["actix-http/flate2-zlib"]
@ -54,66 +58,72 @@ flate2-zlib = ["actix-http/flate2-zlib"]
 flate2-rust = ["actix-http/flate2-rust"]

 # sessions feature, session require "ring" crate and c compiler
-cookies = ["cookie", "actix-http/cookies"]
+secure-cookies = ["actix-http/secure-cookies"]

-# tls
-tls = ["native-tls", "actix-server/ssl"]
+fail = ["actix-http/fail"]

 # openssl
-ssl = ["openssl", "actix-server/ssl"]
+ssl = ["openssl", "actix-server/ssl", "awc/ssl"]

 # rustls
-# rust-tls = ["rustls", "actix-server/rustls"]
+rust-tls = ["rustls", "actix-server/rust-tls"]

 [dependencies]
-actix-codec = "0.1.1"
-actix-service = "0.3.4"
-actix-utils = "0.3.4"
-actix-router = "0.1.0"
-actix-rt = "0.2.2"
-actix-web-codegen = { path="actix-web-codegen" }
-actix-http = { path = "actix-http", features=["fail"] }
-actix-server = "0.4.1"
-actix-server-config = "0.1.0"
-actix-threadpool = "0.1.0"
-awc = { path = "awc", optional = true }
+actix-codec = "0.1.2"
+actix-service = "0.4.1"
+actix-utils = "0.4.2"
+actix-router = "0.1.5"
+actix-rt = "0.2.3"
+actix-web-codegen = "0.1.2"
+actix-http = "0.2.5"
+actix-server = "0.5.1"
+actix-server-config = "0.1.1"
+actix-threadpool = "0.1.1"
+awc = { version = "0.2.1", optional = true }

 bytes = "0.4"
-derive_more = "0.14"
-encoding = "0.2"
-futures = "0.1"
-hashbrown = "0.1.8"
-httparse = "1.3"
+derive_more = "0.15.0"
+encoding_rs = "0.8"
+futures = "0.1.25"
+hashbrown = "0.5.0"
 log = "0.4"
 mime = "0.3"
 net2 = "0.2.33"
-parking_lot = "0.7"
+parking_lot = "0.8"
 regex = "1.0"
 serde = { version = "1.0", features=["derive"] }
 serde_json = "1.0"
-serde_urlencoded = "^0.5.3"
-time = "0.1"
+serde_urlencoded = "0.5.3"
+time = "0.1.42"
 url = { version="1.7", features=["query_encoding"] }

-# cookies support
-cookie = { version="0.11", features=["secure", "percent-encode"], optional = true }
-
 # ssl support
-native-tls = { version="0.2", optional = true }
 openssl = { version="0.10", optional = true }
-# rustls = { version = "^0.15", optional = true }
+rustls = { version = "0.15", optional = true }

 [dev-dependencies]
-actix-http = { path = "actix-http", features=["ssl", "brotli", "flate2-zlib"] }
-actix-http-test = { path = "test-server", features=["ssl"] }
+actix = { version = "0.8.3" }
+actix-http = { version = "0.2.5", features=["ssl", "brotli", "flate2-zlib"] }
+actix-http-test = { version = "0.2.2", features=["ssl"] }
 rand = "0.6"
 env_logger = "0.6"
 serde_derive = "1.0"
 tokio-timer = "0.2.8"
-brotli2 = { version="^0.3.2" }
-flate2 = { version="^1.0.2" }
+brotli2 = "0.3.2"
+flate2 = "1.0.2"

 [profile.release]
 lto = true
 opt-level = 3
 codegen-units = 1
+
+[patch.crates-io]
+actix-web = { path = "." }
+actix-http = { path = "actix-http" }
+actix-http-test = { path = "test-server" }
+actix-web-codegen = { path = "actix-web-codegen" }
+actix-web-actors = { path = "actix-web-actors" }
+actix-session = { path = "actix-session" }
+actix-files = { path = "actix-files" }
+actix-multipart = { path = "actix-multipart" }
+awc = { path = "awc" }
--- a/MIGRATION.md
+++ b/MIGRATION.md
@ -1,3 +1,344 @@
+## 1.0.1
+
+* Cors middleware has been moved to `actix-cors` crate
+
+  instead of
+
+  ```rust
+  use actix_web::middleware::cors::Cors;
+  ```
+
+  use
+
+  ```rust
+  use actix_cors::Cors;
+  ```
+
+* Identity middleware has been moved to `actix-identity` crate
+
+  instead of
+
+  ```rust
+  use actix_web::middleware::identity::{Identity, CookieIdentityPolicy, IdentityService};
+  ```
+
+  use
+
+  ```rust
+  use actix_identity::{Identity, CookieIdentityPolicy, IdentityService};
+  ```
+
+
+## 1.0.0
+
+* Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
+
+  instead of
+    
+  ```rust
+    
+  #[derive(Default)]
+  struct ExtractorConfig {
+     config: String,
+  }
+    
+  impl FromRequest for YourExtractor {
+     type Config = ExtractorConfig;
+     type Result = Result<YourExtractor, Error>;
+  
+     fn from_request(req: &HttpRequest, cfg: &Self::Config) -> Self::Result {
+         println!("use the config: {:?}", cfg.config);
+         ...
+     }
+  }
+    
+  App::new().resource("/route_with_config", |r| {
+     r.post().with_config(handler_fn, |cfg| {
+         cfg.0.config = "test".to_string();
+     })
+  })
+    
+  ```
+    
+  use the HttpRequest to get the configuration like any other `Data` with `req.app_data::<C>()` and set it with the `data()` method on the `resource`
+    
+  ```rust
+  #[derive(Default)]
+  struct ExtractorConfig {
+     config: String,
+  }
+    
+  impl FromRequest for YourExtractor {
+     type Error = Error;
+     type Future = Result<Self, Self::Error>;
+     type Config = ExtractorConfig;
+    
+     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
+         let cfg = req.app_data::<ExtractorConfig>();
+         println!("config data?: {:?}", cfg.unwrap().role);
+         ...
+     }
+  }
+    
+  App::new().service(
+     resource("/route_with_config")
+         .data(ExtractorConfig {
+             config: "test".to_string(),
+         })
+         .route(post().to(handler_fn)),
+  )
+  ```
+  
+* Resource registration. 1.0 version uses generalized resource
+  registration via `.service()` method.
+
+  instead of
+
+  ```rust
+    App.new().resource("/welcome", |r| r.f(welcome))
+  ```
+
+  use App's or Scope's `.service()` method. `.service()` method accepts
+  object that implements `HttpServiceFactory` trait. By default
+  actix-web provides `Resource` and `Scope` services.
+
+  ```rust
+    App.new().service(
+        web::resource("/welcome")
+            .route(web::get().to(welcome))
+            .route(web::post().to(post_handler))
+  ```
+
+* Scope registration.
+
+  instead of
+
+  ```rust
+      let app = App::new().scope("/{project_id}", |scope| {
+            scope
+                .resource("/path1", |r| r.f(|_| HttpResponse::Ok()))
+                .resource("/path2", |r| r.f(|_| HttpResponse::Ok()))
+                .resource("/path3", |r| r.f(|_| HttpResponse::MethodNotAllowed()))
+      });
+  ```
+
+  use `.service()` for registration and `web::scope()` as scope object factory.
+
+  ```rust
+      let app = App::new().service(
+          web::scope("/{project_id}")
+              .service(web::resource("/path1").to(|| HttpResponse::Ok()))
+              .service(web::resource("/path2").to(|| HttpResponse::Ok()))
+              .service(web::resource("/path3").to(|| HttpResponse::MethodNotAllowed()))
+      );
+  ```
+
+* `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
+
+  instead of
+
+  ```rust
+    App.new().resource("/welcome", |r| r.with(welcome))
+  ```
+
+  use `.to()` or `.to_async()` methods
+
+  ```rust
+    App.new().service(web::resource("/welcome").to(welcome))
+  ```
+
+* Passing arguments to handler with extractors, multiple arguments are allowed
+
+  instead of
+
+  ```rust
+  fn welcome((body, req): (Bytes, HttpRequest)) -> ... {
+    ...
+  }
+  ```
+
+  use multiple arguments
+
+  ```rust
+  fn welcome(body: Bytes, req: HttpRequest) -> ... {
+    ...
+  }
+  ```
+
+* `.f()`, `.a()` and `.h()` handler registration methods have been removed.
+  Use `.to()` for handlers and `.to_async()` for async handlers. Handler function
+  must use extractors.
+
+  instead of
+
+  ```rust
+    App.new().resource("/welcome", |r| r.f(welcome))
+  ```
+
+  use App's `to()` or `to_async()` methods
+
+  ```rust
+    App.new().service(web::resource("/welcome").to(welcome))
+  ```
+
+* `HttpRequest` does not provide access to request's payload stream.
+
+  instead of
+
+  ```rust
+  fn index(req: &HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
+    req
+       .payload()
+       .from_err()
+       .fold((), |_, chunk| {
+            ...
+        })
+       .map(|_| HttpResponse::Ok().finish())
+       .responder()
+  }
+  ```
+
+  use `Payload` extractor
+
+  ```rust
+  fn index(stream: web::Payload) -> impl Future<Item=HttpResponse, Error=Error> {
+     stream
+       .from_err()
+       .fold((), |_, chunk| {
+            ...
+        })
+       .map(|_| HttpResponse::Ok().finish())
+  }
+  ```
+
+* `State` is now `Data`.  You register Data during the App initialization process
+  and then access it from handlers either using a Data extractor or using
+  HttpRequest's api.
+
+  instead of
+
+  ```rust
+    App.with_state(T)
+  ```
+
+  use App's `data` method
+
+  ```rust
+	App.new()
+       .data(T)
+  ```
+
+  and either use the Data extractor within your handler
+
+  ```rust
+    use actix_web::web::Data;
+
+	fn endpoint_handler(Data<T>)){
+      ...
+    }
+  ```
+
+  .. or access your Data element from the HttpRequest
+
+  ```rust
+	fn endpoint_handler(req: HttpRequest) {
+		let data: Option<Data<T>> = req.app_data::<T>();
+    }
+  ```
+
+
+* AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
+
+  instead of
+
+  ```rust
+	use actix_web::AsyncResponder;
+
+    fn endpoint_handler(...) -> impl Future<Item=HttpResponse, Error=Error>{
+		...
+        .responder()
+	}
+  ```
+
+  .. simply omit AsyncResponder and the corresponding responder() finish method
+
+
+* Middleware
+
+  instead of
+
+  ```rust
+      let app = App::new()
+           .middleware(middleware::Logger::default())
+  ```
+
+  use `.wrap()` method
+
+  ```rust
+      let app = App::new()
+           .wrap(middleware::Logger::default())
+           .route("/index.html", web::get().to(index));
+  ```
+
+* `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
+  method have been removed. Use `Bytes`, `String`, `Form`, `Json`, `Multipart` extractors instead.
+
+  instead of
+
+  ```rust
+  fn index(req: &HttpRequest) -> Responder {
+     req.body()
+       .and_then(|body| {
+          ...
+       })
+  }
+  ```
+
+  use
+
+  ```rust
+  fn index(body: Bytes) -> Responder {
+     ...
+  }
+  ```
+
+* `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
+
+* StaticFiles and NamedFile has been move to separate create.
+
+  instead of `use actix_web::fs::StaticFile`
+
+  use `use actix_files::Files`
+
+  instead of `use actix_web::fs::Namedfile`
+
+  use `use actix_files::NamedFile`
+
+* Multipart has been move to separate create.
+
+  instead of `use actix_web::multipart::Multipart`
+
+  use `use actix_multipart::Multipart`
+
+* Response compression is not enabled by default.
+  To enable, use `Compress` middleware, `App::new().wrap(Compress::default())`.
+
+* Session middleware moved to actix-session crate
+
+* Actors support have been moved to `actix-web-actors` crate
+
+* Custom Error
+
+  Instead of error_response method alone, ResponseError now provides two methods: error_response and render_response respectively. Where, error_response creates the error response and render_response returns the error response to the caller. 
+
+  Simplest migration from 0.7 to 1.0 shall include below method to the custom implementation of ResponseError:
+
+  ```rust
+  fn render_response(&self) -> HttpResponse {
+    self.error_response()
+  }
+  ```
+
 ## 0.7.15

 * The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# 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](https://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 [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://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 simple, pragmatic and extremely fast web framework for Rust.

@ -10,20 +10,19 @@ Actix web is a simple, pragmatic and extremely fast web framework for Rust.
 * Configurable [request routing](https://actix.rs/docs/url-dispatch/)
 * Multipart streams
 * Static assets
-* SSL support with OpenSSL or `native-tls`
-* Middlewares ([Logger, Session, CORS, CSRF, etc](https://actix.rs/docs/middleware/))
+* SSL support with OpenSSL or Rustls
+* Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
 * Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
 * Supports [Actix actor framework](https://github.com/actix/actix)
-* Experimental [Async/Await](https://github.com/mehcode/actix-web-async-await) support.

 ## Documentation & community resources

 * [User Guide](https://actix.rs/docs/)
-* [API Documentation (Development)](https://actix.rs/actix-web/actix_web/)
-* [API Documentation (Releases)](https://docs.rs/actix-web/)
+* [API Documentation (1.0)](https://docs.rs/actix-web/)
+* [API Documentation (0.7)](https://docs.rs/actix-web/0.7.19/actix_web/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-web](https://crates.io/crates/actix-web)
-* Minimum supported Rust version: 1.32 or later
+* Minimum supported Rust version: 1.34 or later

 ## Example

@ -36,11 +35,10 @@ fn index(info: web::Path<(u32, String)>) -> impl Responder {

 fn main() -> std::io::Result<()> {
    HttpServer::new(
-        || App::new()
-            .service(web::resource("/{id}/{name}/index.html")
-                .route(web::get().to(index)))
+        || App::new().service(
+              web::resource("/{id}/{name}/index.html").to(index)))
        .bind("127.0.0.1:8080")?
-        .run();
+        .run()
 }
 ```

--- a/actix-cors/CHANGES.md
+++ b/actix-cors/CHANGES.md
@ -0,0 +1,9 @@
+# Changes
+
+## [0.1.1] - unreleased
+
+* Bump `derive_more` crate version to 0.15.0
+
+## [0.1.0] - 2019-06-15
+
+* Move cors middleware to separate crate
--- a/actix-cors/Cargo.toml
+++ b/actix-cors/Cargo.toml
@ -0,0 +1,23 @@
+[package]
+name = "actix-cors"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Cross-origin resource sharing (CORS) for Actix applications."
+readme = "README.md"
+keywords = ["web", "framework"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-cors/"
+license = "MIT/Apache-2.0"
+edition = "2018"
+#workspace = ".."
+
+[lib]
+name = "actix_cors"
+path = "src/lib.rs"
+
+[dependencies]
+actix-web = "1.0.0"
+actix-service = "0.4.0"
+derive_more = "0.15.0"
+futures = "0.1.25"
--- a/actix-cors/LICENSE-APACHE
+++ b/actix-cors/LICENSE-APACHE
@ -0,0 +1 @@
+../LICENSE-APACHE
--- a/actix-cors/LICENSE-MIT
+++ b/actix-cors/LICENSE-MIT
@ -0,0 +1 @@
+../LICENSE-MIT
--- a/actix-cors/README.md
+++ b/actix-cors/README.md
@ -0,0 +1,9 @@
+# Identity service for actix web framework [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-identity)](https://crates.io/crates/actix-identity) [![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)
+
+## Documentation & community resources
+
+* [User Guide](https://actix.rs/docs/)
+* [API Documentation](https://docs.rs/actix-identity/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-session](https://crates.io/crates/actix-identity)
+* Minimum supported Rust version: 1.34 or later
--- a/src/middleware/cors.rs
+++ b/src/middleware/cors.rs
@ -7,7 +7,7 @@
 //! # Example
 //!
 //! ```rust
-//! use actix_web::middleware::cors::Cors;
+//! use actix_cors::Cors;
 //! use actix_web::{http, web, App, HttpRequest, HttpResponse, HttpServer};
 //!
 //! fn index(req: HttpRequest) -> &'static str {
@ -42,17 +42,15 @@ use std::iter::FromIterator;
 use std::rc::Rc;

 use actix_service::{IntoTransform, Service, Transform};
+use actix_web::dev::{RequestHead, ServiceRequest, ServiceResponse};
+use actix_web::error::{Error, ResponseError, Result};
+use actix_web::http::header::{self, HeaderName, HeaderValue};
+use actix_web::http::{self, HttpTryFrom, Method, StatusCode, Uri};
+use actix_web::HttpResponse;
 use derive_more::Display;
 use futures::future::{ok, Either, Future, FutureResult};
 use futures::Poll;

-use crate::dev::RequestHead;
-use crate::error::{ResponseError, Result};
-use crate::http::header::{self, HeaderName, HeaderValue};
-use crate::http::{self, HttpTryFrom, Method, StatusCode, Uri};
-use crate::service::{ServiceRequest, ServiceResponse};
-use crate::{HttpMessage, HttpResponse};
-
 /// A set of errors that can occur during processing CORS
 #[derive(Debug, Display)]
 pub enum CorsError {
@ -81,13 +79,6 @@ pub enum CorsError {
        fmt = "The request header `Access-Control-Request-Headers`  has an invalid value"
    )]
    BadRequestHeaders,
-    /// The request header `Access-Control-Request-Headers`  is required but is
-    /// missing.
-    #[display(
-        fmt = "The request header `Access-Control-Request-Headers`  is required but is
-                     missing"
-    )]
-    MissingRequestHeaders,
    /// Origin is not allowed to make this request
    #[display(fmt = "Origin is not allowed to make this request")]
    OriginNotAllowed,
@ -159,11 +150,11 @@ impl<T> AllOrSome<T> {
 /// # Example
 ///
 /// ```rust
+/// use actix_cors::Cors;
 /// use actix_web::http::header;
-/// use actix_web::middleware::cors;
 ///
 /// # fn main() {
-/// let cors = cors::Cors::new()
+/// let cors = Cors::new()
 ///     .allowed_origin("https://www.rust-lang.org/")
 ///     .allowed_methods(vec!["GET", "POST"])
 ///     .allowed_headers(vec![header::AUTHORIZATION, header::ACCEPT])
@ -475,10 +466,10 @@ fn cors<'a>(
    parts.as_mut()
 }

-impl<S, P, B> IntoTransform<CorsFactory, S> for Cors
+impl<S, B> IntoTransform<CorsFactory, S> for Cors
 where
-    S: Service<Request = ServiceRequest<P>, Response = ServiceResponse<B>> + 'static,
-    P: 'static,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
    B: 'static,
 {
    fn into_transform(self) -> CorsFactory {
@ -536,17 +527,15 @@ pub struct CorsFactory {
    inner: Rc<Inner>,
 }

-impl<S, P, B> Transform<S> for CorsFactory
+impl<S, B> Transform<S> for CorsFactory
 where
-    S: Service<Request = ServiceRequest<P>, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
-    S::Error: 'static,
-    P: 'static,
    B: 'static,
 {
-    type Request = ServiceRequest<P>;
+    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type InitError = ();
    type Transform = CorsMiddleware<S>;
    type Future = FutureResult<Self::Transform, Self::InitError>;
@ -584,7 +573,7 @@ struct Inner {

 impl Inner {
    fn validate_origin(&self, req: &RequestHead) -> Result<(), CorsError> {
-        if let Some(hdr) = req.headers().get(header::ORIGIN) {
+        if let Some(hdr) = req.headers().get(&header::ORIGIN) {
            if let Ok(origin) = hdr.to_str() {
                return match self.origins {
                    AllOrSome::All => Ok(()),
@ -608,7 +597,7 @@ impl Inner {
            AllOrSome::All => {
                if self.send_wildcard {
                    Some(HeaderValue::from_static("*"))
-                } else if let Some(origin) = req.headers().get(header::ORIGIN) {
+                } else if let Some(origin) = req.headers().get(&header::ORIGIN) {
                    Some(origin.clone())
                } else {
                    None
@ -617,7 +606,7 @@ impl Inner {
            AllOrSome::Some(ref origins) => {
                if let Some(origin) =
                    req.headers()
-                        .get(header::ORIGIN)
+                        .get(&header::ORIGIN)
                        .filter(|o| match o.to_str() {
                            Ok(os) => origins.contains(os),
                            _ => false,
@ -632,7 +621,7 @@ impl Inner {
    }

    fn validate_allowed_method(&self, req: &RequestHead) -> Result<(), CorsError> {
-        if let Some(hdr) = req.headers().get(header::ACCESS_CONTROL_REQUEST_METHOD) {
+        if let Some(hdr) = req.headers().get(&header::ACCESS_CONTROL_REQUEST_METHOD) {
            if let Ok(meth) = hdr.to_str() {
                if let Ok(method) = Method::try_from(meth) {
                    return self
@ -653,7 +642,7 @@ impl Inner {
            AllOrSome::All => Ok(()),
            AllOrSome::Some(ref allowed_headers) => {
                if let Some(hdr) =
-                    req.headers().get(header::ACCESS_CONTROL_REQUEST_HEADERS)
+                    req.headers().get(&header::ACCESS_CONTROL_REQUEST_HEADERS)
                {
                    if let Ok(headers) = hdr.to_str() {
                        let mut hdrs = HashSet::new();
@ -663,48 +652,49 @@ impl Inner {
                                Err(_) => return Err(CorsError::BadRequestHeaders),
                            };
                        }
-
-                        if !hdrs.is_empty() && !hdrs.is_subset(allowed_headers) {
-                            return Err(CorsError::HeadersNotAllowed);
+                        // `Access-Control-Request-Headers` must contain 1 or more
+                        // `field-name`.
+                        if !hdrs.is_empty() {
+                            if !hdrs.is_subset(allowed_headers) {
+                                return Err(CorsError::HeadersNotAllowed);
+                            }
+                            return Ok(());
                        }
-                        return Ok(());
                    }
                    Err(CorsError::BadRequestHeaders)
                } else {
-                    Err(CorsError::MissingRequestHeaders)
+                    return Ok(());
                }
            }
        }
    }
 }

-impl<S, P, B> Service for CorsMiddleware<S>
+impl<S, B> Service for CorsMiddleware<S>
 where
-    S: Service<Request = ServiceRequest<P>, Response = ServiceResponse<B>>,
+    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
-    S::Error: 'static,
-    P: 'static,
    B: 'static,
 {
-    type Request = ServiceRequest<P>;
+    type Request = ServiceRequest;
    type Response = ServiceResponse<B>;
-    type Error = S::Error;
+    type Error = Error;
    type Future = Either<
-        FutureResult<Self::Response, Self::Error>,
-        Either<S::Future, Box<Future<Item = Self::Response, Error = Self::Error>>>,
+        FutureResult<Self::Response, Error>,
+        Either<S::Future, Box<Future<Item = Self::Response, Error = Error>>>,
    >;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
        self.service.poll_ready()
    }

-    fn call(&mut self, req: ServiceRequest<P>) -> Self::Future {
+    fn call(&mut self, req: ServiceRequest) -> Self::Future {
        if self.inner.preflight && Method::OPTIONS == *req.method() {
            if let Err(e) = self
                .inner
-                .validate_origin(&req)
-                .and_then(|_| self.inner.validate_allowed_method(&req))
-                .and_then(|_| self.inner.validate_allowed_headers(&req))
+                .validate_origin(req.head())
+                .and_then(|_| self.inner.validate_allowed_method(req.head()))
+                .and_then(|_| self.inner.validate_allowed_headers(req.head()))
            {
                return Either::A(ok(req.error_response(e)));
            }
@ -721,7 +711,7 @@ where
                    .unwrap(),
                )
            } else if let Some(hdr) =
-                req.headers().get(header::ACCESS_CONTROL_REQUEST_HEADERS)
+                req.headers().get(&header::ACCESS_CONTROL_REQUEST_HEADERS)
            {
                Some(hdr.clone())
            } else {
@ -739,7 +729,7 @@ where
                    let _ = resp.header(header::ACCESS_CONTROL_ALLOW_HEADERS, headers);
                })
                .if_some(
-                    self.inner.access_control_allow_origin(&req),
+                    self.inner.access_control_allow_origin(req.head()),
                    |origin, resp| {
                        let _ = resp.header(header::ACCESS_CONTROL_ALLOW_ORIGIN, origin);
                    },
@ -760,9 +750,9 @@ where
                .into_body();

            Either::A(ok(req.into_response(res)))
-        } else if req.headers().contains_key(header::ORIGIN) {
+        } else if req.headers().contains_key(&header::ORIGIN) {
            // Only check requests with a origin header.
-            if let Err(e) = self.inner.validate_origin(&req) {
+            if let Err(e) = self.inner.validate_origin(req.head()) {
                return Either::A(ok(req.error_response(e)));
            }

@ -771,7 +761,7 @@ where
            Either::B(Either::B(Box::new(self.service.call(req).and_then(
                move |mut res| {
                    if let Some(origin) =
-                        inner.access_control_allow_origin(&res.request())
+                        inner.access_control_allow_origin(res.request().head())
                    {
                        res.headers_mut()
                            .insert(header::ACCESS_CONTROL_ALLOW_ORIGIN, origin.clone());
@ -791,7 +781,7 @@ where
                    }
                    if inner.vary_header {
                        let value =
-                            if let Some(hdr) = res.headers_mut().get(header::VARY) {
+                            if let Some(hdr) = res.headers_mut().get(&header::VARY) {
                                let mut val: Vec<u8> =
                                    Vec::with_capacity(hdr.as_bytes().len() + 8);
                                val.extend(hdr.as_bytes());
@ -813,24 +803,26 @@ where

 #[cfg(test)]
 mod tests {
-    use actix_service::{FnService, Transform};
+    use actix_service::{IntoService, Transform};
+    use actix_web::test::{self, block_on, TestRequest};

    use super::*;
-    use crate::dev::PayloadStream;
-    use crate::test::{self, block_on, TestRequest};

    impl Cors {
-        fn finish<S, P, B>(self, srv: S) -> CorsMiddleware<S>
+        fn finish<F, S, B>(self, srv: F) -> CorsMiddleware<S>
        where
-            S: Service<Request = ServiceRequest<P>, Response = ServiceResponse<B>>
-                + 'static,
+            F: IntoService<S>,
+            S: Service<
+                    Request = ServiceRequest,
+                    Response = ServiceResponse<B>,
+                    Error = Error,
+                > + 'static,
            S::Future: 'static,
-            S::Error: 'static,
-            P: 'static,
            B: 'static,
        {
            block_on(
-                IntoTransform::<CorsFactory, S>::into_transform(self).new_transform(srv),
+                IntoTransform::<CorsFactory, S>::into_transform(self)
+                    .new_transform(srv.into_service()),
            )
            .unwrap()
        }
@ -848,10 +840,21 @@ mod tests {
    #[test]
    fn validate_origin_allows_all_origins() {
        let mut cors = Cors::new().finish(test::ok_service());
-        let req =
-            TestRequest::with_header("Origin", "https://www.example.com").to_service();
+        let req = TestRequest::with_header("Origin", "https://www.example.com")
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
+    #[test]
+    fn default() {
+        let mut cors =
+            block_on(Cors::default().new_transform(test::ok_service())).unwrap();
+        let req = TestRequest::with_header("Origin", "https://www.example.com")
+            .to_srv_request();
+
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(resp.status(), StatusCode::OK);
    }

@ -867,20 +870,21 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::OPTIONS)
-            .to_service();
+            .header(header::ACCESS_CONTROL_REQUEST_HEADERS, "X-Not-Allowed")
+            .to_srv_request();

-        assert!(cors.inner.validate_allowed_method(&req).is_err());
-        assert!(cors.inner.validate_allowed_headers(&req).is_err());
-        let resp = test::call_success(&mut cors, req);
+        assert!(cors.inner.validate_allowed_method(req.head()).is_err());
+        assert!(cors.inner.validate_allowed_headers(req.head()).is_err());
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "put")
            .method(Method::OPTIONS)
-            .to_service();
+            .to_srv_request();

-        assert!(cors.inner.validate_allowed_method(&req).is_err());
-        assert!(cors.inner.validate_allowed_headers(&req).is_err());
+        assert!(cors.inner.validate_allowed_method(req.head()).is_err());
+        assert!(cors.inner.validate_allowed_headers(req.head()).is_ok());

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "POST")
@ -889,26 +893,26 @@ mod tests {
                "AUTHORIZATION,ACCEPT",
            )
            .method(Method::OPTIONS)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"*"[..],
            resp.headers()
-                .get(header::ACCESS_CONTROL_ALLOW_ORIGIN)
+                .get(&header::ACCESS_CONTROL_ALLOW_ORIGIN)
                .unwrap()
                .as_bytes()
        );
        assert_eq!(
            &b"3600"[..],
            resp.headers()
-                .get(header::ACCESS_CONTROL_MAX_AGE)
+                .get(&header::ACCESS_CONTROL_MAX_AGE)
                .unwrap()
                .as_bytes()
        );
        let hdr = resp
            .headers()
-            .get(header::ACCESS_CONTROL_ALLOW_HEADERS)
+            .get(&header::ACCESS_CONTROL_ALLOW_HEADERS)
            .unwrap()
            .to_str()
            .unwrap();
@ -935,9 +939,9 @@ mod tests {
                "AUTHORIZATION,ACCEPT",
            )
            .method(Method::OPTIONS)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(resp.status(), StatusCode::OK);
    }

@ -960,10 +964,10 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://www.unknown.com")
            .method(Method::GET)
-            .to_service();
-        cors.inner.validate_origin(&req).unwrap();
-        cors.inner.validate_allowed_method(&req).unwrap();
-        cors.inner.validate_allowed_headers(&req).unwrap();
+            .to_srv_request();
+        cors.inner.validate_origin(req.head()).unwrap();
+        cors.inner.validate_allowed_method(req.head()).unwrap();
+        cors.inner.validate_allowed_headers(req.head()).unwrap();
    }

    #[test]
@ -974,9 +978,9 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::GET)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(resp.status(), StatusCode::OK);
    }

@ -984,8 +988,8 @@ mod tests {
    fn test_no_origin_response() {
        let mut cors = Cors::new().disable_preflight().finish(test::ok_service());

-        let req = TestRequest::default().method(Method::GET).to_service();
-        let resp = test::call_success(&mut cors, req);
+        let req = TestRequest::default().method(Method::GET).to_srv_request();
+        let resp = test::call_service(&mut cors, req);
        assert!(resp
            .headers()
            .get(header::ACCESS_CONTROL_ALLOW_ORIGIN)
@ -993,8 +997,8 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::OPTIONS)
-            .to_service();
-        let resp = test::call_success(&mut cors, req);
+            .to_srv_request();
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"https://www.example.com"[..],
            resp.headers()
@ -1019,9 +1023,9 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::OPTIONS)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"*"[..],
            resp.headers()
@ -1059,15 +1063,15 @@ mod tests {
            .allowed_headers(exposed_headers.clone())
            .expose_headers(exposed_headers.clone())
            .allowed_header(header::CONTENT_TYPE)
-            .finish(FnService::new(move |req: ServiceRequest<PayloadStream>| {
+            .finish(|req: ServiceRequest| {
                req.into_response(
                    HttpResponse::Ok().header(header::VARY, "Accept").finish(),
                )
-            }));
+            });
        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::OPTIONS)
-            .to_service();
-        let resp = test::call_success(&mut cors, req);
+            .to_srv_request();
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"Accept, Origin"[..],
            resp.headers().get(header::VARY).unwrap().as_bytes()
@ -1082,8 +1086,8 @@ mod tests {
        let req = TestRequest::with_header("Origin", "https://www.example.com")
            .method(Method::OPTIONS)
            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "POST")
-            .to_service();
-        let resp = test::call_success(&mut cors, req);
+            .to_srv_request();
+        let resp = test::call_service(&mut cors, req);

        let origins_str = resp
            .headers()
@ -1105,9 +1109,9 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://example.com")
            .method(Method::GET)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"https://example.com"[..],
            resp.headers()
@ -1118,9 +1122,9 @@ mod tests {

        let req = TestRequest::with_header("Origin", "https://example.org")
            .method(Method::GET)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"https://example.org"[..],
            resp.headers()
@ -1141,9 +1145,9 @@ mod tests {
        let req = TestRequest::with_header("Origin", "https://example.com")
            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "GET")
            .method(Method::OPTIONS)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"https://example.com"[..],
            resp.headers()
@ -1155,9 +1159,9 @@ mod tests {
        let req = TestRequest::with_header("Origin", "https://example.org")
            .header(header::ACCESS_CONTROL_REQUEST_METHOD, "GET")
            .method(Method::OPTIONS)
-            .to_service();
+            .to_srv_request();

-        let resp = test::call_success(&mut cors, req);
+        let resp = test::call_service(&mut cors, req);
        assert_eq!(
            &b"https://example.org"[..],
            resp.headers()
--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@ -1,5 +1,45 @@
 # Changes

-## [0.1.0] - 2018-10-x
+## [0.1.3] - 2019-06-28
+
+* Do not set `Content-Length` header, let actix-http set it #930
+
+
+## [0.1.2] - 2019-06-13
+
+* Content-Length is 0 for NamedFile HEAD request #914
+
+* Fix ring dependency from actix-web default features for #741
+
+## [0.1.1] - 2019-06-01
+
+* Static files are incorrectly served as both chunked and with length #812
+
+## [0.1.0] - 2019-05-25
+
+* NamedFile last-modified check always fails due to nano-seconds
+  in file modified date #820
+
+## [0.1.0-beta.4] - 2019-05-12
+
+* Update actix-web to beta.4
+
+## [0.1.0-beta.1] - 2019-04-20
+
+* Update actix-web to beta.1
+
+## [0.1.0-alpha.6] - 2019-04-14
+
+* Update actix-web to alpha6
+
+## [0.1.0-alpha.4] - 2019-04-08
+
+* Update actix-web to alpha4
+
+## [0.1.0-alpha.2] - 2019-04-02
+
+* Add default handler support
+
+## [0.1.0-alpha.1] - 2019-03-28

 * Initial impl
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@ -1,8 +1,8 @@
 [package]
 name = "actix-files"
-version = "0.1.0-alpha.1"
+version = "0.1.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Static files support for Actix web."
+description = "Static files support for actix web."
 readme = "README.md"
 keywords = ["actix", "http", "async", "futures"]
 homepage = "https://actix.rs"
@ -18,14 +18,13 @@ name = "actix_files"
 path = "src/lib.rs"

 [dependencies]
-actix-web = { path=".." }
-actix-http = { path="../actix-http" }
-actix-service = "0.3.3"
-
+actix-web = { version = "1.0.2", default-features = false }
+actix-http = "0.2.4"
+actix-service = "0.4.1"
 bitflags = "1"
 bytes = "0.4"
-futures = "0.1"
-derive_more = "0.14"
+futures = "0.1.25"
+derive_more = "0.15.0"
 log = "0.4"
 mime = "0.3"
 mime_guess = "2.0.0-alpha"
@ -33,4 +32,4 @@ percent-encoding = "1.0"
 v_htmlescape = "0.4"

 [dev-dependencies]
-actix-web = { path="..", features=["ssl"] }
+actix-web = { version = "1.0.2", features=["ssl"] }
--- a/actix-files/LICENSE-APACHE
+++ b/actix-files/LICENSE-APACHE
@ -0,0 +1 @@
+../LICENSE-APACHE
--- a/actix-files/LICENSE-MIT
+++ b/actix-files/LICENSE-MIT
@ -0,0 +1 @@
+../LICENSE-MIT
--- a/actix-files/README.md
+++ b/actix-files/README.md
@ -1,82 +1,9 @@
-# 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](https://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 simple, pragmatic and extremely fast web framework for Rust.
-
-* Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.rs/docs/http2/) protocols
-* Streaming and pipelining
-* Keep-alive and slow requests handling
-* Client/server [WebSockets](https://actix.rs/docs/websockets/) support
-* Transparent content compression/decompression (br, gzip, deflate)
-* Configurable [request routing](https://actix.rs/docs/url-dispatch/)
-* Multipart streams
-* Static assets
-* SSL support with OpenSSL or `native-tls`
-* Middlewares ([Logger, Session, CORS, CSRF, etc](https://actix.rs/docs/middleware/))
-* Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
-* Built on top of [Actix actor framework](https://github.com/actix/actix)
-* Experimental [Async/Await](https://github.com/mehcode/actix-web-async-await) support.
+# Static files support for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-files)](https://crates.io/crates/actix-files) [![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)

 ## Documentation & community resources

 * [User Guide](https://actix.rs/docs/)
-* [API Documentation (Development)](https://actix.rs/actix-web/actix_web/)
-* [API Documentation (Releases)](https://actix.rs/api/actix-web/stable/actix_web/)
+* [API Documentation](https://docs.rs/actix-files/)
 * [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-web](https://crates.io/crates/actix-web)
-* Minimum supported Rust version: 1.31 or later
-
-## Example
-
-```rust
-extern crate actix_web;
-use actix_web::{http, server, App, Path, Responder};
-
-fn index(info: Path<(u32, String)>) -> impl Responder {
-    format!("Hello {}! id:{}", info.1, info.0)
-}
-
-fn main() {
-    server::new(
-        || App::new()
-            .route("/{id}/{name}/index.html", http::Method::GET, index))
-        .bind("127.0.0.1:8080").unwrap()
-        .run();
-}
-```
-
-### More examples
-
-* [Basics](https://github.com/actix/examples/tree/master/basics/)
-* [Stateful](https://github.com/actix/examples/tree/master/state/)
-* [Protobuf support](https://github.com/actix/examples/tree/master/protobuf/)
-* [Multipart streams](https://github.com/actix/examples/tree/master/multipart/)
-* [Simple websocket](https://github.com/actix/examples/tree/master/websocket/)
-* [Tera](https://github.com/actix/examples/tree/master/template_tera/) /
-  [Askama](https://github.com/actix/examples/tree/master/template_askama/) templates
-* [Diesel integration](https://github.com/actix/examples/tree/master/diesel/)
-* [r2d2](https://github.com/actix/examples/tree/master/r2d2/)
-* [SSL / HTTP/2.0](https://github.com/actix/examples/tree/master/tls/)
-* [Tcp/Websocket chat](https://github.com/actix/examples/tree/master/websocket-chat/)
-* [Json](https://github.com/actix/examples/tree/master/json/)
-
-You may consider checking out
-[this directory](https://github.com/actix/examples/tree/master/) for more examples.
-
-## Benchmarks
-
-* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r16&hw=ph&test=plaintext)
-
-## License
-
-This project is licensed under either of
-
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
-
-at your option.
-
-## Code of Conduct
-
-Contribution to the actix-web crate is organized under the terms of the
-Contributor Covenant, the maintainer of actix-web, @fafhrd91, promises to
-intervene to uphold that code of conduct.
+* Cargo package: [actix-files](https://crates.io/crates/actix-files)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@ -7,22 +7,22 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::{cmp, io};

-use bytes::Bytes;
-use futures::{Async, Future, Poll, Stream};
-use mime;
-use mime_guess::get_mime_type;
-use percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET};
-use v_htmlescape::escape as escape_html_entity;
-
-use actix_service::{boxed::BoxedNewService, NewService, Service};
+use actix_service::boxed::{self, BoxedNewService, BoxedService};
+use actix_service::{IntoNewService, NewService, Service};
 use actix_web::dev::{
-    HttpServiceFactory, ResourceDef, ServiceConfig, ServiceFromRequest, ServiceRequest,
+    AppService, HttpServiceFactory, Payload, ResourceDef, ServiceRequest,
    ServiceResponse,
 };
 use actix_web::error::{BlockingError, Error, ErrorInternalServerError};
 use actix_web::http::header::DispositionType;
 use actix_web::{web, FromRequest, HttpRequest, HttpResponse, Responder};
-use futures::future::{ok, FutureResult};
+use bytes::Bytes;
+use futures::future::{ok, Either, FutureResult};
+use futures::{Async, Future, Poll, Stream};
+use mime;
+use mime_guess::get_mime_type;
+use percent_encoding::{utf8_percent_encode, DEFAULT_ENCODE_SET};
+use v_htmlescape::escape as escape_html_entity;

 mod error;
 mod named;
@ -32,8 +32,8 @@ use self::error::{FilesError, UriSegmentError};
 pub use crate::named::NamedFile;
 pub use crate::range::HttpRange;

-type HttpNewService<P> =
-    BoxedNewService<(), ServiceRequest<P>, ServiceResponse, Error, ()>;
+type HttpService = BoxedService<ServiceRequest, ServiceResponse, Error>;
+type HttpNewService = BoxedNewService<(), ServiceRequest, ServiceResponse, Error, ()>;

 /// Return the MIME type associated with a filename extension (case-insensitive).
 /// If `ext` is empty or no associated type for the extension was found, returns
@ -224,20 +224,18 @@ type MimeOverride = Fn(&mime::Name) -> DispositionType;
 ///         .service(fs::Files::new("/static", "."));
 /// }
 /// ```
-pub struct Files<S> {
+pub struct Files {
    path: String,
    directory: PathBuf,
    index: Option<String>,
    show_index: bool,
-    default: Rc<RefCell<Option<Rc<HttpNewService<S>>>>>,
+    default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
    renderer: Rc<DirectoryRenderer>,
    mime_override: Option<Rc<MimeOverride>>,
-    _chunk_size: usize,
-    _follow_symlinks: bool,
    file_flags: named::Flags,
 }

-impl<S> Clone for Files<S> {
+impl Clone for Files {
    fn clone(&self) -> Self {
        Self {
            directory: self.directory.clone(),
@ -245,8 +243,6 @@ impl<S> Clone for Files<S> {
            show_index: self.show_index,
            default: self.default.clone(),
            renderer: self.renderer.clone(),
-            _chunk_size: self._chunk_size,
-            _follow_symlinks: self._follow_symlinks,
            file_flags: self.file_flags,
            path: self.path.clone(),
            mime_override: self.mime_override.clone(),
@ -254,13 +250,13 @@ impl<S> Clone for Files<S> {
    }
 }

-impl<S: 'static> Files<S> {
+impl Files {
    /// Create new `Files` instance for specified base directory.
    ///
    /// `File` uses `ThreadPool` for blocking filesystem operations.
    /// By default pool with 5x threads of available cpus is used.
    /// Pool size can be changed by setting ACTIX_CPU_POOL environment variable.
-    pub fn new<T: Into<PathBuf>>(path: &str, dir: T) -> Files<S> {
+    pub fn new<T: Into<PathBuf>>(path: &str, dir: T) -> Files {
        let dir = dir.into().canonicalize().unwrap_or_else(|_| PathBuf::new());
        if !dir.is_dir() {
            log::error!("Specified path is not a directory");
@ -274,8 +270,6 @@ impl<S: 'static> Files<S> {
            default: Rc::new(RefCell::new(None)),
            renderer: Rc::new(directory_listing),
            mime_override: None,
-            _chunk_size: 0,
-            _follow_symlinks: false,
            file_flags: named::Flags::default(),
        }
    }
@ -334,13 +328,29 @@ impl<S: 'static> Files<S> {
        self.file_flags.set(named::Flags::LAST_MD, value);
        self
    }
+
+    /// Sets default handler which is used when no matched file could be found.
+    pub fn default_handler<F, U>(mut self, f: F) -> Self
+    where
+        F: IntoNewService<U>,
+        U: NewService<
+                Config = (),
+                Request = ServiceRequest,
+                Response = ServiceResponse,
+                Error = Error,
+            > + 'static,
+    {
+        // create and configure default resource
+        self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::new_service(
+            f.into_new_service().map_init_err(|_| ()),
+        )))));
+
+        self
+    }
 }

-impl<P> HttpServiceFactory<P> for Files<P>
-where
-    P: 'static,
-{
-    fn register(self, config: &mut ServiceConfig<P>) {
+impl HttpServiceFactory for Files {
+    fn register(self, config: &mut AppService) {
        if self.default.borrow().is_none() {
            *self.default.borrow_mut() = Some(config.default_service());
        }
@ -353,41 +363,95 @@ where
    }
 }

-impl<P> NewService for Files<P> {
-    type Request = ServiceRequest<P>;
+impl NewService for Files {
+    type Config = ();
+    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
-    type Service = Self;
+    type Service = FilesService;
    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
+    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;

    fn new_service(&self, _: &()) -> Self::Future {
-        ok(self.clone())
+        let mut srv = FilesService {
+            directory: self.directory.clone(),
+            index: self.index.clone(),
+            show_index: self.show_index,
+            default: None,
+            renderer: self.renderer.clone(),
+            mime_override: self.mime_override.clone(),
+            file_flags: self.file_flags,
+        };
+
+        if let Some(ref default) = *self.default.borrow() {
+            Box::new(
+                default
+                    .new_service(&())
+                    .map(move |default| {
+                        srv.default = Some(default);
+                        srv
+                    })
+                    .map_err(|_| ()),
+            )
+        } else {
+            Box::new(ok(srv))
+        }
    }
 }

-impl<P> Service for Files<P> {
-    type Request = ServiceRequest<P>;
+pub struct FilesService {
+    directory: PathBuf,
+    index: Option<String>,
+    show_index: bool,
+    default: Option<HttpService>,
+    renderer: Rc<DirectoryRenderer>,
+    mime_override: Option<Rc<MimeOverride>>,
+    file_flags: named::Flags,
+}
+
+impl FilesService {
+    fn handle_err(
+        &mut self,
+        e: io::Error,
+        req: ServiceRequest,
+    ) -> Either<
+        FutureResult<ServiceResponse, Error>,
+        Box<Future<Item = ServiceResponse, Error = Error>>,
+    > {
+        log::debug!("Files: Failed to handle {}: {}", req.path(), e);
+        if let Some(ref mut default) = self.default {
+            default.call(req)
+        } else {
+            Either::A(ok(req.error_response(e)))
+        }
+    }
+}
+
+impl Service for FilesService {
+    type Request = ServiceRequest;
    type Response = ServiceResponse;
    type Error = Error;
-    type Future = FutureResult<Self::Response, Self::Error>;
+    type Future = Either<
+        FutureResult<Self::Response, Self::Error>,
+        Box<Future<Item = Self::Response, Error = Self::Error>>,
+    >;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
        Ok(Async::Ready(()))
    }

-    fn call(&mut self, req: ServiceRequest<P>) -> Self::Future {
-        let (req, _) = req.into_parts();
+    fn call(&mut self, req: ServiceRequest) -> Self::Future {
+        // let (req, pl) = req.into_parts();

        let real_path = match PathBufWrp::get_pathbuf(req.match_info().path()) {
            Ok(item) => item,
-            Err(e) => return ok(ServiceResponse::from_err(e, req.clone())),
+            Err(e) => return Either::A(ok(req.error_response(e))),
        };

        // full filepath
        let path = match self.directory.join(&real_path.0).canonicalize() {
            Ok(path) => path,
-            Err(e) => return ok(ServiceResponse::from_err(e, req.clone())),
+            Err(e) => return self.handle_err(e, req),
        };

        if path.is_dir() {
@ -403,25 +467,27 @@ impl<P> Service for Files<P> {
                        }

                        named_file.flags = self.file_flags;
-                        match named_file.respond_to(&req) {
-                            Ok(item) => ok(ServiceResponse::new(req.clone(), item)),
-                            Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
-                        }
+                        let (req, _) = req.into_parts();
+                        Either::A(ok(match named_file.respond_to(&req) {
+                            Ok(item) => ServiceResponse::new(req, item),
+                            Err(e) => ServiceResponse::from_err(e, req),
+                        }))
                    }
-                    Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+                    Err(e) => return self.handle_err(e, req),
                }
            } else if self.show_index {
                let dir = Directory::new(self.directory.clone(), path);
+                let (req, _) = req.into_parts();
                let x = (self.renderer)(&dir, &req);
                match x {
-                    Ok(resp) => ok(resp),
-                    Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+                    Ok(resp) => Either::A(ok(resp)),
+                    Err(e) => return Either::A(ok(ServiceResponse::from_err(e, req))),
                }
            } else {
-                ok(ServiceResponse::from_err(
+                Either::A(ok(ServiceResponse::from_err(
                    FilesError::IsDirectory,
-                    req.clone(),
-                ))
+                    req.into_parts().0,
+                )))
            }
        } else {
            match NamedFile::open(path) {
@ -433,12 +499,15 @@ impl<P> Service for Files<P> {
                    }

                    named_file.flags = self.file_flags;
+                    let (req, _) = req.into_parts();
                    match named_file.respond_to(&req) {
-                        Ok(item) => ok(ServiceResponse::new(req.clone(), item)),
-                        Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+                        Ok(item) => {
+                            Either::A(ok(ServiceResponse::new(req.clone(), item)))
+                        }
+                        Err(e) => Either::A(ok(ServiceResponse::from_err(e, req))),
                    }
                }
-                Err(e) => ok(ServiceResponse::from_err(e, req.clone())),
+                Err(e) => self.handle_err(e, req),
            }
        }
    }
@ -476,11 +545,12 @@ impl PathBufWrp {
    }
 }

-impl<P> FromRequest<P> for PathBufWrp {
+impl FromRequest for PathBufWrp {
    type Error = UriSegmentError;
    type Future = Result<Self, Self::Error>;
+    type Config = ();

-    fn from_request(req: &mut ServiceFromRequest<P>) -> Self::Future {
+    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
        PathBufWrp::get_pathbuf(req.match_info().path())
    }
 }
@ -495,7 +565,11 @@ mod tests {
    use bytes::BytesMut;

    use super::*;
-    use actix_web::http::{header, header::DispositionType, Method, StatusCode};
+    use actix_web::http::header::{
+        self, ContentDisposition, DispositionParam, DispositionType,
+    };
+    use actix_web::http::{Method, StatusCode};
+    use actix_web::middleware::Compress;
    use actix_web::test::{self, TestRequest};
    use actix_web::App;

@ -612,7 +686,6 @@ mod tests {

    #[test]
    fn test_named_file_image_attachment() {
-        use header::{ContentDisposition, DispositionParam, DispositionType};
        let cd = ContentDisposition {
            disposition: DispositionType::Attachment,
            parameters: vec![DispositionParam::Filename(String::from("test.png"))],
@ -704,7 +777,7 @@ mod tests {
        );

        let request = TestRequest::get().uri("/").to_request();
-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);
        assert_eq!(response.status(), StatusCode::OK);

        let content_disposition = response
@ -728,7 +801,7 @@ mod tests {
            .uri("/t%65st/Cargo.toml")
            .header(header::RANGE, "bytes=10-20")
            .to_request();
-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);
        assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);

        // Invalid range header
@ -736,7 +809,7 @@ mod tests {
            .uri("/t%65st/Cargo.toml")
            .header(header::RANGE, "bytes=1-0")
            .to_request();
-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);

        assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
    }
@ -753,7 +826,7 @@ mod tests {
            .header(header::RANGE, "bytes=10-20")
            .to_request();

-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);
        let contentrange = response
            .headers()
            .get(header::CONTENT_RANGE)
@ -768,7 +841,7 @@ mod tests {
            .uri("/t%65st/tests/test.binary")
            .header(header::RANGE, "bytes=10-5")
            .to_request();
-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);

        let contentrange = response
            .headers()
@ -782,6 +855,8 @@ mod tests {

    #[test]
    fn test_named_file_content_length_headers() {
+        use actix_web::body::{MessageBody, ResponseBody};
+
        let mut srv = test::init_service(
            App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
        );
@ -791,23 +866,22 @@ mod tests {
            .uri("/t%65st/tests/test.binary")
            .header(header::RANGE, "bytes=10-20")
            .to_request();
-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);

-        let contentlength = response
-            .headers()
-            .get(header::CONTENT_LENGTH)
-            .unwrap()
-            .to_str()
-            .unwrap();
-
-        assert_eq!(contentlength, "11");
+        // let contentlength = response
+        //     .headers()
+        //     .get(header::CONTENT_LENGTH)
+        //     .unwrap()
+        //     .to_str()
+        //     .unwrap();
+        // assert_eq!(contentlength, "11");

        // Invalid range header
        let request = TestRequest::get()
            .uri("/t%65st/tests/test.binary")
            .header(header::RANGE, "bytes=10-8")
            .to_request();
-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);
        assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);

        // Without range header
@ -815,22 +889,21 @@ mod tests {
            .uri("/t%65st/tests/test.binary")
            // .no_default_headers()
            .to_request();
-        let response = test::call_success(&mut srv, request);
+        let response = test::call_service(&mut srv, request);

-        let contentlength = response
-            .headers()
-            .get(header::CONTENT_LENGTH)
-            .unwrap()
-            .to_str()
-            .unwrap();
-
-        assert_eq!(contentlength, "100");
+        // let contentlength = response
+        //     .headers()
+        //     .get(header::CONTENT_LENGTH)
+        //     .unwrap()
+        //     .to_str()
+        //     .unwrap();
+        // assert_eq!(contentlength, "100");

        // chunked
        let request = TestRequest::get()
            .uri("/t%65st/tests/test.binary")
            .to_request();
-        let mut response = test::call_success(&mut srv, request);
+        let mut response = test::call_service(&mut srv, request);

        // with enabled compression
        // {
@ -853,6 +926,29 @@ mod tests {
        assert_eq!(bytes.freeze(), data);
    }

+    #[test]
+    fn test_head_content_length_headers() {
+        let mut srv = test::init_service(
+            App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
+        );
+
+        // Valid range header
+        let request = TestRequest::default()
+            .method(Method::HEAD)
+            .uri("/t%65st/tests/test.binary")
+            .to_request();
+        let response = test::call_service(&mut srv, request);
+
+        // TODO: fix check
+        // let contentlength = response
+        //     .headers()
+        //     .get(header::CONTENT_LENGTH)
+        //     .unwrap()
+        //     .to_str()
+        //     .unwrap();
+        // assert_eq!(contentlength, "100");
+    }
+
    #[test]
    fn test_static_files_with_spaces() {
        let mut srv = test::init_service(
@ -861,7 +957,7 @@ mod tests {
        let request = TestRequest::get()
            .uri("/tests/test%20space.binary")
            .to_request();
-        let mut response = test::call_success(&mut srv, request);
+        let mut response = test::call_service(&mut srv, request);
        assert_eq!(response.status(), StatusCode::OK);

        let bytes =
@ -890,20 +986,50 @@ mod tests {
        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
    }

-    //     #[test]
-    //     fn test_named_file_content_encoding() {
-    //         let req = TestRequest::default().method(Method::GET).finish();
-    //         let file = NamedFile::open("Cargo.toml").unwrap();
+    #[test]
+    fn test_named_file_content_encoding() {
+        let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
+            web::resource("/").to(|| {
+                NamedFile::open("Cargo.toml")
+                    .unwrap()
+                    .set_content_encoding(header::ContentEncoding::Identity)
+            }),
+        ));

-    //         assert!(file.encoding.is_none());
-    //         let resp = file
-    //             .set_content_encoding(ContentEncoding::Identity)
-    //             .respond_to(&req)
-    //             .unwrap();
+        let request = TestRequest::get()
+            .uri("/")
+            .header(header::ACCEPT_ENCODING, "gzip")
+            .to_request();
+        let res = test::call_service(&mut srv, request);
+        assert_eq!(res.status(), StatusCode::OK);
+        assert!(!res.headers().contains_key(header::CONTENT_ENCODING));
+    }

-    //         assert!(resp.content_encoding().is_some());
-    //         assert_eq!(resp.content_encoding().unwrap().as_str(), "identity");
-    //     }
+    #[test]
+    fn test_named_file_content_encoding_gzip() {
+        let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
+            web::resource("/").to(|| {
+                NamedFile::open("Cargo.toml")
+                    .unwrap()
+                    .set_content_encoding(header::ContentEncoding::Gzip)
+            }),
+        ));
+
+        let request = TestRequest::get()
+            .uri("/")
+            .header(header::ACCEPT_ENCODING, "gzip")
+            .to_request();
+        let res = test::call_service(&mut srv, request);
+        assert_eq!(res.status(), StatusCode::OK);
+        assert_eq!(
+            res.headers()
+                .get(header::CONTENT_ENCODING)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "gzip"
+        );
+    }

    #[test]
    fn test_named_file_allowed_method() {
@ -920,20 +1046,20 @@ mod tests {
        );
        let req = TestRequest::with_uri("/missing").to_request();

-        let resp = test::call_success(&mut srv, req);
+        let resp = test::call_service(&mut srv, req);
        assert_eq!(resp.status(), StatusCode::NOT_FOUND);

        let mut srv = test::init_service(App::new().service(Files::new("/", ".")));

        let req = TestRequest::default().to_request();
-        let resp = test::call_success(&mut srv, req);
+        let resp = test::call_service(&mut srv, req);
        assert_eq!(resp.status(), StatusCode::NOT_FOUND);

        let mut srv = test::init_service(
            App::new().service(Files::new("/", ".").show_files_listing()),
        );
        let req = TestRequest::with_uri("/tests").to_request();
-        let mut resp = test::call_success(&mut srv, req);
+        let mut resp = test::call_service(&mut srv, req);
        assert_eq!(
            resp.headers().get(header::CONTENT_TYPE).unwrap(),
            "text/html; charset=utf-8"
@ -950,26 +1076,33 @@ mod tests {

    #[test]
    fn test_static_files_bad_directory() {
-        let _st: Files<()> = Files::new("/", "missing");
-        let _st: Files<()> = Files::new("/", "Cargo.toml");
+        let _st: Files = Files::new("/", "missing");
+        let _st: Files = Files::new("/", "Cargo.toml");
    }

-    //     #[test]
-    //     fn test_default_handler_file_missing() {
-    //         let st = Files::new(".")
-    //             .default_handler(|_: &_| "default content");
-    //         let req = TestRequest::with_uri("/missing")
-    //             .param("tail", "missing")
-    //             .finish();
+    #[test]
+    fn test_default_handler_file_missing() {
+        let mut st = test::block_on(
+            Files::new("/", ".")
+                .default_handler(|req: ServiceRequest| {
+                    Ok(req.into_response(HttpResponse::Ok().body("default content")))
+                })
+                .new_service(&()),
+        )
+        .unwrap();
+        let req = TestRequest::with_uri("/missing").to_srv_request();

-    //         let resp = st.handle(&req).respond_to(&req).unwrap();
-    //         let resp = resp.as_msg();
-    //         assert_eq!(resp.status(), StatusCode::OK);
-    //         assert_eq!(
-    //             resp.body(),
-    //             &Body::Binary(Binary::Slice(b"default content"))
-    //         );
-    //     }
+        let mut resp = test::call_service(&mut st, req);
+        assert_eq!(resp.status(), StatusCode::OK);
+        let bytes =
+            test::block_on(resp.take_body().fold(BytesMut::new(), |mut b, c| {
+                b.extend(c);
+                Ok::<_, Error>(b)
+            }))
+            .unwrap();
+
+        assert_eq!(bytes.freeze(), Bytes::from_static(b"default content"));
+    }

    //     #[test]
    //     fn test_serve_index() {
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@ -11,11 +11,12 @@ use bitflags::bitflags;
 use mime;
 use mime_guess::guess_mime_type;

+use actix_http::body::SizedStream;
 use actix_web::http::header::{
    self, ContentDisposition, DispositionParam, DispositionType,
 };
 use actix_web::http::{ContentEncoding, Method, StatusCode};
-use actix_web::middleware::encoding::BodyEncoding;
+use actix_web::middleware::BodyEncoding;
 use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse, Responder};

 use crate::range::HttpRange;
@ -43,7 +44,7 @@ pub struct NamedFile {
    pub(crate) content_disposition: header::ContentDisposition,
    pub(crate) md: Metadata,
    modified: Option<SystemTime>,
-    encoding: Option<ContentEncoding>,
+    pub(crate) encoding: Option<ContentEncoding>,
    pub(crate) status_code: StatusCode,
    pub(crate) flags: Flags,
 }
@ -66,6 +67,7 @@ impl NamedFile {
    ///     let mut file = File::create("foo.txt")?;
    ///     file.write_all(b"Hello, world!")?;
    ///     let named_file = NamedFile::from_file(file, "bar.txt")?;
+    ///     # std::fs::remove_file("foo.txt");
    ///     Ok(())
    /// }
    /// ```
@ -296,10 +298,9 @@ impl Responder for NamedFile {
                    header::CONTENT_DISPOSITION,
                    self.content_disposition.to_string(),
                );
-            // TODO blocking by compressing
-            // if let Some(current_encoding) = self.encoding {
-            //     resp.content_encoding(current_encoding);
-            // }
+            if let Some(current_encoding) = self.encoding {
+                resp.encoding(current_encoding);
+            }
            let reader = ChunkedReadFile {
                size: self.md.len(),
                offset: 0,
@ -337,7 +338,12 @@ impl Responder for NamedFile {
        } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
            (last_modified, req.get_header())
        {
-            m > since
+            let t1: SystemTime = m.clone().into();
+            let t2: SystemTime = since.clone().into();
+            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
+                (Ok(t1), Ok(t2)) => t1 > t2,
+                _ => false,
+            }
        } else {
            false
        };
@ -345,12 +351,17 @@ impl Responder for NamedFile {
        // check last modified
        let not_modified = if !none_match(etag.as_ref(), req) {
            true
-        } else if req.headers().contains_key(header::IF_NONE_MATCH) {
+        } else if req.headers().contains_key(&header::IF_NONE_MATCH) {
            false
        } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
            (last_modified, req.get_header())
        {
-            m <= since
+            let t1: SystemTime = m.clone().into();
+            let t2: SystemTime = since.clone().into();
+            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
+                (Ok(t1), Ok(t2)) => t1 <= t2,
+                _ => false,
+            }
        } else {
            false
        };
@ -379,7 +390,7 @@ impl Responder for NamedFile {
        let mut offset = 0;

        // check for range header
-        if let Some(ranges) = req.headers().get(header::RANGE) {
+        if let Some(ranges) = req.headers().get(&header::RANGE) {
            if let Ok(rangesheader) = ranges.to_str() {
                if let Ok(rangesvec) = HttpRange::parse(rangesheader, length) {
                    length = rangesvec[0].length;
@ -403,28 +414,22 @@ impl Responder for NamedFile {
            };
        };

-        resp.header(header::CONTENT_LENGTH, format!("{}", length));
-
        if precondition_failed {
            return Ok(resp.status(StatusCode::PRECONDITION_FAILED).finish());
        } else if not_modified {
            return Ok(resp.status(StatusCode::NOT_MODIFIED).finish());
        }

-        if *req.method() == Method::HEAD {
-            Ok(resp.finish())
-        } else {
-            let reader = ChunkedReadFile {
-                offset,
-                size: length,
-                file: Some(self.file),
-                fut: None,
-                counter: 0,
-            };
-            if offset != 0 || length != self.md.len() {
-                return Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader));
-            };
-            Ok(resp.streaming(reader))
-        }
+        let reader = ChunkedReadFile {
+            offset,
+            size: length,
+            file: Some(self.file),
+            fut: None,
+            counter: 0,
+        };
+        if offset != 0 || length != self.md.len() {
+            return Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader));
+        };
+        Ok(resp.body(SizedStream::new(length, reader)))
    }
 }
--- a/actix-framed/Cargo.toml
+++ b/actix-framed/Cargo.toml
@ -0,0 +1,38 @@
+[package]
+name = "actix-framed"
+version = "0.2.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix framed app server"
+readme = "README.md"
+keywords = ["http", "web", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-framed/"
+categories = ["network-programming", "asynchronous",
+              "web-programming::http-server",
+              "web-programming::websocket"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace =".."
+
+[lib]
+name = "actix_framed"
+path = "src/lib.rs"
+
+[dependencies]
+actix-codec = "0.1.2"
+actix-service = "0.4.0"
+actix-utils = "0.4.0"
+actix-router = "0.1.2"
+actix-rt = "0.2.2"
+actix-http = "0.2.0"
+actix-server-config = "0.1.1"
+
+bytes = "0.4"
+futures = "0.1.25"
+log = "0.4"
+
+[dev-dependencies]
+actix-server = { version = "0.5.0", features=["ssl"] }
+actix-connect = { version = "0.2.0", features=["ssl"] }
+actix-http-test = { version = "0.2.0", features=["ssl"] }
--- a/actix-framed/LICENSE-APACHE
+++ b/actix-framed/LICENSE-APACHE
@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2017-NOW Nikolay Kim
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/actix-framed/LICENSE-MIT
+++ b/actix-framed/LICENSE-MIT
@ -0,0 +1,25 @@
+Copyright (c) 2017 Nikolay Kim
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/actix-framed/README.md
+++ b/actix-framed/README.md
@ -0,0 +1,8 @@
+# Framed app for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-framed)](https://crates.io/crates/actix-framed) [![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)
+
+## Documentation & community resources
+
+* [API Documentation](https://docs.rs/actix-framed/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-framed](https://crates.io/crates/actix-framed)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-framed/changes.md
+++ b/actix-framed/changes.md
@ -0,0 +1,15 @@
+# Changes
+
+## [0.2.0] - 2019-05-12
+
+* Update dependencies
+
+
+## [0.1.0] - 2019-04-16
+
+* Update tests
+
+
+## [0.1.0-alpha.1] - 2019-04-12
+
+* Initial release
--- a/actix-framed/src/app.rs
+++ b/actix-framed/src/app.rs
@ -0,0 +1,218 @@
+use std::rc::Rc;
+
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use actix_http::h1::{Codec, SendResponse};
+use actix_http::{Error, Request, Response};
+use actix_router::{Path, Router, Url};
+use actix_server_config::ServerConfig;
+use actix_service::{IntoNewService, NewService, Service};
+use actix_utils::cloneable::CloneableService;
+use futures::{Async, Future, Poll};
+
+use crate::helpers::{BoxedHttpNewService, BoxedHttpService, HttpNewService};
+use crate::request::FramedRequest;
+use crate::state::State;
+
+type BoxedResponse = Box<Future<Item = (), Error = Error>>;
+
+pub trait HttpServiceFactory {
+    type Factory: NewService;
+
+    fn path(&self) -> &str;
+
+    fn create(self) -> Self::Factory;
+}
+
+/// Application builder
+pub struct FramedApp<T, S = ()> {
+    state: State<S>,
+    services: Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>,
+}
+
+impl<T: 'static> FramedApp<T, ()> {
+    pub fn new() -> Self {
+        FramedApp {
+            state: State::new(()),
+            services: Vec::new(),
+        }
+    }
+}
+
+impl<T: 'static, S: 'static> FramedApp<T, S> {
+    pub fn with(state: S) -> FramedApp<T, S> {
+        FramedApp {
+            services: Vec::new(),
+            state: State::new(state),
+        }
+    }
+
+    pub fn service<U>(mut self, factory: U) -> Self
+    where
+        U: HttpServiceFactory,
+        U::Factory: NewService<
+                Config = (),
+                Request = FramedRequest<T, S>,
+                Response = (),
+                Error = Error,
+                InitError = (),
+            > + 'static,
+        <U::Factory as NewService>::Future: 'static,
+        <U::Factory as NewService>::Service: Service<
+            Request = FramedRequest<T, S>,
+            Response = (),
+            Error = Error,
+            Future = Box<Future<Item = (), Error = Error>>,
+        >,
+    {
+        let path = factory.path().to_string();
+        self.services
+            .push((path, Box::new(HttpNewService::new(factory.create()))));
+        self
+    }
+}
+
+impl<T, S> IntoNewService<FramedAppFactory<T, S>> for FramedApp<T, S>
+where
+    T: AsyncRead + AsyncWrite + 'static,
+    S: 'static,
+{
+    fn into_new_service(self) -> FramedAppFactory<T, S> {
+        FramedAppFactory {
+            state: self.state,
+            services: Rc::new(self.services),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct FramedAppFactory<T, S> {
+    state: State<S>,
+    services: Rc<Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>>,
+}
+
+impl<T, S> NewService for FramedAppFactory<T, S>
+where
+    T: AsyncRead + AsyncWrite + 'static,
+    S: 'static,
+{
+    type Config = ServerConfig;
+    type Request = (Request, Framed<T, Codec>);
+    type Response = ();
+    type Error = Error;
+    type InitError = ();
+    type Service = CloneableService<FramedAppService<T, S>>;
+    type Future = CreateService<T, S>;
+
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
+        CreateService {
+            fut: self
+                .services
+                .iter()
+                .map(|(path, service)| {
+                    CreateServiceItem::Future(
+                        Some(path.clone()),
+                        service.new_service(&()),
+                    )
+                })
+                .collect(),
+            state: self.state.clone(),
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct CreateService<T, S> {
+    fut: Vec<CreateServiceItem<T, S>>,
+    state: State<S>,
+}
+
+enum CreateServiceItem<T, S> {
+    Future(
+        Option<String>,
+        Box<Future<Item = BoxedHttpService<FramedRequest<T, S>>, Error = ()>>,
+    ),
+    Service(String, BoxedHttpService<FramedRequest<T, S>>),
+}
+
+impl<S: 'static, T: 'static> Future for CreateService<T, S>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    type Item = CloneableService<FramedAppService<T, S>>;
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let mut done = true;
+
+        // poll http services
+        for item in &mut self.fut {
+            let res = match item {
+                CreateServiceItem::Future(ref mut path, ref mut fut) => {
+                    match fut.poll()? {
+                        Async::Ready(service) => Some((path.take().unwrap(), service)),
+                        Async::NotReady => {
+                            done = false;
+                            None
+                        }
+                    }
+                }
+                CreateServiceItem::Service(_, _) => continue,
+            };
+
+            if let Some((path, service)) = res {
+                *item = CreateServiceItem::Service(path, service);
+            }
+        }
+
+        if done {
+            let router = self
+                .fut
+                .drain(..)
+                .fold(Router::build(), |mut router, item| {
+                    match item {
+                        CreateServiceItem::Service(path, service) => {
+                            router.path(&path, service);
+                        }
+                        CreateServiceItem::Future(_, _) => unreachable!(),
+                    }
+                    router
+                });
+            Ok(Async::Ready(CloneableService::new(FramedAppService {
+                router: router.finish(),
+                state: self.state.clone(),
+            })))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}
+
+pub struct FramedAppService<T, S> {
+    state: State<S>,
+    router: Router<BoxedHttpService<FramedRequest<T, S>>>,
+}
+
+impl<S: 'static, T: 'static> Service for FramedAppService<T, S>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    type Request = (Request, Framed<T, Codec>);
+    type Response = ();
+    type Error = Error;
+    type Future = BoxedResponse;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
+        let mut path = Path::new(Url::new(req.uri().clone()));
+
+        if let Some((srv, _info)) = self.router.recognize_mut(&mut path) {
+            return srv.call(FramedRequest::new(req, framed, path, self.state.clone()));
+        }
+        Box::new(
+            SendResponse::new(framed, Response::NotFound().finish()).then(|_| Ok(())),
+        )
+    }
+}
--- a/actix-framed/src/helpers.rs
+++ b/actix-framed/src/helpers.rs
@ -0,0 +1,90 @@
+use actix_http::Error;
+use actix_service::{NewService, Service};
+use futures::{Future, Poll};
+
+pub(crate) type BoxedHttpService<Req> = Box<
+    Service<
+        Request = Req,
+        Response = (),
+        Error = Error,
+        Future = Box<Future<Item = (), Error = Error>>,
+    >,
+>;
+
+pub(crate) type BoxedHttpNewService<Req> = Box<
+    NewService<
+        Config = (),
+        Request = Req,
+        Response = (),
+        Error = Error,
+        InitError = (),
+        Service = BoxedHttpService<Req>,
+        Future = Box<Future<Item = BoxedHttpService<Req>, Error = ()>>,
+    >,
+>;
+
+pub(crate) struct HttpNewService<T: NewService>(T);
+
+impl<T> HttpNewService<T>
+where
+    T: NewService<Response = (), Error = Error>,
+    T::Response: 'static,
+    T::Future: 'static,
+    T::Service: Service<Future = Box<Future<Item = (), Error = Error>>> + 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    pub fn new(service: T) -> Self {
+        HttpNewService(service)
+    }
+}
+
+impl<T> NewService for HttpNewService<T>
+where
+    T: NewService<Config = (), Response = (), Error = Error>,
+    T::Request: 'static,
+    T::Future: 'static,
+    T::Service: Service<Future = Box<Future<Item = (), Error = Error>>> + 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    type Config = ();
+    type Request = T::Request;
+    type Response = ();
+    type Error = Error;
+    type InitError = ();
+    type Service = BoxedHttpService<T::Request>;
+    type Future = Box<Future<Item = Self::Service, Error = ()>>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        Box::new(self.0.new_service(&()).map_err(|_| ()).and_then(|service| {
+            let service: BoxedHttpService<_> = Box::new(HttpServiceWrapper { service });
+            Ok(service)
+        }))
+    }
+}
+
+struct HttpServiceWrapper<T: Service> {
+    service: T,
+}
+
+impl<T> Service for HttpServiceWrapper<T>
+where
+    T: Service<
+        Response = (),
+        Future = Box<Future<Item = (), Error = Error>>,
+        Error = Error,
+    >,
+    T::Request: 'static,
+{
+    type Request = T::Request;
+    type Response = ();
+    type Error = Error;
+    type Future = Box<Future<Item = (), Error = Error>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.service.poll_ready()
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        self.service.call(req)
+    }
+}
--- a/actix-framed/src/lib.rs
+++ b/actix-framed/src/lib.rs
@ -0,0 +1,16 @@
+mod app;
+mod helpers;
+mod request;
+mod route;
+mod service;
+mod state;
+pub mod test;
+
+// re-export for convinience
+pub use actix_http::{http, Error, HttpMessage, Response, ResponseError};
+
+pub use self::app::{FramedApp, FramedAppService};
+pub use self::request::FramedRequest;
+pub use self::route::FramedRoute;
+pub use self::service::{SendError, VerifyWebSockets};
+pub use self::state::State;
--- a/actix-framed/src/request.rs
+++ b/actix-framed/src/request.rs
@ -0,0 +1,170 @@
+use std::cell::{Ref, RefMut};
+
+use actix_codec::Framed;
+use actix_http::http::{HeaderMap, Method, Uri, Version};
+use actix_http::{h1::Codec, Extensions, Request, RequestHead};
+use actix_router::{Path, Url};
+
+use crate::state::State;
+
+pub struct FramedRequest<Io, S = ()> {
+    req: Request,
+    framed: Framed<Io, Codec>,
+    state: State<S>,
+    pub(crate) path: Path<Url>,
+}
+
+impl<Io, S> FramedRequest<Io, S> {
+    pub fn new(
+        req: Request,
+        framed: Framed<Io, Codec>,
+        path: Path<Url>,
+        state: State<S>,
+    ) -> Self {
+        Self {
+            req,
+            framed,
+            state,
+            path,
+        }
+    }
+}
+
+impl<Io, S> FramedRequest<Io, S> {
+    /// Split request into a parts
+    pub fn into_parts(self) -> (Request, Framed<Io, Codec>, State<S>) {
+        (self.req, self.framed, self.state)
+    }
+
+    /// This method returns reference to the request head
+    #[inline]
+    pub fn head(&self) -> &RequestHead {
+        self.req.head()
+    }
+
+    /// This method returns muttable reference to the request head.
+    /// panics if multiple references of http request exists.
+    #[inline]
+    pub fn head_mut(&mut self) -> &mut RequestHead {
+        self.req.head_mut()
+    }
+
+    /// Shared application state
+    #[inline]
+    pub fn state(&self) -> &S {
+        self.state.get_ref()
+    }
+
+    /// Request's uri.
+    #[inline]
+    pub fn uri(&self) -> &Uri {
+        &self.head().uri
+    }
+
+    /// Read the Request method.
+    #[inline]
+    pub fn method(&self) -> &Method {
+        &self.head().method
+    }
+
+    /// Read the Request Version.
+    #[inline]
+    pub fn version(&self) -> Version {
+        self.head().version
+    }
+
+    #[inline]
+    /// Returns request's headers.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.head().headers
+    }
+
+    /// The target path of this Request.
+    #[inline]
+    pub fn path(&self) -> &str {
+        self.head().uri.path()
+    }
+
+    /// The query string in the URL.
+    ///
+    /// E.g., id=10
+    #[inline]
+    pub fn query_string(&self) -> &str {
+        if let Some(query) = self.uri().query().as_ref() {
+            query
+        } else {
+            ""
+        }
+    }
+
+    /// Get a reference to the Path parameters.
+    ///
+    /// Params is a container for url parameters.
+    /// A variable segment is specified in the form `{identifier}`,
+    /// where the identifier can be used later in a request handler to
+    /// access the matched value for that segment.
+    #[inline]
+    pub fn match_info(&self) -> &Path<Url> {
+        &self.path
+    }
+
+    /// Request extensions
+    #[inline]
+    pub fn extensions(&self) -> Ref<Extensions> {
+        self.head().extensions()
+    }
+
+    /// Mutable reference to a the request's extensions
+    #[inline]
+    pub fn extensions_mut(&self) -> RefMut<Extensions> {
+        self.head().extensions_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_http::http::{HeaderName, HeaderValue, HttpTryFrom};
+    use actix_http::test::{TestBuffer, TestRequest};
+
+    use super::*;
+
+    #[test]
+    fn test_reqest() {
+        let buf = TestBuffer::empty();
+        let framed = Framed::new(buf, Codec::default());
+        let req = TestRequest::with_uri("/index.html?q=1")
+            .header("content-type", "test")
+            .finish();
+        let path = Path::new(Url::new(req.uri().clone()));
+
+        let mut freq = FramedRequest::new(req, framed, path, State::new(10u8));
+        assert_eq!(*freq.state(), 10);
+        assert_eq!(freq.version(), Version::HTTP_11);
+        assert_eq!(freq.method(), Method::GET);
+        assert_eq!(freq.path(), "/index.html");
+        assert_eq!(freq.query_string(), "q=1");
+        assert_eq!(
+            freq.headers()
+                .get("content-type")
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "test"
+        );
+
+        freq.head_mut().headers.insert(
+            HeaderName::try_from("x-hdr").unwrap(),
+            HeaderValue::from_static("test"),
+        );
+        assert_eq!(
+            freq.headers().get("x-hdr").unwrap().to_str().unwrap(),
+            "test"
+        );
+
+        freq.extensions_mut().insert(100usize);
+        assert_eq!(*freq.extensions().get::<usize>().unwrap(), 100usize);
+
+        let (_, _, state) = freq.into_parts();
+        assert_eq!(*state, 10);
+    }
+}
--- a/actix-framed/src/route.rs
+++ b/actix-framed/src/route.rs
@ -0,0 +1,157 @@
+use std::fmt;
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_http::{http::Method, Error};
+use actix_service::{NewService, Service};
+use futures::future::{ok, FutureResult};
+use futures::{Async, Future, IntoFuture, Poll};
+use log::error;
+
+use crate::app::HttpServiceFactory;
+use crate::request::FramedRequest;
+
+/// Resource route definition
+///
+/// Route uses builder-like pattern for configuration.
+/// If handler is not explicitly set, default *404 Not Found* handler is used.
+pub struct FramedRoute<Io, S, F = (), R = ()> {
+    handler: F,
+    pattern: String,
+    methods: Vec<Method>,
+    state: PhantomData<(Io, S, R)>,
+}
+
+impl<Io, S> FramedRoute<Io, S> {
+    pub fn new(pattern: &str) -> Self {
+        FramedRoute {
+            handler: (),
+            pattern: pattern.to_string(),
+            methods: Vec::new(),
+            state: PhantomData,
+        }
+    }
+
+    pub fn get(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::GET)
+    }
+
+    pub fn post(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::POST)
+    }
+
+    pub fn put(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::PUT)
+    }
+
+    pub fn delete(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::DELETE)
+    }
+
+    pub fn method(mut self, method: Method) -> Self {
+        self.methods.push(method);
+        self
+    }
+
+    pub fn to<F, R>(self, handler: F) -> FramedRoute<Io, S, F, R>
+    where
+        F: FnMut(FramedRequest<Io, S>) -> R,
+        R: IntoFuture<Item = ()>,
+        R::Future: 'static,
+        R::Error: fmt::Debug,
+    {
+        FramedRoute {
+            handler,
+            pattern: self.pattern,
+            methods: self.methods,
+            state: PhantomData,
+        }
+    }
+}
+
+impl<Io, S, F, R> HttpServiceFactory for FramedRoute<Io, S, F, R>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
+    R: IntoFuture<Item = ()>,
+    R::Future: 'static,
+    R::Error: fmt::Display,
+{
+    type Factory = FramedRouteFactory<Io, S, F, R>;
+
+    fn path(&self) -> &str {
+        &self.pattern
+    }
+
+    fn create(self) -> Self::Factory {
+        FramedRouteFactory {
+            handler: self.handler,
+            methods: self.methods,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct FramedRouteFactory<Io, S, F, R> {
+    handler: F,
+    methods: Vec<Method>,
+    _t: PhantomData<(Io, S, R)>,
+}
+
+impl<Io, S, F, R> NewService for FramedRouteFactory<Io, S, F, R>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
+    R: IntoFuture<Item = ()>,
+    R::Future: 'static,
+    R::Error: fmt::Display,
+{
+    type Config = ();
+    type Request = FramedRequest<Io, S>;
+    type Response = ();
+    type Error = Error;
+    type InitError = ();
+    type Service = FramedRouteService<Io, S, F, R>;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(FramedRouteService {
+            handler: self.handler.clone(),
+            methods: self.methods.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct FramedRouteService<Io, S, F, R> {
+    handler: F,
+    methods: Vec<Method>,
+    _t: PhantomData<(Io, S, R)>,
+}
+
+impl<Io, S, F, R> Service for FramedRouteService<Io, S, F, R>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
+    R: IntoFuture<Item = ()>,
+    R::Future: 'static,
+    R::Error: fmt::Display,
+{
+    type Request = FramedRequest<Io, S>;
+    type Response = ();
+    type Error = Error;
+    type Future = Box<Future<Item = (), Error = Error>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: FramedRequest<Io, S>) -> Self::Future {
+        Box::new((self.handler)(req).into_future().then(|res| {
+            if let Err(e) = res {
+                error!("Error in request handler: {}", e);
+            }
+            Ok(())
+        }))
+    }
+}
--- a/actix-framed/src/service.rs
+++ b/actix-framed/src/service.rs
@ -0,0 +1,149 @@
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use actix_http::body::BodySize;
+use actix_http::error::ResponseError;
+use actix_http::h1::{Codec, Message};
+use actix_http::ws::{verify_handshake, HandshakeError};
+use actix_http::{Request, Response};
+use actix_service::{NewService, Service};
+use futures::future::{ok, Either, FutureResult};
+use futures::{Async, Future, IntoFuture, Poll, Sink};
+
+/// Service that verifies incoming request if it is valid websocket
+/// upgrade request. In case of error returns `HandshakeError`
+pub struct VerifyWebSockets<T, C> {
+    _t: PhantomData<(T, C)>,
+}
+
+impl<T, C> Default for VerifyWebSockets<T, C> {
+    fn default() -> Self {
+        VerifyWebSockets { _t: PhantomData }
+    }
+}
+
+impl<T, C> NewService for VerifyWebSockets<T, C> {
+    type Config = C;
+    type Request = (Request, Framed<T, Codec>);
+    type Response = (Request, Framed<T, Codec>);
+    type Error = (HandshakeError, Framed<T, Codec>);
+    type InitError = ();
+    type Service = VerifyWebSockets<T, C>;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &C) -> Self::Future {
+        ok(VerifyWebSockets { _t: PhantomData })
+    }
+}
+
+impl<T, C> Service for VerifyWebSockets<T, C> {
+    type Request = (Request, Framed<T, Codec>);
+    type Response = (Request, Framed<T, Codec>);
+    type Error = (HandshakeError, Framed<T, Codec>);
+    type Future = FutureResult<Self::Response, Self::Error>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
+        match verify_handshake(req.head()) {
+            Err(e) => Err((e, framed)).into_future(),
+            Ok(_) => Ok((req, framed)).into_future(),
+        }
+    }
+}
+
+/// Send http/1 error response
+pub struct SendError<T, R, E, C>(PhantomData<(T, R, E, C)>);
+
+impl<T, R, E, C> Default for SendError<T, R, E, C>
+where
+    T: AsyncRead + AsyncWrite,
+    E: ResponseError,
+{
+    fn default() -> Self {
+        SendError(PhantomData)
+    }
+}
+
+impl<T, R, E, C> NewService for SendError<T, R, E, C>
+where
+    T: AsyncRead + AsyncWrite + 'static,
+    R: 'static,
+    E: ResponseError + 'static,
+{
+    type Config = C;
+    type Request = Result<R, (E, Framed<T, Codec>)>;
+    type Response = R;
+    type Error = (E, Framed<T, Codec>);
+    type InitError = ();
+    type Service = SendError<T, R, E, C>;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &C) -> Self::Future {
+        ok(SendError(PhantomData))
+    }
+}
+
+impl<T, R, E, C> Service for SendError<T, R, E, C>
+where
+    T: AsyncRead + AsyncWrite + 'static,
+    R: 'static,
+    E: ResponseError + 'static,
+{
+    type Request = Result<R, (E, Framed<T, Codec>)>;
+    type Response = R;
+    type Error = (E, Framed<T, Codec>);
+    type Future = Either<FutureResult<R, (E, Framed<T, Codec>)>, SendErrorFut<T, R, E>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Result<R, (E, Framed<T, Codec>)>) -> Self::Future {
+        match req {
+            Ok(r) => Either::A(ok(r)),
+            Err((e, framed)) => {
+                let res = e.error_response().drop_body();
+                Either::B(SendErrorFut {
+                    framed: Some(framed),
+                    res: Some((res, BodySize::Empty).into()),
+                    err: Some(e),
+                    _t: PhantomData,
+                })
+            }
+        }
+    }
+}
+
+pub struct SendErrorFut<T, R, E> {
+    res: Option<Message<(Response<()>, BodySize)>>,
+    framed: Option<Framed<T, Codec>>,
+    err: Option<E>,
+    _t: PhantomData<R>,
+}
+
+impl<T, R, E> Future for SendErrorFut<T, R, E>
+where
+    E: ResponseError,
+    T: AsyncRead + AsyncWrite,
+{
+    type Item = R;
+    type Error = (E, Framed<T, Codec>);
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(res) = self.res.take() {
+            if self.framed.as_mut().unwrap().force_send(res).is_err() {
+                return Err((self.err.take().unwrap(), self.framed.take().unwrap()));
+            }
+        }
+        match self.framed.as_mut().unwrap().poll_complete() {
+            Ok(Async::Ready(_)) => {
+                Err((self.err.take().unwrap(), self.framed.take().unwrap()))
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Err(_) => Err((self.err.take().unwrap(), self.framed.take().unwrap())),
+        }
+    }
+}
--- a/actix-framed/src/state.rs
+++ b/actix-framed/src/state.rs
@ -0,0 +1,29 @@
+use std::ops::Deref;
+use std::sync::Arc;
+
+/// Application state
+pub struct State<S>(Arc<S>);
+
+impl<S> State<S> {
+    pub fn new(state: S) -> State<S> {
+        State(Arc::new(state))
+    }
+
+    pub fn get_ref(&self) -> &S {
+        self.0.as_ref()
+    }
+}
+
+impl<S> Deref for State<S> {
+    type Target = S;
+
+    fn deref(&self) -> &S {
+        self.0.as_ref()
+    }
+}
+
+impl<S> Clone for State<S> {
+    fn clone(&self) -> State<S> {
+        State(self.0.clone())
+    }
+}
--- a/actix-framed/src/test.rs
+++ b/actix-framed/src/test.rs
@ -0,0 +1,153 @@
+//! Various helpers for Actix applications to use during testing.
+use actix_codec::Framed;
+use actix_http::h1::Codec;
+use actix_http::http::header::{Header, HeaderName, IntoHeaderValue};
+use actix_http::http::{HttpTryFrom, Method, Uri, Version};
+use actix_http::test::{TestBuffer, TestRequest as HttpTestRequest};
+use actix_router::{Path, Url};
+use actix_rt::Runtime;
+use futures::IntoFuture;
+
+use crate::{FramedRequest, State};
+
+/// Test `Request` builder.
+pub struct TestRequest<S = ()> {
+    req: HttpTestRequest,
+    path: Path<Url>,
+    state: State<S>,
+}
+
+impl Default for TestRequest<()> {
+    fn default() -> TestRequest {
+        TestRequest {
+            req: HttpTestRequest::default(),
+            path: Path::new(Url::new(Uri::default())),
+            state: State::new(()),
+        }
+    }
+}
+
+impl TestRequest<()> {
+    /// Create TestRequest and set request uri
+    pub fn with_uri(path: &str) -> Self {
+        Self::get().uri(path)
+    }
+
+    /// Create TestRequest and set header
+    pub fn with_hdr<H: Header>(hdr: H) -> Self {
+        Self::default().set(hdr)
+    }
+
+    /// Create TestRequest and set header
+    pub fn with_header<K, V>(key: K, value: V) -> Self
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        Self::default().header(key, value)
+    }
+
+    /// Create TestRequest and set method to `Method::GET`
+    pub fn get() -> Self {
+        Self::default().method(Method::GET)
+    }
+
+    /// Create TestRequest and set method to `Method::POST`
+    pub fn post() -> Self {
+        Self::default().method(Method::POST)
+    }
+}
+
+impl<S> TestRequest<S> {
+    /// Create TestRequest and set request uri
+    pub fn with_state(state: S) -> TestRequest<S> {
+        let req = TestRequest::get();
+        TestRequest {
+            state: State::new(state),
+            req: req.req,
+            path: req.path,
+        }
+    }
+
+    /// Set HTTP version of this request
+    pub fn version(mut self, ver: Version) -> Self {
+        self.req.version(ver);
+        self
+    }
+
+    /// Set HTTP method of this request
+    pub fn method(mut self, meth: Method) -> Self {
+        self.req.method(meth);
+        self
+    }
+
+    /// Set HTTP Uri of this request
+    pub fn uri(mut self, path: &str) -> Self {
+        self.req.uri(path);
+        self
+    }
+
+    /// Set a header
+    pub fn set<H: Header>(mut self, hdr: H) -> Self {
+        self.req.set(hdr);
+        self
+    }
+
+    /// Set a header
+    pub fn header<K, V>(mut self, key: K, value: V) -> Self
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        self.req.header(key, value);
+        self
+    }
+
+    /// Set request path pattern parameter
+    pub fn param(mut self, name: &'static str, value: &'static str) -> Self {
+        self.path.add_static(name, value);
+        self
+    }
+
+    /// Complete request creation and generate `Request` instance
+    pub fn finish(mut self) -> FramedRequest<TestBuffer, S> {
+        let req = self.req.finish();
+        self.path.get_mut().update(req.uri());
+        let framed = Framed::new(TestBuffer::empty(), Codec::default());
+        FramedRequest::new(req, framed, self.path, self.state)
+    }
+
+    /// This method generates `FramedRequest` instance and executes async handler
+    pub fn run<F, R, I, E>(self, f: F) -> Result<I, E>
+    where
+        F: FnOnce(FramedRequest<TestBuffer, S>) -> R,
+        R: IntoFuture<Item = I, Error = E>,
+    {
+        let mut rt = Runtime::new().unwrap();
+        rt.block_on(f(self.finish()).into_future())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test() {
+        let req = TestRequest::with_uri("/index.html")
+            .header("x-test", "test")
+            .param("test", "123")
+            .finish();
+
+        assert_eq!(*req.state(), ());
+        assert_eq!(req.version(), Version::HTTP_11);
+        assert_eq!(req.method(), Method::GET);
+        assert_eq!(req.path(), "/index.html");
+        assert_eq!(req.query_string(), "");
+        assert_eq!(
+            req.headers().get("x-test").unwrap().to_str().unwrap(),
+            "test"
+        );
+        assert_eq!(&req.match_info()["test"], "123");
+    }
+}
--- a/actix-framed/tests/test_server.rs
+++ b/actix-framed/tests/test_server.rs
@ -0,0 +1,141 @@
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_http::{body, http::StatusCode, ws, Error, HttpService, Response};
+use actix_http_test::TestServer;
+use actix_service::{IntoNewService, NewService};
+use actix_utils::framed::FramedTransport;
+use bytes::{Bytes, BytesMut};
+use futures::future::{self, ok};
+use futures::{Future, Sink, Stream};
+
+use actix_framed::{FramedApp, FramedRequest, FramedRoute, SendError, VerifyWebSockets};
+
+fn ws_service<T: AsyncRead + AsyncWrite>(
+    req: FramedRequest<T>,
+) -> impl Future<Item = (), Error = Error> {
+    let (req, framed, _) = req.into_parts();
+    let res = ws::handshake(req.head()).unwrap().message_body(());
+
+    framed
+        .send((res, body::BodySize::None).into())
+        .map_err(|_| panic!())
+        .and_then(|framed| {
+            FramedTransport::new(framed.into_framed(ws::Codec::new()), service)
+                .map_err(|_| panic!())
+        })
+}
+
+fn service(msg: ws::Frame) -> impl Future<Item = ws::Message, Error = Error> {
+    let msg = match msg {
+        ws::Frame::Ping(msg) => ws::Message::Pong(msg),
+        ws::Frame::Text(text) => {
+            ws::Message::Text(String::from_utf8_lossy(&text.unwrap()).to_string())
+        }
+        ws::Frame::Binary(bin) => ws::Message::Binary(bin.unwrap().freeze()),
+        ws::Frame::Close(reason) => ws::Message::Close(reason),
+        _ => panic!(),
+    };
+    ok(msg)
+}
+
+#[test]
+fn test_simple() {
+    let mut srv = TestServer::new(|| {
+        HttpService::build()
+            .upgrade(
+                FramedApp::new().service(FramedRoute::get("/index.html").to(ws_service)),
+            )
+            .finish(|_| future::ok::<_, Error>(Response::NotFound()))
+    });
+
+    assert!(srv.ws_at("/test").is_err());
+
+    // client service
+    let framed = srv.ws_at("/index.html").unwrap();
+    let framed = srv
+        .block_on(framed.send(ws::Message::Text("text".to_string())))
+        .unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(item, Some(ws::Frame::Text(Some(BytesMut::from("text")))));
+
+    let framed = srv
+        .block_on(framed.send(ws::Message::Binary("text".into())))
+        .unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(
+        item,
+        Some(ws::Frame::Binary(Some(Bytes::from_static(b"text").into())))
+    );
+
+    let framed = srv
+        .block_on(framed.send(ws::Message::Ping("text".into())))
+        .unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(item, Some(ws::Frame::Pong("text".to_string().into())));
+
+    let framed = srv
+        .block_on(framed.send(ws::Message::Close(Some(ws::CloseCode::Normal.into()))))
+        .unwrap();
+
+    let (item, _framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(
+        item,
+        Some(ws::Frame::Close(Some(ws::CloseCode::Normal.into())))
+    );
+}
+
+#[test]
+fn test_service() {
+    let mut srv = TestServer::new(|| {
+        actix_http::h1::OneRequest::new().map_err(|_| ()).and_then(
+            VerifyWebSockets::default()
+                .then(SendError::default())
+                .map_err(|_| ())
+                .and_then(
+                    FramedApp::new()
+                        .service(FramedRoute::get("/index.html").to(ws_service))
+                        .into_new_service()
+                        .map_err(|_| ()),
+                ),
+        )
+    });
+
+    // non ws request
+    let res = srv.block_on(srv.get("/index.html").send()).unwrap();
+    assert_eq!(res.status(), StatusCode::BAD_REQUEST);
+
+    // not found
+    assert!(srv.ws_at("/test").is_err());
+
+    // client service
+    let framed = srv.ws_at("/index.html").unwrap();
+    let framed = srv
+        .block_on(framed.send(ws::Message::Text("text".to_string())))
+        .unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(item, Some(ws::Frame::Text(Some(BytesMut::from("text")))));
+
+    let framed = srv
+        .block_on(framed.send(ws::Message::Binary("text".into())))
+        .unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(
+        item,
+        Some(ws::Frame::Binary(Some(Bytes::from_static(b"text").into())))
+    );
+
+    let framed = srv
+        .block_on(framed.send(ws::Message::Ping("text".into())))
+        .unwrap();
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(item, Some(ws::Frame::Pong("text".to_string().into())));
+
+    let framed = srv
+        .block_on(framed.send(ws::Message::Close(Some(ws::CloseCode::Normal.into()))))
+        .unwrap();
+
+    let (item, _framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(
+        item,
+        Some(ws::Frame::Close(Some(ws::CloseCode::Normal.into())))
+    );
+}
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@ -1,5 +1,185 @@
 # Changes

+## [0.2.5] - 2019-06-28
+
+### Added
+
+* Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
+
+### Changed
+
+* Use `encoding_rs` crate instead of unmaintained `encoding` crate
+
+* Add `Copy` and `Clone` impls for `ws::Codec`
+
+
+## [0.2.4] - 2019-06-16
+
+### Fixed
+
+* Do not compress NoContent (204) responses #918
+
+
+## [0.2.3] - 2019-06-02
+
+### Added
+
+* Debug impl for ResponseBuilder
+
+* From SizedStream and BodyStream for Body
+
+### Changed
+
+* SizedStream uses u64
+
+
+## [0.2.2] - 2019-05-29
+
+### Fixed
+
+* Parse incoming stream before closing stream on disconnect #868
+
+
+## [0.2.1] - 2019-05-25
+
+### Fixed
+
+* Handle socket read disconnect
+
+
+## [0.2.0] - 2019-05-12
+
+### Changed
+
+* Update actix-service to 0.4
+
+* Expect and upgrade services accept `ServerConfig` config.
+
+### Deleted
+
+* `OneRequest` service
+
+
+## [0.1.5] - 2019-05-04
+
+### Fixed
+
+* Clean up response extensions in response pool #817
+
+
+## [0.1.4] - 2019-04-24
+
+### Added
+
+* Allow to render h1 request headers in `Camel-Case`
+
+### Fixed
+
+* Read until eof for http/1.0 responses #771
+
+
+## [0.1.3] - 2019-04-23
+
+### Fixed
+
+* Fix http client pool management
+
+* Fix http client wait queue management #794
+
+
+## [0.1.2] - 2019-04-23
+
+### Fixed
+
+* Fix BorrowMutError panic in client connector #793
+
+
+## [0.1.1] - 2019-04-19
+
+### Changed
+
+* Cookie::max_age() accepts value in seconds
+
+* Cookie::max_age_time() accepts value in time::Duration
+
+* Allow to specify server address for client connector
+
+
+## [0.1.0] - 2019-04-16
+
+### Added
+
+* Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
+
+### Changed
+
+* `actix_http::encoding` always available
+
+* use trust-dns-resolver 0.11.0
+
+
+## [0.1.0-alpha.5] - 2019-04-12
+
+### Added
+
+* Allow to use custom service for upgrade requests
+
+* Added `h1::SendResponse` future.
+
+### Changed
+
+* MessageBody::length() renamed to MessageBody::size() for consistency
+
+* ws handshake verification functions take RequestHead instead of Request
+
+
+## [0.1.0-alpha.4] - 2019-04-08
+
+### Added
+
+* Allow to use custom `Expect` handler
+
+* Add minimal `std::error::Error` impl for `Error`
+
+### Changed
+
+* Export IntoHeaderValue
+
+* Render error and return as response body
+
+* Use thread pool for response body comression
+
+### Deleted
+
+* Removed PayloadBuffer
+
+
+## [0.1.0-alpha.3] - 2019-04-02
+
+### Added
+
+* Warn when an unsealed private cookie isn't valid UTF-8
+
+### Fixed
+
+* Rust 1.31.0 compatibility
+
+* Preallocate read buffer for h1 codec
+
+* Detect socket disconnection during protocol selection
+
+
+## [0.1.0-alpha.2] - 2019-03-29
+
+### Added
+
+* Added ws::Message::Nop, no-op websockets message
+
+### Changed
+
+* Do not use thread pool for decomression if chunk size is smaller than 2048.
+
+
 ## [0.1.0-alpha.1] - 2019-03-28

 * Initial impl
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@ -1,12 +1,12 @@
 [package]
 name = "actix-http"
-version = "0.1.0-alpha.1"
+version = "0.2.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http primitives"
 readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "futures"]
 homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-http.git"
+repository = "https://github.com/actix/actix-web.git"
 documentation = "https://docs.rs/actix-http/"
 categories = ["network-programming", "asynchronous",
              "web-programming::http-server",
@ -16,11 +16,7 @@ edition = "2018"
 workspace = ".."

 [package.metadata.docs.rs]
-features = ["ssl", "fail", "cookie", "brotli", "flate2-zlib"]
-
-[badges]
-travis-ci = { repository = "actix/actix-web", branch = "master" }
-codecov = { repository = "actix/actix-web", branch = "master", service = "github" }
+features = ["ssl", "fail", "brotli", "flate2-zlib", "secure-cookies"]

 [lib]
 name = "actix_http"
@ -32,9 +28,6 @@ default = []
 # openssl
 ssl = ["openssl", "actix-connect/ssl"]

-# cookies integration
-cookies = ["cookie"]
-
 # brotli encoding, requires c compiler
 brotli = ["brotli2"]

@ -47,24 +40,29 @@ flate2-rust = ["flate2/rust_backend"]
 # failure integration. actix does not use failure anymore
 fail = ["failure"]

+# support for secure cookies
+secure-cookies = ["ring"]
+
 [dependencies]
-actix-service = "0.3.4"
+actix-service = "0.4.1"
 actix-codec = "0.1.2"
-actix-connect = "0.1.0"
-actix-utils = "0.3.4"
-actix-server-config = "0.1.0"
+actix-connect = "0.2.0"
+actix-utils = "0.4.2"
+actix-server-config = "0.1.1"
 actix-threadpool = "0.1.0"

 base64 = "0.10"
 bitflags = "1.0"
 bytes = "0.4"
 byteorder = "1.2"
-derive_more = "0.14"
-encoding = "0.2"
-futures = "0.1"
-hashbrown = "0.1.8"
+copyless = "0.1.2"
+derive_more = "0.15.0"
+either = "1.5.2"
+encoding_rs = "0.8"
+futures = "0.1.25"
+hashbrown = "0.5.0"
 h2 = "0.1.16"
-http = "0.1.16"
+http = "0.1.17"
 httparse = "1.3"
 indexmap = "1.0"
 lazy_static = "1.0"
@ -78,29 +76,31 @@ serde = "1.0"
 serde_json = "1.0"
 sha1 = "0.6"
 slab = "0.4"
-serde_urlencoded = "0.5.3"
-time = "0.1"
+serde_urlencoded = "0.5.5"
+time = "0.1.42"
 tokio-tcp = "0.1.3"
-tokio-timer = "0.2"
+tokio-timer = "0.2.8"
 tokio-current-thread = "0.1"
-trust-dns-resolver = { version="0.11.0-alpha.2", default-features = false }
+trust-dns-resolver = { version="0.11.1", default-features = false }
+
+# for secure cookie
+ring = { version = "0.14.6", optional = true }

 # compression
-brotli2 = { version="^0.3.2", optional = true }
-flate2 = { version="^1.0.2", optional = true, default-features = false }
+brotli2 = { version="0.3.2", optional = true }
+flate2 = { version="1.0.7", optional = true, default-features = false }

 # optional deps
-cookie = { version="0.11", features=["percent-encode"], optional = true }
 failure = { version = "0.1.5", optional = true }
 openssl = { version="0.10", optional = true }
+chrono = "0.4.6"

 [dev-dependencies]
 actix-rt = "0.2.2"
-actix-server = { version = "0.4.0", features=["ssl"] }
-actix-connect = { version = "0.1.0", features=["ssl"] }
-actix-http-test = { path="../test-server", features=["ssl"] }
-
+actix-server = { version = "0.5.0", features=["ssl"] }
+actix-connect = { version = "0.2.0", features=["ssl"] }
+actix-http-test = { version = "0.2.0", features=["ssl"] }
 env_logger = "0.6"
 serde_derive = "1.0"
 openssl = { version="0.10" }
-tokio-tcp = "0.1"
+tokio-tcp = "0.1"
--- a/actix-http/README.md
+++ b/actix-http/README.md
@ -1,4 +1,4 @@
-# Actix http [![Build Status](https://travis-ci.org/actix/actix-http.svg?branch=master)](https://travis-ci.org/actix/actix-http)  [![codecov](https://codecov.io/gh/actix/actix-http/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-http) [![crates.io](https://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 http [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web)  [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-http)](https://crates.io/crates/actix-http) [![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 http

@ -8,7 +8,7 @@ Actix http
 * [API Documentation](https://docs.rs/actix-http/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-http](https://crates.io/crates/actix-http)
-* Minimum supported Rust version: 1.26 or later
+* Minimum supported Rust version: 1.31 or later

 ## Example

--- a/actix-http/examples/framed_hello.rs
+++ b/actix-http/examples/framed_hello.rs
@ -1,28 +0,0 @@
-use std::{env, io};
-
-use actix_codec::Framed;
-use actix_http::{h1, Response, SendResponse, ServiceConfig};
-use actix_server::{Io, Server};
-use actix_service::{fn_service, NewService};
-use actix_utils::framed::IntoFramed;
-use actix_utils::stream::TakeItem;
-use futures::Future;
-use tokio_tcp::TcpStream;
-
-fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "framed_hello=info");
-    env_logger::init();
-
-    Server::build()
-        .bind("framed_hello", "127.0.0.1:8080", || {
-            fn_service(|io: Io<TcpStream>| Ok(io.into_parts().0))
-                .and_then(IntoFramed::new(|| h1::Codec::new(ServiceConfig::default())))
-                .and_then(TakeItem::new().map_err(|_| ()))
-                .and_then(|(_req, _framed): (_, Framed<_, _>)| {
-                    SendResponse::send(_framed, Response::Ok().body("Hello world!"))
-                        .map_err(|_| ())
-                        .map(|_| ())
-                })
-        })?
-        .run()
-}
--- a/actix-http/src/body.rs
+++ b/actix-http/src/body.rs
@ -30,13 +30,13 @@ impl BodySize {

 /// Type that provides this trait can be streamed to a peer.
 pub trait MessageBody {
-    fn length(&self) -> BodySize;
+    fn size(&self) -> BodySize;

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error>;
 }

 impl MessageBody for () {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Empty
    }

@ -46,8 +46,8 @@ impl MessageBody for () {
 }

 impl<T: MessageBody> MessageBody for Box<T> {
-    fn length(&self) -> BodySize {
-        self.as_ref().length()
+    fn size(&self) -> BodySize {
+        self.as_ref().size()
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
@ -86,10 +86,10 @@ impl<B: MessageBody> ResponseBody<B> {
 }

 impl<B: MessageBody> MessageBody for ResponseBody<B> {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        match self {
-            ResponseBody::Body(ref body) => body.length(),
-            ResponseBody::Other(ref body) => body.length(),
+            ResponseBody::Body(ref body) => body.size(),
+            ResponseBody::Other(ref body) => body.size(),
        }
    }

@ -135,12 +135,12 @@ impl Body {
 }

 impl MessageBody for Body {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        match self {
            Body::None => BodySize::None,
            Body::Empty => BodySize::Empty,
            Body::Bytes(ref bin) => BodySize::Sized(bin.len()),
-            Body::Message(ref body) => body.length(),
+            Body::Message(ref body) => body.size(),
        }
    }

@ -153,7 +153,7 @@ impl MessageBody for Body {
                if len == 0 {
                    Ok(Async::Ready(None))
                } else {
-                    Ok(Async::Ready(Some(bin.split_to(len))))
+                    Ok(Async::Ready(Some(mem::replace(bin, Bytes::new()))))
                }
            }
            Body::Message(ref mut body) => body.poll_next(),
@ -185,7 +185,7 @@ impl fmt::Debug for Body {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Body::None => write!(f, "Body::None"),
-            Body::Empty => write!(f, "Body::Zero"),
+            Body::Empty => write!(f, "Body::Empty"),
            Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
            Body::Message(_) => write!(f, "Body::Message(_)"),
        }
@ -234,8 +234,27 @@ impl From<BytesMut> for Body {
    }
 }

+impl<S> From<SizedStream<S>> for Body
+where
+    S: Stream<Item = Bytes, Error = Error> + 'static,
+{
+    fn from(s: SizedStream<S>) -> Body {
+        Body::from_message(s)
+    }
+}
+
+impl<S, E> From<BodyStream<S, E>> for Body
+where
+    S: Stream<Item = Bytes, Error = E> + 'static,
+    E: Into<Error> + 'static,
+{
+    fn from(s: BodyStream<S, E>) -> Body {
+        Body::from_message(s)
+    }
+}
+
 impl MessageBody for Bytes {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Sized(self.len())
    }

@ -249,7 +268,7 @@ impl MessageBody for Bytes {
 }

 impl MessageBody for BytesMut {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Sized(self.len())
    }

@ -265,7 +284,7 @@ impl MessageBody for BytesMut {
 }

 impl MessageBody for &'static str {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Sized(self.len())
    }

@ -281,7 +300,7 @@ impl MessageBody for &'static str {
 }

 impl MessageBody for &'static [u8] {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Sized(self.len())
    }

@ -297,7 +316,7 @@ impl MessageBody for &'static [u8] {
 }

 impl MessageBody for Vec<u8> {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Sized(self.len())
    }

@ -314,7 +333,7 @@ impl MessageBody for Vec<u8> {
 }

 impl MessageBody for String {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Sized(self.len())
    }

@ -354,19 +373,19 @@ where
    S: Stream<Item = Bytes, Error = E>,
    E: Into<Error>,
 {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        BodySize::Stream
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        self.stream.poll().map_err(|e| e.into())
+        self.stream.poll().map_err(std::convert::Into::into)
    }
 }

 /// Type represent streaming body. This body implementation should be used
 /// if total size of stream is known. Data get sent as is without using transfer encoding.
 pub struct SizedStream<S> {
-    size: usize,
+    size: u64,
    stream: S,
 }

@ -374,7 +393,7 @@ impl<S> SizedStream<S>
 where
    S: Stream<Item = Bytes, Error = Error>,
 {
-    pub fn new(size: usize, stream: S) -> Self {
+    pub fn new(size: u64, stream: S) -> Self {
        SizedStream { size, stream }
    }
 }
@ -383,8 +402,8 @@ impl<S> MessageBody for SizedStream<S>
 where
    S: Stream<Item = Bytes, Error = Error>,
 {
-    fn length(&self) -> BodySize {
-        BodySize::Sized(self.size)
+    fn size(&self) -> BodySize {
+        BodySize::Sized64(self.size)
    }

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
@ -416,47 +435,117 @@ mod tests {

    #[test]
    fn test_static_str() {
-        assert_eq!(Body::from("").length(), BodySize::Sized(0));
-        assert_eq!(Body::from("test").length(), BodySize::Sized(4));
+        assert_eq!(Body::from("").size(), BodySize::Sized(0));
+        assert_eq!(Body::from("test").size(), BodySize::Sized(4));
        assert_eq!(Body::from("test").get_ref(), b"test");
+
+        assert_eq!("test".size(), BodySize::Sized(4));
+        assert_eq!(
+            "test".poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
+        );
    }

    #[test]
    fn test_static_bytes() {
-        assert_eq!(Body::from(b"test".as_ref()).length(), BodySize::Sized(4));
+        assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
        assert_eq!(
-            Body::from_slice(b"test".as_ref()).length(),
+            Body::from_slice(b"test".as_ref()).size(),
            BodySize::Sized(4)
        );
        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
+
+        assert_eq!((&b"test"[..]).size(), BodySize::Sized(4));
+        assert_eq!(
+            (&b"test"[..]).poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
+        );
    }

    #[test]
    fn test_vec() {
-        assert_eq!(Body::from(Vec::from("test")).length(), BodySize::Sized(4));
+        assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
        assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
+
+        assert_eq!(Vec::from("test").size(), BodySize::Sized(4));
+        assert_eq!(
+            Vec::from("test").poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
+        );
    }

    #[test]
    fn test_bytes() {
-        assert_eq!(Body::from(Bytes::from("test")).length(), BodySize::Sized(4));
-        assert_eq!(Body::from(Bytes::from("test")).get_ref(), b"test");
-    }
-
-    #[test]
-    fn test_string() {
-        let b = "test".to_owned();
-        assert_eq!(Body::from(b.clone()).length(), BodySize::Sized(4));
+        let mut b = Bytes::from("test");
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        assert_eq!(Body::from(&b).length(), BodySize::Sized(4));
-        assert_eq!(Body::from(&b).get_ref(), b"test");
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            b.poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
+        );
    }

    #[test]
    fn test_bytes_mut() {
-        let b = BytesMut::from("test");
-        assert_eq!(Body::from(b.clone()).length(), BodySize::Sized(4));
-        assert_eq!(Body::from(b).get_ref(), b"test");
+        let mut b = BytesMut::from("test");
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            b.poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
+        );
+    }
+
+    #[test]
+    fn test_string() {
+        let mut b = "test".to_owned();
+        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
+        assert_eq!(Body::from(&b).get_ref(), b"test");
+
+        assert_eq!(b.size(), BodySize::Sized(4));
+        assert_eq!(
+            b.poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
+        );
+    }
+
+    #[test]
+    fn test_unit() {
+        assert_eq!(().size(), BodySize::Empty);
+        assert_eq!(().poll_next().unwrap(), Async::Ready(None));
+    }
+
+    #[test]
+    fn test_box() {
+        let mut val = Box::new(());
+        assert_eq!(val.size(), BodySize::Empty);
+        assert_eq!(val.poll_next().unwrap(), Async::Ready(None));
+    }
+
+    #[test]
+    fn test_body_eq() {
+        assert!(Body::None == Body::None);
+        assert!(Body::None != Body::Empty);
+        assert!(Body::Empty == Body::Empty);
+        assert!(Body::Empty != Body::None);
+        assert!(
+            Body::Bytes(Bytes::from_static(b"1"))
+                == Body::Bytes(Bytes::from_static(b"1"))
+        );
+        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
+    }
+
+    #[test]
+    fn test_body_debug() {
+        assert!(format!("{:?}", Body::None).contains("Body::None"));
+        assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
+        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains("1"));
    }
 }
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@ -1,49 +1,75 @@
-use std::fmt::Debug;
+use std::fmt;
 use std::marker::PhantomData;
+use std::rc::Rc;

+use actix_codec::Framed;
 use actix_server_config::ServerConfig as SrvConfig;
-use actix_service::{IntoNewService, NewService};
+use actix_service::{IntoNewService, NewService, Service};

 use crate::body::MessageBody;
 use crate::config::{KeepAlive, ServiceConfig};
+use crate::error::Error;
+use crate::h1::{Codec, ExpectHandler, H1Service, UpgradeHandler};
+use crate::h2::H2Service;
+use crate::helpers::{Data, DataFactory};
 use crate::request::Request;
 use crate::response::Response;
-
-use crate::h1::H1Service;
-use crate::h2::H2Service;
 use crate::service::HttpService;

 /// A http service builder
 ///
 /// This type can be used to construct an instance of `http service` through a
 /// builder-like pattern.
-pub struct HttpServiceBuilder<T, S> {
+pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
    keep_alive: KeepAlive,
    client_timeout: u64,
    client_disconnect: u64,
+    expect: X,
+    upgrade: Option<U>,
+    on_connect: Option<Rc<Fn(&T) -> Box<dyn DataFactory>>>,
    _t: PhantomData<(T, S)>,
 }

-impl<T, S> HttpServiceBuilder<T, S>
+impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>>
 where
-    S: NewService<SrvConfig, Request = Request>,
-    S::Error: Debug + 'static,
-    S::Service: 'static,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
 {
    /// Create instance of `ServiceConfigBuilder`
-    pub fn new() -> HttpServiceBuilder<T, S> {
+    pub fn new() -> Self {
        HttpServiceBuilder {
            keep_alive: KeepAlive::Timeout(5),
            client_timeout: 5000,
            client_disconnect: 0,
+            expect: ExpectHandler,
+            upgrade: None,
+            on_connect: None,
            _t: PhantomData,
        }
    }
+}

+impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
+where
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, Codec>),
+        Response = (),
+    >,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
+{
    /// Set server keep-alive setting.
    ///
    /// By default keep alive is set to a 5 seconds.
-    pub fn keep_alive<U: Into<KeepAlive>>(mut self, val: U) -> Self {
+    pub fn keep_alive<W: Into<KeepAlive>>(mut self, val: W) -> Self {
        self.keep_alive = val.into();
        self
    }
@ -75,30 +101,75 @@ where
        self
    }

-    // #[cfg(feature = "ssl")]
-    // /// Configure alpn protocols for SslAcceptorBuilder.
-    // pub fn configure_openssl(
-    //     builder: &mut openssl::ssl::SslAcceptorBuilder,
-    // ) -> io::Result<()> {
-    //     let protos: &[u8] = b"\x02h2";
-    //     builder.set_alpn_select_callback(|_, protos| {
-    //         const H2: &[u8] = b"\x02h2";
-    //         if protos.windows(3).any(|window| window == H2) {
-    //             Ok(b"h2")
-    //         } else {
-    //             Err(openssl::ssl::AlpnError::NOACK)
-    //         }
-    //     });
-    //     builder.set_alpn_protos(&protos)?;
+    /// Provide service for `EXPECT: 100-Continue` support.
+    ///
+    /// Service get called with request that contains `EXPECT` header.
+    /// Service must return request in case of success, in that case
+    /// request will be forwarded to main service.
+    pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U>
+    where
+        F: IntoNewService<X1>,
+        X1: NewService<Config = SrvConfig, Request = Request, Response = Request>,
+        X1::Error: Into<Error>,
+        X1::InitError: fmt::Debug,
+    {
+        HttpServiceBuilder {
+            keep_alive: self.keep_alive,
+            client_timeout: self.client_timeout,
+            client_disconnect: self.client_disconnect,
+            expect: expect.into_new_service(),
+            upgrade: self.upgrade,
+            on_connect: self.on_connect,
+            _t: PhantomData,
+        }
+    }

-    //     Ok(())
-    // }
+    /// Provide service for custom `Connection: UPGRADE` support.
+    ///
+    /// If service is provided then normal requests handling get halted
+    /// and this service get called with original request and framed object.
+    pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
+    where
+        F: IntoNewService<U1>,
+        U1: NewService<
+            Config = SrvConfig,
+            Request = (Request, Framed<T, Codec>),
+            Response = (),
+        >,
+        U1::Error: fmt::Display,
+        U1::InitError: fmt::Debug,
+    {
+        HttpServiceBuilder {
+            keep_alive: self.keep_alive,
+            client_timeout: self.client_timeout,
+            client_disconnect: self.client_disconnect,
+            expect: self.expect,
+            upgrade: Some(upgrade.into_new_service()),
+            on_connect: self.on_connect,
+            _t: PhantomData,
+        }
+    }
+
+    /// Set on-connect callback.
+    ///
+    /// It get called once per connection and result of the call
+    /// get stored to the request's extensions.
+    pub fn on_connect<F, I>(mut self, f: F) -> Self
+    where
+        F: Fn(&T) -> I + 'static,
+        I: Clone + 'static,
+    {
+        self.on_connect = Some(Rc::new(move |io| Box::new(Data(f(io)))));
+        self
+    }

    /// Finish service configuration and create *http service* for HTTP/1 protocol.
-    pub fn h1<F, P, B>(self, service: F) -> H1Service<T, P, S, B>
+    pub fn h1<F, P, B>(self, service: F) -> H1Service<T, P, S, B, X, U>
    where
        B: MessageBody + 'static,
-        F: IntoNewService<S, SrvConfig>,
+        F: IntoNewService<S>,
+        S::Error: Into<Error>,
+        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
    {
        let cfg = ServiceConfig::new(
@ -107,14 +178,20 @@ where
            self.client_disconnect,
        );
        H1Service::with_config(cfg, service.into_new_service())
+            .expect(self.expect)
+            .upgrade(self.upgrade)
+            .on_connect(self.on_connect)
    }

    /// Finish service configuration and create *http service* for HTTP/2 protocol.
    pub fn h2<F, P, B>(self, service: F) -> H2Service<T, P, S, B>
    where
        B: MessageBody + 'static,
-        F: IntoNewService<S, SrvConfig>,
+        F: IntoNewService<S>,
+        S::Error: Into<Error>,
+        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
+        <S::Service as Service>::Future: 'static,
    {
        let cfg = ServiceConfig::new(
            self.keep_alive,
@ -125,11 +202,14 @@ where
    }

    /// Finish service configuration and create `HttpService` instance.
-    pub fn finish<F, P, B>(self, service: F) -> HttpService<T, P, S, B>
+    pub fn finish<F, P, B>(self, service: F) -> HttpService<T, P, S, B, X, U>
    where
        B: MessageBody + 'static,
-        F: IntoNewService<S, SrvConfig>,
+        F: IntoNewService<S>,
+        S::Error: Into<Error>,
+        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
+        <S::Service as Service>::Future: 'static,
    {
        let cfg = ServiceConfig::new(
            self.keep_alive,
@ -137,5 +217,8 @@ where
            self.client_disconnect,
        );
        HttpService::with_config(cfg, service.into_new_service())
+            .expect(self.expect)
+            .upgrade(self.upgrade)
+            .on_connect(self.on_connect)
    }
 }
--- a/actix-http/src/client/connection.rs
+++ b/actix-http/src/client/connection.rs
@ -12,7 +12,7 @@ use crate::message::{RequestHead, ResponseHead};
 use crate::payload::Payload;

 use super::error::SendRequestError;
-use super::pool::Acquired;
+use super::pool::{Acquired, Protocol};
 use super::{h1proto, h2proto};

 pub(crate) enum ConnectionType<Io> {
@ -24,6 +24,8 @@ pub trait Connection {
    type Io: AsyncRead + AsyncWrite;
    type Future: Future<Item = (ResponseHead, Payload), Error = SendRequestError>;

+    fn protocol(&self) -> Protocol;
+
    /// Send request and body
    fn send_request<B: MessageBody + 'static>(
        self,
@ -69,7 +71,7 @@ where
    }
 }

-impl<T: AsyncRead + AsyncWrite + 'static> IoConnection<T> {
+impl<T: AsyncRead + AsyncWrite> IoConnection<T> {
    pub(crate) fn new(
        io: ConnectionType<T>,
        created: time::Instant,
@ -94,6 +96,14 @@ where
    type Io = T;
    type Future = Box<Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;

+    fn protocol(&self) -> Protocol {
+        match self.io {
+            Some(ConnectionType::H1(_)) => Protocol::Http1,
+            Some(ConnectionType::H2(_)) => Protocol::Http2,
+            None => Protocol::Http1,
+        }
+    }
+
    fn send_request<B: MessageBody + 'static>(
        mut self,
        head: RequestHead,
@ -161,6 +171,13 @@ where
    type Io = EitherIo<A, B>;
    type Future = Box<Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;

+    fn protocol(&self) -> Protocol {
+        match self {
+            EitherConnection::A(con) => con.protocol(),
+            EitherConnection::B(con) => con.protocol(),
+        }
+    }
+
    fn send_request<RB: MessageBody + 'static>(
        self,
        head: RequestHead,
@ -184,11 +201,11 @@ where
        match self {
            EitherConnection::A(con) => Box::new(
                con.open_tunnel(head)
-                    .map(|(head, framed)| (head, framed.map_io(|io| EitherIo::A(io)))),
+                    .map(|(head, framed)| (head, framed.map_io(EitherIo::A))),
            ),
            EitherConnection::B(con) => Box::new(
                con.open_tunnel(head)
-                    .map(|(head, framed)| (head, framed.map_io(|io| EitherIo::B(io)))),
+                    .map(|(head, framed)| (head, framed.map_io(EitherIo::B))),
            ),
        }
    }
--- a/actix-http/src/client/connector.rs
+++ b/actix-http/src/client/connector.rs
@ -14,6 +14,7 @@ use tokio_tcp::TcpStream;
 use super::connection::Connection;
 use super::error::ConnectError;
 use super::pool::{ConnectionPool, Protocol};
+use super::Connect;

 #[cfg(feature = "ssl")]
 use openssl::ssl::SslConnector;
@ -21,8 +22,18 @@ use openssl::ssl::SslConnector;
 #[cfg(not(feature = "ssl"))]
 type SslConnector = ();

-/// Http client connector builde instance.
-/// `Connector` type uses builder-like pattern for connector service construction.
+/// Manages http client network connectivity
+/// The `Connector` type uses a builder-like combinator pattern for service
+/// construction that finishes by calling the `.finish()` method.
+///
+/// ```rust,ignore
+/// use std::time::Duration;
+/// use actix_http::client::Connector;
+///
+/// let connector = Connector::new()
+///      .timeout(Duration::from_secs(5))
+///      .finish();
+/// ```
 pub struct Connector<T, U> {
    connector: T,
    timeout: Duration,
@ -47,8 +58,7 @@ impl Connector<(), ()> {
        let ssl = {
            #[cfg(feature = "ssl")]
            {
-                use log::error;
-                use openssl::ssl::{SslConnector, SslMethod};
+                use openssl::ssl::SslMethod;

                let mut ssl = SslConnector::builder(SslMethod::tls()).unwrap();
                let _ = ssl
@ -104,7 +114,8 @@ where
            Request = TcpConnect<Uri>,
            Response = TcpConnection<Uri, U>,
            Error = actix_connect::ConnectError,
-        > + Clone,
+        > + Clone
+        + 'static,
 {
    /// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
    /// Set to 1 second by default.
@ -164,17 +175,21 @@ where
    }

    /// Finish configuration process and create connector service.
-    pub fn service(
+    /// The Connector builder always concludes by calling `finish()` last in
+    /// its combinator chain.
+    pub fn finish(
        self,
-    ) -> impl Service<Request = Uri, Response = impl Connection, Error = ConnectError> + Clone
-    {
+    ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
+                 + Clone {
        #[cfg(not(feature = "ssl"))]
        {
            let connector = TimeoutService::new(
                self.timeout,
-                apply_fn(self.connector, |msg: Uri, srv| srv.call(msg.into()))
-                    .map_err(ConnectError::from)
-                    .map(|stream| (stream.into_parts().0, Protocol::Http1)),
+                apply_fn(self.connector, |msg: Connect, srv| {
+                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                })
+                .map_err(ConnectError::from)
+                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
            )
            .map_err(|e| match e {
                TimeoutError::Service(e) => e,
@ -198,26 +213,28 @@ where

            let ssl_service = TimeoutService::new(
                self.timeout,
-                apply_fn(self.connector.clone(), |msg: Uri, srv| srv.call(msg.into()))
-                    .map_err(ConnectError::from)
-                    .and_then(
-                        OpensslConnector::service(self.ssl)
-                            .map_err(ConnectError::from)
-                            .map(|stream| {
-                                let sock = stream.into_parts().0;
-                                let h2 = sock
-                                    .get_ref()
-                                    .ssl()
-                                    .selected_alpn_protocol()
-                                    .map(|protos| protos.windows(2).any(|w| w == H2))
-                                    .unwrap_or(false);
-                                if h2 {
-                                    (sock, Protocol::Http2)
-                                } else {
-                                    (sock, Protocol::Http1)
-                                }
-                            }),
-                    ),
+                apply_fn(self.connector.clone(), |msg: Connect, srv| {
+                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                })
+                .map_err(ConnectError::from)
+                .and_then(
+                    OpensslConnector::service(self.ssl)
+                        .map_err(ConnectError::from)
+                        .map(|stream| {
+                            let sock = stream.into_parts().0;
+                            let h2 = sock
+                                .get_ref()
+                                .ssl()
+                                .selected_alpn_protocol()
+                                .map(|protos| protos.windows(2).any(|w| w == H2))
+                                .unwrap_or(false);
+                            if h2 {
+                                (sock, Protocol::Http2)
+                            } else {
+                                (sock, Protocol::Http1)
+                            }
+                        }),
+                ),
            )
            .map_err(|e| match e {
                TimeoutError::Service(e) => e,
@ -226,9 +243,11 @@ where

            let tcp_service = TimeoutService::new(
                self.timeout,
-                apply_fn(self.connector.clone(), |msg: Uri, srv| srv.call(msg.into()))
-                    .map_err(ConnectError::from)
-                    .map(|stream| (stream.into_parts().0, Protocol::Http1)),
+                apply_fn(self.connector.clone(), |msg: Connect, srv| {
+                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
+                })
+                .map_err(ConnectError::from)
+                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
            )
            .map_err(|e| match e {
                TimeoutError::Service(e) => e,
@ -266,7 +285,9 @@ mod connect_impl {
    pub(crate) struct InnerConnector<T, Io>
    where
        Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
    {
        pub(crate) tcp_pool: ConnectionPool<T, Io>,
    }
@ -274,8 +295,9 @@ mod connect_impl {
    impl<T, Io> Clone for InnerConnector<T, Io>
    where
        Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>
-            + Clone,
+        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
    {
        fn clone(&self) -> Self {
            InnerConnector {
@ -287,9 +309,11 @@ mod connect_impl {
    impl<T, Io> Service for InnerConnector<T, Io>
    where
        Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
    {
-        type Request = Uri;
+        type Request = Connect;
        type Response = IoConnection<Io>;
        type Error = ConnectError;
        type Future = Either<
@ -301,8 +325,8 @@ mod connect_impl {
            self.tcp_pool.poll_ready()
        }

-        fn call(&mut self, req: Uri) -> Self::Future {
-            match req.scheme_str() {
+        fn call(&mut self, req: Connect) -> Self::Future {
+            match req.uri.scheme_str() {
                Some("https") | Some("wss") => {
                    Either::B(err(ConnectError::SslIsNotSupported))
                }
@ -326,8 +350,8 @@ mod connect_impl {
    where
        Io1: AsyncRead + AsyncWrite + 'static,
        Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>,
+        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>,
    {
        pub(crate) tcp_pool: ConnectionPool<T1, Io1>,
        pub(crate) ssl_pool: ConnectionPool<T2, Io2>,
@ -337,10 +361,12 @@ mod connect_impl {
    where
        Io1: AsyncRead + AsyncWrite + 'static,
        Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>
-            + Clone,
-        T2: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>
-            + Clone,
+        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
+        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
    {
        fn clone(&self) -> Self {
            InnerConnector {
@ -354,10 +380,14 @@ mod connect_impl {
    where
        Io1: AsyncRead + AsyncWrite + 'static,
        Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
+        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
    {
-        type Request = Uri;
+        type Request = Connect;
        type Response = EitherConnection<Io1, Io2>;
        type Error = ConnectError;
        type Future = Either<
@ -372,8 +402,8 @@ mod connect_impl {
            self.tcp_pool.poll_ready()
        }

-        fn call(&mut self, req: Uri) -> Self::Future {
-            match req.scheme_str() {
+        fn call(&mut self, req: Connect) -> Self::Future {
+            match req.uri.scheme_str() {
                Some("https") | Some("wss") => {
                    Either::B(Either::B(InnerConnectorResponseB {
                        fut: self.ssl_pool.call(req),
@ -391,7 +421,9 @@ mod connect_impl {
    pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
    where
        Io1: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
    {
        fut: <ConnectionPool<T, Io1> as Service>::Future,
        _t: PhantomData<Io2>,
@ -399,7 +431,9 @@ mod connect_impl {

    impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2>
    where
-        T: Service<Request = Uri, Response = (Io1, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
        Io1: AsyncRead + AsyncWrite + 'static,
        Io2: AsyncRead + AsyncWrite + 'static,
    {
@ -417,7 +451,9 @@ mod connect_impl {
    pub(crate) struct InnerConnectorResponseB<T, Io1, Io2>
    where
        Io2: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
    {
        fut: <ConnectionPool<T, Io2> as Service>::Future,
        _t: PhantomData<Io1>,
@ -425,7 +461,9 @@ mod connect_impl {

    impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2>
    where
-        T: Service<Request = Uri, Response = (Io2, Protocol), Error = ConnectError>,
+        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
+            + 'static,
        Io1: AsyncRead + AsyncWrite + 'static,
        Io2: AsyncRead + AsyncWrite + 'static,
    {
--- a/actix-http/src/client/error.rs
+++ b/actix-http/src/client/error.rs
@ -105,6 +105,9 @@ pub enum SendRequestError {
    /// Http2 error
    #[display(fmt = "{}", _0)]
    H2(h2::Error),
+    /// Response took too long
+    #[display(fmt = "Timeout out while waiting for response")]
+    Timeout,
    /// Tunnels are not supported for http2 connection
    #[display(fmt = "Tunnels are not supported for http2 connection")]
    TunnelNotSupported,
--- a/actix-http/src/client/h1proto.rs
+++ b/actix-http/src/client/h1proto.rs
@ -1,12 +1,14 @@
+use std::io::Write;
 use std::{io, time};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use bytes::Bytes;
+use bytes::{BufMut, Bytes, BytesMut};
 use futures::future::{ok, Either};
 use futures::{Async, Future, Poll, Sink, Stream};

 use crate::error::PayloadError;
 use crate::h1;
+use crate::http::header::{IntoHeaderValue, HOST};
 use crate::message::{RequestHead, ResponseHead};
 use crate::payload::{Payload, PayloadStream};

@ -17,7 +19,7 @@ use crate::body::{BodySize, MessageBody};

 pub(crate) fn send_request<T, B>(
    io: T,
-    head: RequestHead,
+    mut head: RequestHead,
    body: B,
    created: time::Instant,
    pool: Option<Acquired<T>>,
@ -26,20 +28,41 @@ where
    T: AsyncRead + AsyncWrite + 'static,
    B: MessageBody,
 {
+    // set request host header
+    if !head.headers.contains_key(HOST) {
+        if let Some(host) = head.uri.host() {
+            let mut wrt = BytesMut::with_capacity(host.len() + 5).writer();
+
+            let _ = match head.uri.port_u16() {
+                None | Some(80) | Some(443) => write!(wrt, "{}", host),
+                Some(port) => write!(wrt, "{}:{}", host, port),
+            };
+
+            match wrt.get_mut().take().freeze().try_into() {
+                Ok(value) => {
+                    head.headers.insert(HOST, value);
+                }
+                Err(e) => {
+                    log::error!("Can not set HOST header {}", e);
+                }
+            }
+        }
+    }
+
    let io = H1Connection {
        created,
        pool,
        io: Some(io),
    };

-    let len = body.length();
+    let len = body.size();

    // create Framed and send reqest
    Framed::new(io, h1::ClientCodec::default())
        .send((head, len).into())
        .from_err()
        // send request body
-        .and_then(move |framed| match body.length() {
+        .and_then(move |framed| match body.size() {
            BodySize::None | BodySize::Empty | BodySize::Sized(0) => {
                Either::A(ok(framed))
            }
@ -251,7 +274,7 @@ impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
                    Ok(Async::Ready(Some(chunk)))
                } else {
                    let framed = self.framed.take().unwrap();
-                    let force_close = framed.get_codec().keepalive();
+                    let force_close = !framed.get_codec().keepalive();
                    release_connection(framed, force_close);
                    Ok(Async::Ready(None))
                }
--- a/actix-http/src/client/h2proto.rs
+++ b/actix-http/src/client/h2proto.rs
@ -27,9 +27,9 @@ where
    T: AsyncRead + AsyncWrite + 'static,
    B: MessageBody,
 {
-    trace!("Sending client request: {:?} {:?}", head, body.length());
+    trace!("Sending client request: {:?} {:?}", head, body.size());
    let head_req = head.method == Method::HEAD;
-    let length = body.length();
+    let length = body.size();
    let eof = match length {
        BodySize::None | BodySize::Empty | BodySize::Sized(0) => true,
        _ => false,
@ -104,11 +104,9 @@ where
            let (parts, body) = resp.into_parts();
            let payload = if head_req { Payload::None } else { body.into() };

-            let mut head = ResponseHead::default();
+            let mut head = ResponseHead::new(parts.status);
            head.version = parts.version;
-            head.status = parts.status;
-            head.headers = parts.headers;
-
+            head.headers = parts.headers.into();
            Ok((head, payload))
        })
        .from_err()
--- a/actix-http/src/client/mod.rs
+++ b/actix-http/src/client/mod.rs
@ -1,4 +1,6 @@
 //! Http client api
+use http::Uri;
+
 mod connection;
 mod connector;
 mod error;
@ -9,3 +11,10 @@ mod pool;
 pub use self::connection::Connection;
 pub use self::connector::Connector;
 pub use self::error::{ConnectError, InvalidUrl, SendRequestError};
+pub use self::pool::Protocol;
+
+#[derive(Clone)]
+pub struct Connect {
+    pub uri: Uri,
+    pub addr: Option<std::net::SocketAddr>,
+}
--- a/actix-http/src/client/pool.rs
+++ b/actix-http/src/client/pool.rs
@ -13,15 +13,17 @@ use futures::unsync::oneshot;
 use futures::{Async, Future, Poll};
 use h2::client::{handshake, Handshake};
 use hashbrown::HashMap;
-use http::uri::{Authority, Uri};
+use http::uri::Authority;
 use indexmap::IndexSet;
 use slab::Slab;
 use tokio_timer::{sleep, Delay};

 use super::connection::{ConnectionType, IoConnection};
 use super::error::ConnectError;
+use super::Connect;

 #[derive(Clone, Copy, PartialEq)]
+/// Protocol version
 pub enum Protocol {
    Http1,
    Http2,
@ -47,7 +49,9 @@ pub(crate) struct ConnectionPool<T, Io: AsyncRead + AsyncWrite + 'static>(
 impl<T, Io> ConnectionPool<T, Io>
 where
    Io: AsyncRead + AsyncWrite + 'static,
-    T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+        + Clone
+        + 'static,
 {
    pub(crate) fn new(
        connector: T,
@ -67,7 +71,7 @@ where
                waiters: Slab::new(),
                waiters_queue: IndexSet::new(),
                available: HashMap::new(),
-                task: AtomicTask::new(),
+                task: None,
            })),
        )
    }
@ -86,9 +90,11 @@ where
 impl<T, Io> Service for ConnectionPool<T, Io>
 where
    Io: AsyncRead + AsyncWrite + 'static,
-    T: Service<Request = Uri, Response = (Io, Protocol), Error = ConnectError>,
+    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+        + Clone
+        + 'static,
 {
-    type Request = Uri;
+    type Request = Connect;
    type Response = IoConnection<Io>;
    type Error = ConnectError;
    type Future = Either<
@ -100,8 +106,8 @@ where
        self.0.poll_ready()
    }

-    fn call(&mut self, req: Uri) -> Self::Future {
-        let key = if let Some(authority) = req.authority_part() {
+    fn call(&mut self, req: Connect) -> Self::Future {
+        let key = if let Some(authority) = req.uri.authority_part() {
            authority.clone().into()
        } else {
            return Either::A(err(ConnectError::Unresolverd));
@ -111,31 +117,41 @@ where
        match self.1.as_ref().borrow_mut().acquire(&key) {
            Acquire::Acquired(io, created) => {
                // use existing connection
-                Either::A(ok(IoConnection::new(
+                return Either::A(ok(IoConnection::new(
                    io,
                    created,
                    Some(Acquired(key, Some(self.1.clone()))),
-                )))
-            }
-            Acquire::NotAvailable => {
-                // connection is not available, wait
-                let (rx, token) = self.1.as_ref().borrow_mut().wait_for(req);
-                Either::B(Either::A(WaitForConnection {
-                    rx,
-                    key,
-                    token,
-                    inner: Some(self.1.clone()),
-                }))
+                )));
            }
            Acquire::Available => {
                // open new connection
-                Either::B(Either::B(OpenConnection::new(
+                return Either::B(Either::B(OpenConnection::new(
                    key,
                    self.1.clone(),
                    self.0.call(req),
-                )))
+                )));
            }
+            _ => (),
        }
+
+        // connection is not available, wait
+        let (rx, token, support) = self.1.as_ref().borrow_mut().wait_for(req);
+
+        // start support future
+        if !support {
+            self.1.as_ref().borrow_mut().task = Some(AtomicTask::new());
+            tokio_current_thread::spawn(ConnectorPoolSupport {
+                connector: self.0.clone(),
+                inner: self.1.clone(),
+            })
+        }
+
+        Either::B(Either::A(WaitForConnection {
+            rx,
+            key,
+            token,
+            inner: Some(self.1.clone()),
+        }))
    }
 }

@ -243,7 +259,7 @@ where
                    Ok(Async::Ready(IoConnection::new(
                        ConnectionType::H2(snd),
                        Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.clone())),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
                    )))
                }
                Ok(Async::NotReady) => Ok(Async::NotReady),
@ -254,12 +270,11 @@ where
        match self.fut.poll() {
            Err(err) => Err(err),
            Ok(Async::Ready((io, proto))) => {
-                let _ = self.inner.take();
                if proto == Protocol::Http1 {
                    Ok(Async::Ready(IoConnection::new(
                        ConnectionType::H1(io),
                        Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.clone())),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
                    )))
                } else {
                    self.h2 = Some(handshake(io));
@ -277,7 +292,6 @@ enum Acquire<T> {
    NotAvailable,
 }

-// #[derive(Debug)]
 struct AvailableConnection<Io> {
    io: ConnectionType<Io>,
    used: Instant,
@ -291,9 +305,12 @@ pub(crate) struct Inner<Io> {
    limit: usize,
    acquired: usize,
    available: HashMap<Key, VecDeque<AvailableConnection<Io>>>,
-    waiters: Slab<(Uri, oneshot::Sender<Result<IoConnection<Io>, ConnectError>>)>,
+    waiters: Slab<(
+        Connect,
+        oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
+    )>,
    waiters_queue: IndexSet<(Key, usize)>,
-    task: AtomicTask,
+    task: Option<AtomicTask>,
 }

 impl<Io> Inner<Io> {
@ -309,18 +326,6 @@ impl<Io> Inner<Io> {
        self.waiters.remove(token);
        self.waiters_queue.remove(&(key.clone(), token));
    }
-
-    fn release_conn(&mut self, key: &Key, io: ConnectionType<Io>, created: Instant) {
-        self.acquired -= 1;
-        self.available
-            .entry(key.clone())
-            .or_insert_with(VecDeque::new)
-            .push_back(AvailableConnection {
-                io,
-                created,
-                used: Instant::now(),
-            });
-    }
 }

 impl<Io> Inner<Io>
@ -330,19 +335,21 @@ where
    /// connection is not available, wait
    fn wait_for(
        &mut self,
-        connect: Uri,
+        connect: Connect,
    ) -> (
        oneshot::Receiver<Result<IoConnection<Io>, ConnectError>>,
        usize,
+        bool,
    ) {
        let (tx, rx) = oneshot::channel();

-        let key: Key = connect.authority_part().unwrap().clone().into();
+        let key: Key = connect.uri.authority_part().unwrap().clone().into();
        let entry = self.waiters.vacant_entry();
        let token = entry.key();
        entry.insert((connect, tx));
-        assert!(!self.waiters_queue.insert((key, token)));
-        (rx, token)
+        assert!(self.waiters_queue.insert((key, token)));
+
+        (rx, token, self.task.is_some())
    }

    fn acquire(&mut self, key: &Key) -> Acquire<Io> {
@ -395,6 +402,19 @@ where
        Acquire::Available
    }

+    fn release_conn(&mut self, key: &Key, io: ConnectionType<Io>, created: Instant) {
+        self.acquired -= 1;
+        self.available
+            .entry(key.clone())
+            .or_insert_with(VecDeque::new)
+            .push_back(AvailableConnection {
+                io,
+                created,
+                used: Instant::now(),
+            });
+        self.check_availibility();
+    }
+
    fn release_close(&mut self, io: ConnectionType<Io>) {
        self.acquired -= 1;
        if let Some(timeout) = self.disconnect_timeout {
@ -402,11 +422,12 @@ where
                tokio_current_thread::spawn(CloseConnection::new(io, timeout))
            }
        }
+        self.check_availibility();
    }

    fn check_availibility(&self) {
        if !self.waiters_queue.is_empty() && self.acquired < self.limit {
-            self.task.notify()
+            self.task.as_ref().map(|t| t.notify());
        }
    }
 }
@ -446,6 +467,147 @@ where
    }
 }

+struct ConnectorPoolSupport<T, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    connector: T,
+    inner: Rc<RefCell<Inner<Io>>>,
+}
+
+impl<T, Io> Future for ConnectorPoolSupport<T, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>,
+    T::Future: 'static,
+{
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let mut inner = self.inner.as_ref().borrow_mut();
+        inner.task.as_ref().unwrap().register();
+
+        // check waiters
+        loop {
+            let (key, token) = {
+                if let Some((key, token)) = inner.waiters_queue.get_index(0) {
+                    (key.clone(), *token)
+                } else {
+                    break;
+                }
+            };
+            match inner.acquire(&key) {
+                Acquire::NotAvailable => break,
+                Acquire::Acquired(io, created) => {
+                    let (_, tx) = inner.waiters.remove(token);
+                    if let Err(conn) = tx.send(Ok(IoConnection::new(
+                        io,
+                        created,
+                        Some(Acquired(key.clone(), Some(self.inner.clone()))),
+                    ))) {
+                        let (io, created) = conn.unwrap().into_inner();
+                        inner.release_conn(&key, io, created);
+                    }
+                }
+                Acquire::Available => {
+                    let (connect, tx) = inner.waiters.remove(token);
+                    OpenWaitingConnection::spawn(
+                        key.clone(),
+                        tx,
+                        self.inner.clone(),
+                        self.connector.call(connect),
+                    );
+                }
+            }
+            let _ = inner.waiters_queue.swap_remove_index(0);
+        }
+
+        Ok(Async::NotReady)
+    }
+}
+
+struct OpenWaitingConnection<F, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    fut: F,
+    key: Key,
+    h2: Option<Handshake<Io, Bytes>>,
+    rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
+    inner: Option<Rc<RefCell<Inner<Io>>>>,
+}
+
+impl<F, Io> OpenWaitingConnection<F, Io>
+where
+    F: Future<Item = (Io, Protocol), Error = ConnectError> + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    fn spawn(
+        key: Key,
+        rx: oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
+        inner: Rc<RefCell<Inner<Io>>>,
+        fut: F,
+    ) {
+        tokio_current_thread::spawn(OpenWaitingConnection {
+            key,
+            fut,
+            h2: None,
+            rx: Some(rx),
+            inner: Some(inner),
+        })
+    }
+}
+
+impl<F, Io> Drop for OpenWaitingConnection<F, Io>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+{
+    fn drop(&mut self) {
+        if let Some(inner) = self.inner.take() {
+            let mut inner = inner.as_ref().borrow_mut();
+            inner.release();
+            inner.check_availibility();
+        }
+    }
+}
+
+impl<F, Io> Future for OpenWaitingConnection<F, Io>
+where
+    F: Future<Item = (Io, Protocol), Error = ConnectError>,
+    Io: AsyncRead + AsyncWrite,
+{
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.fut.poll() {
+            Err(err) => {
+                let _ = self.inner.take();
+                if let Some(rx) = self.rx.take() {
+                    let _ = rx.send(Err(err));
+                }
+                Err(())
+            }
+            Ok(Async::Ready((io, proto))) => {
+                if proto == Protocol::Http1 {
+                    let rx = self.rx.take().unwrap();
+                    let _ = rx.send(Ok(IoConnection::new(
+                        ConnectionType::H1(io),
+                        Instant::now(),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
+                    )));
+                    Ok(Async::Ready(()))
+                } else {
+                    self.h2 = Some(handshake(io));
+                    self.poll()
+                }
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+        }
+    }
+}
+
 pub(crate) struct Acquired<T>(Key, Option<Rc<RefCell<Inner<T>>>>);

 impl<T> Acquired<T>
--- a/actix-http/src/config.rs
+++ b/actix-http/src/config.rs
@ -158,7 +158,8 @@ impl ServiceConfig {
        self.0.timer.now()
    }

-    pub(crate) fn set_date(&self, dst: &mut BytesMut) {
+    #[doc(hidden)]
+    pub fn set_date(&self, dst: &mut BytesMut) {
        let mut buf: [u8; 39] = [0; 39];
        buf[..6].copy_from_slice(b"date: ");
        buf[6..35].copy_from_slice(&self.0.timer.date().bytes);
--- a/actix-http/src/cookie/builder.rs
+++ b/actix-http/src/cookie/builder.rs
@ -0,0 +1,260 @@
+use std::borrow::Cow;
+
+use chrono::Duration;
+use time::Tm;
+
+use super::{Cookie, SameSite};
+
+/// Structure that follows the builder pattern for building `Cookie` structs.
+///
+/// To construct a cookie:
+///
+///   1. Call [`Cookie::build`](struct.Cookie.html#method.build) to start building.
+///   2. Use any of the builder methods to set fields in the cookie.
+///   3. Call [finish](#method.finish) to retrieve the built cookie.
+///
+/// # Example
+///
+/// ```rust
+/// use actix_http::cookie::Cookie;
+///
+/// # fn main() {
+/// let cookie: Cookie = Cookie::build("name", "value")
+///     .domain("www.rust-lang.org")
+///     .path("/")
+///     .secure(true)
+///     .http_only(true)
+///     .max_age(84600)
+///     .finish();
+/// # }
+/// ```
+#[derive(Debug, Clone)]
+pub struct CookieBuilder {
+    /// The cookie being built.
+    cookie: Cookie<'static>,
+}
+
+impl CookieBuilder {
+    /// Creates a new `CookieBuilder` instance from the given name and value.
+    ///
+    /// This method is typically called indirectly via
+    /// [Cookie::build](struct.Cookie.html#method.build).
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar").finish();
+    /// assert_eq!(c.name_value(), ("foo", "bar"));
+    /// ```
+    pub fn new<N, V>(name: N, value: V) -> CookieBuilder
+    where
+        N: Into<Cow<'static, str>>,
+        V: Into<Cow<'static, str>>,
+    {
+        CookieBuilder {
+            cookie: Cookie::new(name, value),
+        }
+    }
+
+    /// Sets the `expires` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .expires(time::now())
+    ///     .finish();
+    ///
+    /// assert!(c.expires().is_some());
+    /// # }
+    /// ```
+    #[inline]
+    pub fn expires(mut self, when: Tm) -> CookieBuilder {
+        self.cookie.set_expires(when);
+        self
+    }
+
+    /// Sets the `max_age` field in seconds in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .max_age(1800)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
+    /// # }
+    /// ```
+    #[inline]
+    pub fn max_age(self, seconds: i64) -> CookieBuilder {
+        self.max_age_time(Duration::seconds(seconds))
+    }
+
+    /// Sets the `max_age` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .max_age_time(time::Duration::minutes(30))
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
+    /// # }
+    /// ```
+    #[inline]
+    pub fn max_age_time(mut self, value: Duration) -> CookieBuilder {
+        self.cookie.set_max_age(value);
+        self
+    }
+
+    /// Sets the `domain` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .domain("www.rust-lang.org")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.domain(), Some("www.rust-lang.org"));
+    /// ```
+    pub fn domain<D: Into<Cow<'static, str>>>(mut self, value: D) -> CookieBuilder {
+        self.cookie.set_domain(value);
+        self
+    }
+
+    /// Sets the `path` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .path("/")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.path(), Some("/"));
+    /// ```
+    pub fn path<P: Into<Cow<'static, str>>>(mut self, path: P) -> CookieBuilder {
+        self.cookie.set_path(path);
+        self
+    }
+
+    /// Sets the `secure` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .secure(true)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.secure(), Some(true));
+    /// ```
+    #[inline]
+    pub fn secure(mut self, value: bool) -> CookieBuilder {
+        self.cookie.set_secure(value);
+        self
+    }
+
+    /// Sets the `http_only` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .http_only(true)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.http_only(), Some(true));
+    /// ```
+    #[inline]
+    pub fn http_only(mut self, value: bool) -> CookieBuilder {
+        self.cookie.set_http_only(value);
+        self
+    }
+
+    /// Sets the `same_site` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{Cookie, SameSite};
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .same_site(SameSite::Strict)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.same_site(), Some(SameSite::Strict));
+    /// ```
+    #[inline]
+    pub fn same_site(mut self, value: SameSite) -> CookieBuilder {
+        self.cookie.set_same_site(value);
+        self
+    }
+
+    /// Makes the cookie being built 'permanent' by extending its expiration and
+    /// max age 20 years into the future.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    /// use chrono::Duration;
+    ///
+    /// # fn main() {
+    /// let c = Cookie::build("foo", "bar")
+    ///     .permanent()
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
+    /// # assert!(c.expires().is_some());
+    /// # }
+    /// ```
+    #[inline]
+    pub fn permanent(mut self) -> CookieBuilder {
+        self.cookie.make_permanent();
+        self
+    }
+
+    /// Finishes building and returns the built `Cookie`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .domain("crates.io")
+    ///     .path("/")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.name_value(), ("foo", "bar"));
+    /// assert_eq!(c.domain(), Some("crates.io"));
+    /// assert_eq!(c.path(), Some("/"));
+    /// ```
+    #[inline]
+    pub fn finish(self) -> Cookie<'static> {
+        self.cookie
+    }
+}
--- a/actix-http/src/cookie/delta.rs
+++ b/actix-http/src/cookie/delta.rs
@ -0,0 +1,71 @@
+use std::borrow::Borrow;
+use std::hash::{Hash, Hasher};
+use std::ops::{Deref, DerefMut};
+
+use super::Cookie;
+
+/// A `DeltaCookie` is a helper structure used in a cookie jar. It wraps a
+/// `Cookie` so that it can be hashed and compared purely by name. It further
+/// records whether the wrapped cookie is a "removal" cookie, that is, a cookie
+/// that when sent to the client removes the named cookie on the client's
+/// machine.
+#[derive(Clone, Debug)]
+pub struct DeltaCookie {
+    pub cookie: Cookie<'static>,
+    pub removed: bool,
+}
+
+impl DeltaCookie {
+    /// Create a new `DeltaCookie` that is being added to a jar.
+    #[inline]
+    pub fn added(cookie: Cookie<'static>) -> DeltaCookie {
+        DeltaCookie {
+            cookie,
+            removed: false,
+        }
+    }
+
+    /// Create a new `DeltaCookie` that is being removed from a jar. The
+    /// `cookie` should be a "removal" cookie.
+    #[inline]
+    pub fn removed(cookie: Cookie<'static>) -> DeltaCookie {
+        DeltaCookie {
+            cookie,
+            removed: true,
+        }
+    }
+}
+
+impl Deref for DeltaCookie {
+    type Target = Cookie<'static>;
+
+    fn deref(&self) -> &Cookie<'static> {
+        &self.cookie
+    }
+}
+
+impl DerefMut for DeltaCookie {
+    fn deref_mut(&mut self) -> &mut Cookie<'static> {
+        &mut self.cookie
+    }
+}
+
+impl PartialEq for DeltaCookie {
+    fn eq(&self, other: &DeltaCookie) -> bool {
+        self.name() == other.name()
+    }
+}
+
+impl Eq for DeltaCookie {}
+
+impl Hash for DeltaCookie {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name().hash(state);
+    }
+}
+
+impl Borrow<str> for DeltaCookie {
+    fn borrow(&self) -> &str {
+        self.name()
+    }
+}
--- a/actix-http/src/cookie/draft.rs
+++ b/actix-http/src/cookie/draft.rs
@ -0,0 +1,98 @@
+//! This module contains types that represent cookie properties that are not yet
+//! standardized. That is, _draft_ features.
+
+use std::fmt;
+
+/// The `SameSite` cookie attribute.
+///
+/// A cookie with a `SameSite` attribute is imposed restrictions on when it is
+/// sent to the origin server in a cross-site request. If the `SameSite`
+/// attribute is "Strict", then the cookie is never sent in cross-site requests.
+/// If the `SameSite` attribute is "Lax", the cookie is only sent in cross-site
+/// requests with "safe" HTTP methods, i.e, `GET`, `HEAD`, `OPTIONS`, `TRACE`.
+/// If the `SameSite` attribute is not present (made explicit via the
+/// `SameSite::None` variant), then the cookie will be sent as normal.
+///
+/// **Note:** This cookie attribute is an HTTP draft! Its meaning and definition
+/// are subject to change.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SameSite {
+    /// The "Strict" `SameSite` attribute.
+    Strict,
+    /// The "Lax" `SameSite` attribute.
+    Lax,
+    /// No `SameSite` attribute.
+    None,
+}
+
+impl SameSite {
+    /// Returns `true` if `self` is `SameSite::Strict` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::SameSite;
+    ///
+    /// let strict = SameSite::Strict;
+    /// assert!(strict.is_strict());
+    /// assert!(!strict.is_lax());
+    /// assert!(!strict.is_none());
+    /// ```
+    #[inline]
+    pub fn is_strict(self) -> bool {
+        match self {
+            SameSite::Strict => true,
+            SameSite::Lax | SameSite::None => false,
+        }
+    }
+
+    /// Returns `true` if `self` is `SameSite::Lax` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::SameSite;
+    ///
+    /// let lax = SameSite::Lax;
+    /// assert!(lax.is_lax());
+    /// assert!(!lax.is_strict());
+    /// assert!(!lax.is_none());
+    /// ```
+    #[inline]
+    pub fn is_lax(self) -> bool {
+        match self {
+            SameSite::Lax => true,
+            SameSite::Strict | SameSite::None => false,
+        }
+    }
+
+    /// Returns `true` if `self` is `SameSite::None` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::SameSite;
+    ///
+    /// let none = SameSite::None;
+    /// assert!(none.is_none());
+    /// assert!(!none.is_lax());
+    /// assert!(!none.is_strict());
+    /// ```
+    #[inline]
+    pub fn is_none(self) -> bool {
+        match self {
+            SameSite::None => true,
+            SameSite::Lax | SameSite::Strict => false,
+        }
+    }
+}
+
+impl fmt::Display for SameSite {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            SameSite::Strict => write!(f, "Strict"),
+            SameSite::Lax => write!(f, "Lax"),
+            SameSite::None => Ok(()),
+        }
+    }
+}
--- a/actix-http/src/cookie/jar.rs
+++ b/actix-http/src/cookie/jar.rs
@ -0,0 +1,655 @@
+use std::collections::HashSet;
+use std::mem::replace;
+
+use chrono::Duration;
+
+use super::delta::DeltaCookie;
+use super::Cookie;
+
+#[cfg(feature = "secure-cookies")]
+use super::secure::{Key, PrivateJar, SignedJar};
+
+/// A collection of cookies that tracks its modifications.
+///
+/// A `CookieJar` provides storage for any number of cookies. Any changes made
+/// to the jar are tracked; the changes can be retrieved via the
+/// [delta](#method.delta) method which returns an interator over the changes.
+///
+/// # Usage
+///
+/// A jar's life begins via [new](#method.new) and calls to
+/// [`add_original`](#method.add_original):
+///
+/// ```rust
+/// use actix_http::cookie::{Cookie, CookieJar};
+///
+/// let mut jar = CookieJar::new();
+/// jar.add_original(Cookie::new("name", "value"));
+/// jar.add_original(Cookie::new("second", "another"));
+/// ```
+///
+/// Cookies can be added via [add](#method.add) and removed via
+/// [remove](#method.remove). Finally, cookies can be looked up via
+/// [get](#method.get):
+///
+/// ```rust
+/// # use actix_http::cookie::{Cookie, CookieJar};
+/// let mut jar = CookieJar::new();
+/// jar.add(Cookie::new("a", "one"));
+/// jar.add(Cookie::new("b", "two"));
+///
+/// assert_eq!(jar.get("a").map(|c| c.value()), Some("one"));
+/// assert_eq!(jar.get("b").map(|c| c.value()), Some("two"));
+///
+/// jar.remove(Cookie::named("b"));
+/// assert!(jar.get("b").is_none());
+/// ```
+///
+/// # Deltas
+///
+/// A jar keeps track of any modifications made to it over time. The
+/// modifications are recorded as cookies. The modifications can be retrieved
+/// via [delta](#method.delta). Any new `Cookie` added to a jar via `add`
+/// results in the same `Cookie` appearing in the `delta`; cookies added via
+/// `add_original` do not count towards the delta. Any _original_ cookie that is
+/// removed from a jar results in a "removal" cookie appearing in the delta. A
+/// "removal" cookie is a cookie that a server sends so that the cookie is
+/// removed from the client's machine.
+///
+/// Deltas are typically used to create `Set-Cookie` headers corresponding to
+/// the changes made to a cookie jar over a period of time.
+///
+/// ```rust
+/// # use actix_http::cookie::{Cookie, CookieJar};
+/// let mut jar = CookieJar::new();
+///
+/// // original cookies don't affect the delta
+/// jar.add_original(Cookie::new("original", "value"));
+/// assert_eq!(jar.delta().count(), 0);
+///
+/// // new cookies result in an equivalent `Cookie` in the delta
+/// jar.add(Cookie::new("a", "one"));
+/// jar.add(Cookie::new("b", "two"));
+/// assert_eq!(jar.delta().count(), 2);
+///
+/// // removing an original cookie adds a "removal" cookie to the delta
+/// jar.remove(Cookie::named("original"));
+/// assert_eq!(jar.delta().count(), 3);
+///
+/// // removing a new cookie that was added removes that `Cookie` from the delta
+/// jar.remove(Cookie::named("a"));
+/// assert_eq!(jar.delta().count(), 2);
+/// ```
+#[derive(Default, Debug, Clone)]
+pub struct CookieJar {
+    original_cookies: HashSet<DeltaCookie>,
+    delta_cookies: HashSet<DeltaCookie>,
+}
+
+impl CookieJar {
+    /// Creates an empty cookie jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::CookieJar;
+    ///
+    /// let jar = CookieJar::new();
+    /// assert_eq!(jar.iter().count(), 0);
+    /// ```
+    pub fn new() -> CookieJar {
+        CookieJar::default()
+    }
+
+    /// Returns a reference to the `Cookie` inside this jar with the name
+    /// `name`. If no such cookie exists, returns `None`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// assert!(jar.get("name").is_none());
+    ///
+    /// jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// ```
+    pub fn get(&self, name: &str) -> Option<&Cookie<'static>> {
+        self.delta_cookies
+            .get(name)
+            .or_else(|| self.original_cookies.get(name))
+            .and_then(|c| if !c.removed { Some(&c.cookie) } else { None })
+    }
+
+    /// Adds an "original" `cookie` to this jar. If an original cookie with the
+    /// same name already exists, it is replaced with `cookie`. Cookies added
+    /// with `add` take precedence and are not replaced by this method.
+    ///
+    /// Adding an original cookie does not affect the [delta](#method.delta)
+    /// computation. This method is intended to be used to seed the cookie jar
+    /// with cookies received from a client's HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
+    /// assert_eq!(jar.iter().count(), 2);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, cookie: Cookie<'static>) {
+        self.original_cookies.replace(DeltaCookie::added(cookie));
+    }
+
+    /// Adds `cookie` to this jar. If a cookie with the same name already
+    /// exists, it is replaced with `cookie`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add(Cookie::new("name", "value"));
+    /// jar.add(Cookie::new("second", "two"));
+    ///
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
+    /// assert_eq!(jar.iter().count(), 2);
+    /// assert_eq!(jar.delta().count(), 2);
+    /// ```
+    pub fn add(&mut self, cookie: Cookie<'static>) {
+        self.delta_cookies.replace(DeltaCookie::added(cookie));
+    }
+
+    /// Removes `cookie` from this jar. If an _original_ cookie with the same
+    /// name as `cookie` is present in the jar, a _removal_ cookie will be
+    /// present in the `delta` computation. To properly generate the removal
+    /// cookie, `cookie` must contain the same `path` and `domain` as the cookie
+    /// that was initially set.
+    ///
+    /// A "removal" cookie is a cookie that has the same name as the original
+    /// cookie but has an empty value, a max-age of 0, and an expiration date
+    /// far in the past.
+    ///
+    /// # Example
+    ///
+    /// Removing an _original_ cookie results in a _removal_ cookie:
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    /// use chrono::Duration;
+    ///
+    /// # fn main() {
+    /// let mut jar = CookieJar::new();
+    ///
+    /// // Assume this cookie originally had a path of "/" and domain of "a.b".
+    /// jar.add_original(Cookie::new("name", "value"));
+    ///
+    /// // If the path and domain were set, they must be provided to `remove`.
+    /// jar.remove(Cookie::build("name", "").path("/").domain("a.b").finish());
+    ///
+    /// // The delta will contain the removal cookie.
+    /// let delta: Vec<_> = jar.delta().collect();
+    /// assert_eq!(delta.len(), 1);
+    /// assert_eq!(delta[0].name(), "name");
+    /// assert_eq!(delta[0].max_age(), Some(Duration::seconds(0)));
+    /// # }
+    /// ```
+    ///
+    /// Removing a new cookie does not result in a _removal_ cookie:
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    ///
+    /// jar.remove(Cookie::named("name"));
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn remove(&mut self, mut cookie: Cookie<'static>) {
+        if self.original_cookies.contains(cookie.name()) {
+            cookie.set_value("");
+            cookie.set_max_age(Duration::seconds(0));
+            cookie.set_expires(time::now() - Duration::days(365));
+            self.delta_cookies.replace(DeltaCookie::removed(cookie));
+        } else {
+            self.delta_cookies.remove(cookie.name());
+        }
+    }
+
+    /// Removes `cookie` from this jar completely. This method differs from
+    /// `remove` in that no delta cookie is created under any condition. Neither
+    /// the `delta` nor `iter` methods will return a cookie that is removed
+    /// using this method.
+    ///
+    /// # Example
+    ///
+    /// Removing an _original_ cookie; no _removal_ cookie is generated:
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    /// use chrono::Duration;
+    ///
+    /// # fn main() {
+    /// let mut jar = CookieJar::new();
+    ///
+    /// // Add an original cookie and a new cookie.
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add(Cookie::new("key", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    /// assert_eq!(jar.iter().count(), 2);
+    ///
+    /// // Now force remove the original cookie.
+    /// jar.force_remove(Cookie::new("name", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    /// assert_eq!(jar.iter().count(), 1);
+    ///
+    /// // Now force remove the new cookie.
+    /// jar.force_remove(Cookie::new("key", "value"));
+    /// assert_eq!(jar.delta().count(), 0);
+    /// assert_eq!(jar.iter().count(), 0);
+    /// # }
+    /// ```
+    pub fn force_remove<'a>(&mut self, cookie: Cookie<'a>) {
+        self.original_cookies.remove(cookie.name());
+        self.delta_cookies.remove(cookie.name());
+    }
+
+    /// Removes all cookies from this cookie jar.
+    #[deprecated(
+        since = "0.7.0",
+        note = "calling this method may not remove \
+                all cookies since the path and domain are not specified; use \
+                `remove` instead"
+    )]
+    pub fn clear(&mut self) {
+        self.delta_cookies.clear();
+        for delta in replace(&mut self.original_cookies, HashSet::new()) {
+            self.remove(delta.cookie);
+        }
+    }
+
+    /// Returns an iterator over cookies that represent the changes to this jar
+    /// over time. These cookies can be rendered directly as `Set-Cookie` header
+    /// values to affect the changes made to this jar on the client.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// // Add new cookies.
+    /// jar.add(Cookie::new("new", "third"));
+    /// jar.add(Cookie::new("another", "fourth"));
+    /// jar.add(Cookie::new("yac", "fifth"));
+    ///
+    /// // Remove some cookies.
+    /// jar.remove(Cookie::named("name"));
+    /// jar.remove(Cookie::named("another"));
+    ///
+    /// // Delta contains two new cookies ("new", "yac") and a removal ("name").
+    /// assert_eq!(jar.delta().count(), 3);
+    /// ```
+    pub fn delta(&self) -> Delta {
+        Delta {
+            iter: self.delta_cookies.iter(),
+        }
+    }
+
+    /// Returns an iterator over all of the cookies present in this jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    ///
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// jar.add(Cookie::new("new", "third"));
+    /// jar.add(Cookie::new("another", "fourth"));
+    /// jar.add(Cookie::new("yac", "fifth"));
+    ///
+    /// jar.remove(Cookie::named("name"));
+    /// jar.remove(Cookie::named("another"));
+    ///
+    /// // There are three cookies in the jar: "second", "new", and "yac".
+    /// # assert_eq!(jar.iter().count(), 3);
+    /// for cookie in jar.iter() {
+    ///     match cookie.name() {
+    ///         "second" => assert_eq!(cookie.value(), "two"),
+    ///         "new" => assert_eq!(cookie.value(), "third"),
+    ///         "yac" => assert_eq!(cookie.value(), "fifth"),
+    ///         _ => unreachable!("there are only three cookies in the jar")
+    ///     }
+    /// }
+    /// ```
+    pub fn iter(&self) -> Iter {
+        Iter {
+            delta_cookies: self
+                .delta_cookies
+                .iter()
+                .chain(self.original_cookies.difference(&self.delta_cookies)),
+        }
+    }
+
+    /// Returns a `PrivateJar` with `self` as its parent jar using the key `key`
+    /// to sign/encrypt and verify/decrypt cookies added/retrieved from the
+    /// child jar.
+    ///
+    /// Any modifications to the child jar will be reflected on the parent jar,
+    /// and any retrievals from the child jar will be made from the parent jar.
+    ///
+    /// This method is only available when the `secure` feature is enabled.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a private (signed + encrypted) cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.private(&key).add(Cookie::new("private", "text"));
+    ///
+    /// // The cookie's contents are encrypted.
+    /// assert_ne!(jar.get("private").unwrap().value(), "text");
+    ///
+    /// // They can be decrypted and verified through the child jar.
+    /// assert_eq!(jar.private(&key).get("private").unwrap().value(), "text");
+    ///
+    /// // A tampered with cookie does not validate but still exists.
+    /// let mut cookie = jar.get("private").unwrap().clone();
+    /// jar.add(Cookie::new("private", cookie.value().to_string() + "!"));
+    /// assert!(jar.private(&key).get("private").is_none());
+    /// assert!(jar.get("private").is_some());
+    /// ```
+    #[cfg(feature = "secure-cookies")]
+    pub fn private(&mut self, key: &Key) -> PrivateJar {
+        PrivateJar::new(self, key)
+    }
+
+    /// Returns a `SignedJar` with `self` as its parent jar using the key `key`
+    /// to sign/verify cookies added/retrieved from the child jar.
+    ///
+    /// Any modifications to the child jar will be reflected on the parent jar,
+    /// and any retrievals from the child jar will be made from the parent jar.
+    ///
+    /// This method is only available when the `secure` feature is enabled.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a signed cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.signed(&key).add(Cookie::new("signed", "text"));
+    ///
+    /// // The cookie's contents are signed but still in plaintext.
+    /// assert_ne!(jar.get("signed").unwrap().value(), "text");
+    /// assert!(jar.get("signed").unwrap().value().contains("text"));
+    ///
+    /// // They can be verified through the child jar.
+    /// assert_eq!(jar.signed(&key).get("signed").unwrap().value(), "text");
+    ///
+    /// // A tampered with cookie does not validate but still exists.
+    /// let mut cookie = jar.get("signed").unwrap().clone();
+    /// jar.add(Cookie::new("signed", cookie.value().to_string() + "!"));
+    /// assert!(jar.signed(&key).get("signed").is_none());
+    /// assert!(jar.get("signed").is_some());
+    /// ```
+    #[cfg(feature = "secure-cookies")]
+    pub fn signed(&mut self, key: &Key) -> SignedJar {
+        SignedJar::new(self, key)
+    }
+}
+
+use std::collections::hash_set::Iter as HashSetIter;
+
+/// Iterator over the changes to a cookie jar.
+pub struct Delta<'a> {
+    iter: HashSetIter<'a, DeltaCookie>,
+}
+
+impl<'a> Iterator for Delta<'a> {
+    type Item = &'a Cookie<'static>;
+
+    fn next(&mut self) -> Option<&'a Cookie<'static>> {
+        self.iter.next().map(|c| &c.cookie)
+    }
+}
+
+use std::collections::hash_map::RandomState;
+use std::collections::hash_set::Difference;
+use std::iter::Chain;
+
+/// Iterator over all of the cookies in a jar.
+pub struct Iter<'a> {
+    delta_cookies:
+        Chain<HashSetIter<'a, DeltaCookie>, Difference<'a, DeltaCookie, RandomState>>,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a Cookie<'static>;
+
+    fn next(&mut self) -> Option<&'a Cookie<'static>> {
+        for cookie in self.delta_cookies.by_ref() {
+            if !cookie.removed {
+                return Some(&*cookie);
+            }
+        }
+
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[cfg(feature = "secure-cookies")]
+    use super::Key;
+    use super::{Cookie, CookieJar};
+
+    #[test]
+    #[allow(deprecated)]
+    fn simple() {
+        let mut c = CookieJar::new();
+
+        c.add(Cookie::new("test", ""));
+        c.add(Cookie::new("test2", ""));
+        c.remove(Cookie::named("test"));
+
+        assert!(c.get("test").is_none());
+        assert!(c.get("test2").is_some());
+
+        c.add(Cookie::new("test3", ""));
+        c.clear();
+
+        assert!(c.get("test").is_none());
+        assert!(c.get("test2").is_none());
+        assert!(c.get("test3").is_none());
+    }
+
+    #[test]
+    fn jar_is_send() {
+        fn is_send<T: Send>(_: T) -> bool {
+            true
+        }
+
+        assert!(is_send(CookieJar::new()))
+    }
+
+    #[test]
+    #[cfg(feature = "secure-cookies")]
+    fn iter() {
+        let key = Key::generate();
+        let mut c = CookieJar::new();
+
+        c.add_original(Cookie::new("original", "original"));
+
+        c.add(Cookie::new("test", "test"));
+        c.add(Cookie::new("test2", "test2"));
+        c.add(Cookie::new("test3", "test3"));
+        assert_eq!(c.iter().count(), 4);
+
+        c.signed(&key).add(Cookie::new("signed", "signed"));
+        c.private(&key).add(Cookie::new("encrypted", "encrypted"));
+        assert_eq!(c.iter().count(), 6);
+
+        c.remove(Cookie::named("test"));
+        assert_eq!(c.iter().count(), 5);
+
+        c.remove(Cookie::named("signed"));
+        c.remove(Cookie::named("test2"));
+        assert_eq!(c.iter().count(), 3);
+
+        c.add(Cookie::new("test2", "test2"));
+        assert_eq!(c.iter().count(), 4);
+
+        c.remove(Cookie::named("test2"));
+        assert_eq!(c.iter().count(), 3);
+    }
+
+    #[test]
+    #[cfg(feature = "secure-cookies")]
+    fn delta() {
+        use chrono::Duration;
+        use std::collections::HashMap;
+
+        let mut c = CookieJar::new();
+
+        c.add_original(Cookie::new("original", "original"));
+        c.add_original(Cookie::new("original1", "original1"));
+
+        c.add(Cookie::new("test", "test"));
+        c.add(Cookie::new("test2", "test2"));
+        c.add(Cookie::new("test3", "test3"));
+        c.add(Cookie::new("test4", "test4"));
+
+        c.remove(Cookie::named("test"));
+        c.remove(Cookie::named("original"));
+
+        assert_eq!(c.delta().count(), 4);
+
+        let names: HashMap<_, _> = c.delta().map(|c| (c.name(), c.max_age())).collect();
+
+        assert!(names.get("test2").unwrap().is_none());
+        assert!(names.get("test3").unwrap().is_none());
+        assert!(names.get("test4").unwrap().is_none());
+        assert_eq!(names.get("original").unwrap(), &Some(Duration::seconds(0)));
+    }
+
+    #[test]
+    fn replace_original() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("original_a", "a"));
+        jar.add_original(Cookie::new("original_b", "b"));
+        assert_eq!(jar.get("original_a").unwrap().value(), "a");
+
+        jar.add(Cookie::new("original_a", "av2"));
+        assert_eq!(jar.get("original_a").unwrap().value(), "av2");
+    }
+
+    #[test]
+    fn empty_delta() {
+        let mut jar = CookieJar::new();
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 1);
+    }
+
+    #[test]
+    fn add_remove_add() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        // The cookie's been deleted. Another original doesn't change that.
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+    }
+
+    #[test]
+    fn replace_remove() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+    }
+
+    #[test]
+    fn remove_with_path() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::build("name", "val").finish());
+        assert_eq!(jar.iter().count(), 1);
+        assert_eq!(jar.delta().count(), 0);
+        assert_eq!(jar.iter().filter(|c| c.path().is_none()).count(), 1);
+
+        jar.remove(Cookie::build("name", "").path("/").finish());
+        assert_eq!(jar.iter().count(), 0);
+        assert_eq!(jar.delta().count(), 1);
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().filter(|c| c.path() == Some("/")).count(), 1);
+    }
+}
--- a/actix-http/src/cookie/mod.rs
+++ b/actix-http/src/cookie/mod.rs
--- a/actix-http/src/cookie/parse.rs
+++ b/actix-http/src/cookie/parse.rs
@ -0,0 +1,425 @@
+use std::borrow::Cow;
+use std::cmp;
+use std::convert::From;
+use std::error::Error;
+use std::fmt;
+use std::str::Utf8Error;
+
+use chrono::Duration;
+use percent_encoding::percent_decode;
+
+use super::{Cookie, CookieStr, SameSite};
+
+/// Enum corresponding to a parsing error.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum ParseError {
+    /// The cookie did not contain a name/value pair.
+    MissingPair,
+    /// The cookie's name was empty.
+    EmptyName,
+    /// Decoding the cookie's name or value resulted in invalid UTF-8.
+    Utf8Error(Utf8Error),
+    /// It is discouraged to exhaustively match on this enum as its variants may
+    /// grow without a breaking-change bump in version numbers.
+    #[doc(hidden)]
+    __Nonexhasutive,
+}
+
+impl ParseError {
+    /// Returns a description of this error as a string
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            ParseError::MissingPair => "the cookie is missing a name/value pair",
+            ParseError::EmptyName => "the cookie's name is empty",
+            ParseError::Utf8Error(_) => {
+                "decoding the cookie's name or value resulted in invalid UTF-8"
+            }
+            ParseError::__Nonexhasutive => unreachable!("__Nonexhasutive ParseError"),
+        }
+    }
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl From<Utf8Error> for ParseError {
+    fn from(error: Utf8Error) -> ParseError {
+        ParseError::Utf8Error(error)
+    }
+}
+
+impl Error for ParseError {
+    fn description(&self) -> &str {
+        self.as_str()
+    }
+}
+
+fn indexes_of(needle: &str, haystack: &str) -> Option<(usize, usize)> {
+    let haystack_start = haystack.as_ptr() as usize;
+    let needle_start = needle.as_ptr() as usize;
+
+    if needle_start < haystack_start {
+        return None;
+    }
+
+    if (needle_start + needle.len()) > (haystack_start + haystack.len()) {
+        return None;
+    }
+
+    let start = needle_start - haystack_start;
+    let end = start + needle.len();
+    Some((start, end))
+}
+
+fn name_val_decoded(
+    name: &str,
+    val: &str,
+) -> Result<(CookieStr, CookieStr), ParseError> {
+    let decoded_name = percent_decode(name.as_bytes()).decode_utf8()?;
+    let decoded_value = percent_decode(val.as_bytes()).decode_utf8()?;
+    let name = CookieStr::Concrete(Cow::Owned(decoded_name.into_owned()));
+    let val = CookieStr::Concrete(Cow::Owned(decoded_value.into_owned()));
+
+    Ok((name, val))
+}
+
+// This function does the real parsing but _does not_ set the `cookie_string` in
+// the returned cookie object. This only exists so that the borrow to `s` is
+// returned at the end of the call, allowing the `cookie_string` field to be
+// set in the outer `parse` function.
+fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
+    let mut attributes = s.split(';');
+    let key_value = match attributes.next() {
+        Some(s) => s,
+        _ => panic!(),
+    };
+
+    // Determine the name = val.
+    let (name, value) = match key_value.find('=') {
+        Some(i) => (key_value[..i].trim(), key_value[(i + 1)..].trim()),
+        None => return Err(ParseError::MissingPair),
+    };
+
+    if name.is_empty() {
+        return Err(ParseError::EmptyName);
+    }
+
+    // Create a cookie with all of the defaults. We'll fill things in while we
+    // iterate through the parameters below.
+    let (name, value) = if decode {
+        name_val_decoded(name, value)?
+    } else {
+        let name_indexes = indexes_of(name, s).expect("name sub");
+        let value_indexes = indexes_of(value, s).expect("value sub");
+        let name = CookieStr::Indexed(name_indexes.0, name_indexes.1);
+        let value = CookieStr::Indexed(value_indexes.0, value_indexes.1);
+
+        (name, value)
+    };
+
+    let mut cookie = Cookie {
+        name,
+        value,
+        cookie_string: None,
+        expires: None,
+        max_age: None,
+        domain: None,
+        path: None,
+        secure: None,
+        http_only: None,
+        same_site: None,
+    };
+
+    for attr in attributes {
+        let (key, value) = match attr.find('=') {
+            Some(i) => (attr[..i].trim(), Some(attr[(i + 1)..].trim())),
+            None => (attr.trim(), None),
+        };
+
+        match (&*key.to_ascii_lowercase(), value) {
+            ("secure", _) => cookie.secure = Some(true),
+            ("httponly", _) => cookie.http_only = Some(true),
+            ("max-age", Some(v)) => {
+                // See RFC 6265 Section 5.2.2, negative values indicate that the
+                // earliest possible expiration time should be used, so set the
+                // max age as 0 seconds.
+                cookie.max_age = match v.parse() {
+                    Ok(val) if val <= 0 => Some(Duration::zero()),
+                    Ok(val) => {
+                        // Don't panic if the max age seconds is greater than what's supported by
+                        // `Duration`.
+                        let val = cmp::min(val, Duration::max_value().num_seconds());
+                        Some(Duration::seconds(val))
+                    }
+                    Err(_) => continue,
+                };
+            }
+            ("domain", Some(mut domain)) if !domain.is_empty() => {
+                if domain.starts_with('.') {
+                    domain = &domain[1..];
+                }
+
+                let (i, j) = indexes_of(domain, s).expect("domain sub");
+                cookie.domain = Some(CookieStr::Indexed(i, j));
+            }
+            ("path", Some(v)) => {
+                let (i, j) = indexes_of(v, s).expect("path sub");
+                cookie.path = Some(CookieStr::Indexed(i, j));
+            }
+            ("samesite", Some(v)) => {
+                if v.eq_ignore_ascii_case("strict") {
+                    cookie.same_site = Some(SameSite::Strict);
+                } else if v.eq_ignore_ascii_case("lax") {
+                    cookie.same_site = Some(SameSite::Lax);
+                } else {
+                    // We do nothing here, for now. When/if the `SameSite`
+                    // attribute becomes standard, the spec says that we should
+                    // ignore this cookie, i.e, fail to parse it, when an
+                    // invalid value is passed in. The draft is at
+                    // http://httpwg.org/http-extensions/draft-ietf-httpbis-cookie-same-site.html.
+                }
+            }
+            ("expires", Some(v)) => {
+                // Try strptime with three date formats according to
+                // http://tools.ietf.org/html/rfc2616#section-3.3.1. Try
+                // additional ones as encountered in the real world.
+                let tm = time::strptime(v, "%a, %d %b %Y %H:%M:%S %Z")
+                    .or_else(|_| time::strptime(v, "%A, %d-%b-%y %H:%M:%S %Z"))
+                    .or_else(|_| time::strptime(v, "%a, %d-%b-%Y %H:%M:%S %Z"))
+                    .or_else(|_| time::strptime(v, "%a %b %d %H:%M:%S %Y"));
+
+                if let Ok(time) = tm {
+                    cookie.expires = Some(time)
+                }
+            }
+            _ => {
+                // We're going to be permissive here. If we have no idea what
+                // this is, then it's something nonstandard. We're not going to
+                // store it (because it's not compliant), but we're also not
+                // going to emit an error.
+            }
+        }
+    }
+
+    Ok(cookie)
+}
+
+pub fn parse_cookie<'c, S>(cow: S, decode: bool) -> Result<Cookie<'c>, ParseError>
+where
+    S: Into<Cow<'c, str>>,
+{
+    let s = cow.into();
+    let mut cookie = parse_inner(&s, decode)?;
+    cookie.cookie_string = Some(s);
+    Ok(cookie)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Cookie, SameSite};
+    use chrono::Duration;
+    use time::strptime;
+
+    macro_rules! assert_eq_parse {
+        ($string:expr, $expected:expr) => {
+            let cookie = match Cookie::parse($string) {
+                Ok(cookie) => cookie,
+                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
+            };
+
+            assert_eq!(cookie, $expected);
+        };
+    }
+
+    macro_rules! assert_ne_parse {
+        ($string:expr, $expected:expr) => {
+            let cookie = match Cookie::parse($string) {
+                Ok(cookie) => cookie,
+                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
+            };
+
+            assert_ne!(cookie, $expected);
+        };
+    }
+
+    #[test]
+    fn parse_same_site() {
+        let expected = Cookie::build("foo", "bar")
+            .same_site(SameSite::Lax)
+            .finish();
+
+        assert_eq_parse!("foo=bar; SameSite=Lax", expected);
+        assert_eq_parse!("foo=bar; SameSite=lax", expected);
+        assert_eq_parse!("foo=bar; SameSite=LAX", expected);
+        assert_eq_parse!("foo=bar; samesite=Lax", expected);
+        assert_eq_parse!("foo=bar; SAMESITE=Lax", expected);
+
+        let expected = Cookie::build("foo", "bar")
+            .same_site(SameSite::Strict)
+            .finish();
+
+        assert_eq_parse!("foo=bar; SameSite=Strict", expected);
+        assert_eq_parse!("foo=bar; SameSITE=Strict", expected);
+        assert_eq_parse!("foo=bar; SameSite=strict", expected);
+        assert_eq_parse!("foo=bar; SameSite=STrICT", expected);
+        assert_eq_parse!("foo=bar; SameSite=STRICT", expected);
+    }
+
+    #[test]
+    fn parse() {
+        assert!(Cookie::parse("bar").is_err());
+        assert!(Cookie::parse("=bar").is_err());
+        assert!(Cookie::parse(" =bar").is_err());
+        assert!(Cookie::parse("foo=").is_ok());
+
+        let expected = Cookie::build("foo", "bar=baz").finish();
+        assert_eq_parse!("foo=bar=baz", expected);
+
+        let mut expected = Cookie::build("foo", "bar").finish();
+        assert_eq_parse!("foo=bar", expected);
+        assert_eq_parse!("foo = bar", expected);
+        assert_eq_parse!(" foo=bar ", expected);
+        assert_eq_parse!(" foo=bar ;Domain=", expected);
+        assert_eq_parse!(" foo=bar ;Domain= ", expected);
+        assert_eq_parse!(" foo=bar ;Ignored", expected);
+
+        let mut unexpected = Cookie::build("foo", "bar").http_only(false).finish();
+        assert_ne_parse!(" foo=bar ;HttpOnly", unexpected);
+        assert_ne_parse!(" foo=bar; httponly", unexpected);
+
+        expected.set_http_only(true);
+        assert_eq_parse!(" foo=bar ;HttpOnly", expected);
+        assert_eq_parse!(" foo=bar ;httponly", expected);
+        assert_eq_parse!(" foo=bar ;HTTPONLY=whatever", expected);
+        assert_eq_parse!(" foo=bar ; sekure; HTTPONLY", expected);
+
+        expected.set_secure(true);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure=aaaa", expected);
+
+        unexpected.set_http_only(true);
+        unexpected.set_secure(true);
+        assert_ne_parse!(" foo=bar ;HttpOnly; skeure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; =secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly;", unexpected);
+
+        unexpected.set_secure(false);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+
+        expected.set_max_age(Duration::zero());
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=0", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0 ", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=-1", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", expected);
+
+        expected.set_max_age(Duration::minutes(1));
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=60", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age =   60 ", expected);
+
+        expected.set_max_age(Duration::seconds(4));
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 4 ", expected);
+
+        unexpected.set_secure(true);
+        unexpected.set_max_age(Duration::minutes(1));
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=122", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 38 ", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=51", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0", unexpected);
+
+        expected.set_path("/");
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/", expected);
+
+        expected.set_path("/foo");
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path = /foo", expected);
+
+        unexpected.set_max_age(Duration::seconds(4));
+        unexpected.set_path("/bar");
+        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", unexpected);
+        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/baz", unexpected);
+
+        expected.set_domain("www.foo.com");
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=www.foo.com",
+            expected
+        );
+
+        expected.set_domain("foo.com");
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com",
+            expected
+        );
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=FOO.COM",
+            expected
+        );
+
+        unexpected.set_path("/foo");
+        unexpected.set_domain("bar.com");
+        assert_ne_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com",
+            unexpected
+        );
+        assert_ne_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=FOO.COM",
+            unexpected
+        );
+
+        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
+        let expires = strptime(time_str, "%a, %d %b %Y %H:%M:%S %Z").unwrap();
+        expected.set_expires(expires);
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
+            expected
+        );
+
+        unexpected.set_domain("foo.com");
+        let bad_expires = strptime(time_str, "%a, %d %b %Y %H:%S:%M %Z").unwrap();
+        expected.set_expires(bad_expires);
+        assert_ne_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
+            unexpected
+        );
+    }
+
+    #[test]
+    fn odd_characters() {
+        let expected = Cookie::new("foo", "b%2Fr");
+        assert_eq_parse!("foo=b%2Fr", expected);
+    }
+
+    #[test]
+    fn odd_characters_encoded() {
+        let expected = Cookie::new("foo", "b/r");
+        let cookie = match Cookie::parse_encoded("foo=b%2Fr") {
+            Ok(cookie) => cookie,
+            Err(e) => panic!("Failed to parse: {:?}", e),
+        };
+
+        assert_eq!(cookie, expected);
+    }
+
+    #[test]
+    fn do_not_panic_on_large_max_ages() {
+        let max_seconds = Duration::max_value().num_seconds();
+        let expected = Cookie::build("foo", "bar").max_age(max_seconds).finish();
+        assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", max_seconds + 1), expected);
+    }
+}
--- a/actix-http/src/cookie/secure/key.rs
+++ b/actix-http/src/cookie/secure/key.rs
@ -0,0 +1,180 @@
+use ring::digest::{Algorithm, SHA256};
+use ring::hkdf::expand;
+use ring::hmac::SigningKey;
+use ring::rand::{SecureRandom, SystemRandom};
+
+use super::private::KEY_LEN as PRIVATE_KEY_LEN;
+use super::signed::KEY_LEN as SIGNED_KEY_LEN;
+
+static HKDF_DIGEST: &'static Algorithm = &SHA256;
+const KEYS_INFO: &'static str = "COOKIE;SIGNED:HMAC-SHA256;PRIVATE:AEAD-AES-256-GCM";
+
+/// A cryptographic master key for use with `Signed` and/or `Private` jars.
+///
+/// This structure encapsulates secure, cryptographic keys for use with both
+/// [PrivateJar](struct.PrivateJar.html) and [SignedJar](struct.SignedJar.html).
+/// It can be derived from a single master key via
+/// [from_master](#method.from_master) or generated from a secure random source
+/// via [generate](#method.generate). A single instance of `Key` can be used for
+/// both a `PrivateJar` and a `SignedJar`.
+///
+/// This type is only available when the `secure` feature is enabled.
+#[derive(Clone)]
+pub struct Key {
+    signing_key: [u8; SIGNED_KEY_LEN],
+    encryption_key: [u8; PRIVATE_KEY_LEN],
+}
+
+impl Key {
+    /// Derives new signing/encryption keys from a master key.
+    ///
+    /// The master key must be at least 256-bits (32 bytes). For security, the
+    /// master key _must_ be cryptographically random. The keys are derived
+    /// deterministically from the master key.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `key` is less than 32 bytes in length.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// # /*
+    /// let master_key = { /* a cryptographically random key >= 32 bytes */ };
+    /// # */
+    /// # let master_key: &Vec<u8> = &(0..32).collect();
+    ///
+    /// let key = Key::from_master(master_key);
+    /// ```
+    pub fn from_master(key: &[u8]) -> Key {
+        if key.len() < 32 {
+            panic!(
+                "bad master key length: expected at least 32 bytes, found {}",
+                key.len()
+            );
+        }
+
+        // Expand the user's key into two.
+        let prk = SigningKey::new(HKDF_DIGEST, key);
+        let mut both_keys = [0; SIGNED_KEY_LEN + PRIVATE_KEY_LEN];
+        expand(&prk, KEYS_INFO.as_bytes(), &mut both_keys);
+
+        // Copy the keys into their respective arrays.
+        let mut signing_key = [0; SIGNED_KEY_LEN];
+        let mut encryption_key = [0; PRIVATE_KEY_LEN];
+        signing_key.copy_from_slice(&both_keys[..SIGNED_KEY_LEN]);
+        encryption_key.copy_from_slice(&both_keys[SIGNED_KEY_LEN..]);
+
+        Key {
+            signing_key,
+            encryption_key,
+        }
+    }
+
+    /// Generates signing/encryption keys from a secure, random source. Keys are
+    /// generated nondeterministically.
+    ///
+    /// # Panics
+    ///
+    /// Panics if randomness cannot be retrieved from the operating system. See
+    /// [try_generate](#method.try_generate) for a non-panicking version.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// ```
+    pub fn generate() -> Key {
+        Self::try_generate().expect("failed to generate `Key` from randomness")
+    }
+
+    /// Attempts to generate signing/encryption keys from a secure, random
+    /// source. Keys are generated nondeterministically. If randomness cannot be
+    /// retrieved from the underlying operating system, returns `None`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::try_generate();
+    /// ```
+    pub fn try_generate() -> Option<Key> {
+        let mut sign_key = [0; SIGNED_KEY_LEN];
+        let mut enc_key = [0; PRIVATE_KEY_LEN];
+
+        let rng = SystemRandom::new();
+        if rng.fill(&mut sign_key).is_err() || rng.fill(&mut enc_key).is_err() {
+            return None;
+        }
+
+        Some(Key {
+            signing_key: sign_key,
+            encryption_key: enc_key,
+        })
+    }
+
+    /// Returns the raw bytes of a key suitable for signing cookies.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// let signing_key = key.signing();
+    /// ```
+    pub fn signing(&self) -> &[u8] {
+        &self.signing_key[..]
+    }
+
+    /// Returns the raw bytes of a key suitable for encrypting cookies.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// let encryption_key = key.encryption();
+    /// ```
+    pub fn encryption(&self) -> &[u8] {
+        &self.encryption_key[..]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Key;
+
+    #[test]
+    fn deterministic_from_master() {
+        let master_key: Vec<u8> = (0..32).collect();
+
+        let key_a = Key::from_master(&master_key);
+        let key_b = Key::from_master(&master_key);
+
+        assert_eq!(key_a.signing(), key_b.signing());
+        assert_eq!(key_a.encryption(), key_b.encryption());
+        assert_ne!(key_a.encryption(), key_a.signing());
+
+        let master_key_2: Vec<u8> = (32..64).collect();
+        let key_2 = Key::from_master(&master_key_2);
+
+        assert_ne!(key_2.signing(), key_a.signing());
+        assert_ne!(key_2.encryption(), key_a.encryption());
+    }
+
+    #[test]
+    fn non_deterministic_generate() {
+        let key_a = Key::generate();
+        let key_b = Key::generate();
+
+        assert_ne!(key_a.signing(), key_b.signing());
+        assert_ne!(key_a.encryption(), key_b.encryption());
+    }
+}
--- a/actix-http/src/cookie/secure/macros.rs
+++ b/actix-http/src/cookie/secure/macros.rs
@ -0,0 +1,40 @@
+#[cfg(test)]
+macro_rules! assert_simple_behaviour {
+    ($clear:expr, $secure:expr) => {{
+        assert_eq!($clear.iter().count(), 0);
+
+        $secure.add(Cookie::new("name", "val"));
+        assert_eq!($clear.iter().count(), 1);
+        assert_eq!($secure.get("name").unwrap().value(), "val");
+        assert_ne!($clear.get("name").unwrap().value(), "val");
+
+        $secure.add(Cookie::new("another", "two"));
+        assert_eq!($clear.iter().count(), 2);
+
+        $clear.remove(Cookie::named("another"));
+        assert_eq!($clear.iter().count(), 1);
+
+        $secure.remove(Cookie::named("name"));
+        assert_eq!($clear.iter().count(), 0);
+    }};
+}
+
+#[cfg(test)]
+macro_rules! assert_secure_behaviour {
+    ($clear:expr, $secure:expr) => {{
+        $secure.add(Cookie::new("secure", "secure"));
+        assert!($clear.get("secure").unwrap().value() != "secure");
+        assert!($secure.get("secure").unwrap().value() == "secure");
+
+        let mut cookie = $clear.get("secure").unwrap().clone();
+        let new_val = format!("{}l", cookie.value());
+        cookie.set_value(new_val);
+        $clear.add(cookie);
+        assert!($secure.get("secure").is_none());
+
+        let mut cookie = $clear.get("secure").unwrap().clone();
+        cookie.set_value("foobar");
+        $clear.add(cookie);
+        assert!($secure.get("secure").is_none());
+    }};
+}
--- a/actix-http/src/cookie/secure/mod.rs
+++ b/actix-http/src/cookie/secure/mod.rs
@ -0,0 +1,10 @@
+//! Fork of https://github.com/alexcrichton/cookie-rs
+#[macro_use]
+mod macros;
+mod key;
+mod private;
+mod signed;
+
+pub use self::key::*;
+pub use self::private::*;
+pub use self::signed::*;
--- a/actix-http/src/cookie/secure/private.rs
+++ b/actix-http/src/cookie/secure/private.rs
@ -0,0 +1,269 @@
+use std::str;
+
+use log::warn;
+use ring::aead::{open_in_place, seal_in_place, Aad, Algorithm, Nonce, AES_256_GCM};
+use ring::aead::{OpeningKey, SealingKey};
+use ring::rand::{SecureRandom, SystemRandom};
+
+use super::Key;
+use crate::cookie::{Cookie, CookieJar};
+
+// Keep these in sync, and keep the key len synced with the `private` docs as
+// well as the `KEYS_INFO` const in secure::Key.
+static ALGO: &'static Algorithm = &AES_256_GCM;
+const NONCE_LEN: usize = 12;
+pub const KEY_LEN: usize = 32;
+
+/// A child cookie jar that provides authenticated encryption for its cookies.
+///
+/// A _private_ child jar signs and encrypts all the cookies added to it and
+/// verifies and decrypts cookies retrieved from it. Any cookies stored in a
+/// `PrivateJar` are simultaneously assured confidentiality, integrity, and
+/// authenticity. In other words, clients cannot discover nor tamper with the
+/// contents of a cookie, nor can they fabricate cookie data.
+///
+/// This type is only available when the `secure` feature is enabled.
+pub struct PrivateJar<'a> {
+    parent: &'a mut CookieJar,
+    key: [u8; KEY_LEN],
+}
+
+impl<'a> PrivateJar<'a> {
+    /// Creates a new child `PrivateJar` with parent `parent` and key `key`.
+    /// This method is typically called indirectly via the `signed` method of
+    /// `CookieJar`.
+    #[doc(hidden)]
+    pub fn new(parent: &'a mut CookieJar, key: &Key) -> PrivateJar<'a> {
+        let mut key_array = [0u8; KEY_LEN];
+        key_array.copy_from_slice(key.encryption());
+        PrivateJar {
+            parent,
+            key: key_array,
+        }
+    }
+
+    /// Given a sealed value `str` and a key name `name`, where the nonce is
+    /// prepended to the original value and then both are Base64 encoded,
+    /// verifies and decrypts the sealed value and returns it. If there's a
+    /// problem, returns an `Err` with a string describing the issue.
+    fn unseal(&self, name: &str, value: &str) -> Result<String, &'static str> {
+        let mut data = base64::decode(value).map_err(|_| "bad base64 value")?;
+        if data.len() <= NONCE_LEN {
+            return Err("length of decoded data is <= NONCE_LEN");
+        }
+
+        let ad = Aad::from(name.as_bytes());
+        let key = OpeningKey::new(ALGO, &self.key).expect("opening key");
+        let (nonce, sealed) = data.split_at_mut(NONCE_LEN);
+        let nonce =
+            Nonce::try_assume_unique_for_key(nonce).expect("invalid length of `nonce`");
+        let unsealed = open_in_place(&key, nonce, ad, 0, sealed)
+            .map_err(|_| "invalid key/nonce/value: bad seal")?;
+
+        if let Ok(unsealed_utf8) = str::from_utf8(unsealed) {
+            Ok(unsealed_utf8.to_string())
+        } else {
+            warn!(
+                "Private cookie does not have utf8 content!
+It is likely the secret key used to encrypt them has been leaked.
+Please change it as soon as possible."
+            );
+            Err("bad unsealed utf8")
+        }
+    }
+
+    /// Returns a reference to the `Cookie` inside this jar with the name `name`
+    /// and authenticates and decrypts the cookie's value, returning a `Cookie`
+    /// with the decrypted value. If the cookie cannot be found, or the cookie
+    /// fails to authenticate or decrypt, `None` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut private_jar = jar.private(&key);
+    /// assert!(private_jar.get("name").is_none());
+    ///
+    /// private_jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(private_jar.get("name").unwrap().value(), "value");
+    /// ```
+    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
+        if let Some(cookie_ref) = self.parent.get(name) {
+            let mut cookie = cookie_ref.clone();
+            if let Ok(value) = self.unseal(name, cookie.value()) {
+                cookie.set_value(value);
+                return Some(cookie);
+            }
+        }
+
+        None
+    }
+
+    /// Adds `cookie` to the parent jar. The cookie's value is encrypted with
+    /// authenticated encryption assuring confidentiality, integrity, and
+    /// authenticity.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.private(&key).add(Cookie::new("name", "value"));
+    ///
+    /// assert_ne!(jar.get("name").unwrap().value(), "value");
+    /// assert_eq!(jar.private(&key).get("name").unwrap().value(), "value");
+    /// ```
+    pub fn add(&mut self, mut cookie: Cookie<'static>) {
+        self.encrypt_cookie(&mut cookie);
+
+        // Add the sealed cookie to the parent.
+        self.parent.add(cookie);
+    }
+
+    /// Adds an "original" `cookie` to parent jar. The cookie's value is
+    /// encrypted with authenticated encryption assuring confidentiality,
+    /// integrity, and authenticity. Adding an original cookie does not affect
+    /// the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
+    /// computation. This method is intended to be used to seed the cookie jar
+    /// with cookies received from a client's HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.private(&key).add_original(Cookie::new("name", "value"));
+    ///
+    /// assert_eq!(jar.iter().count(), 1);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
+        self.encrypt_cookie(&mut cookie);
+
+        // Add the sealed cookie to the parent.
+        self.parent.add_original(cookie);
+    }
+
+    /// Encrypts the cookie's value with
+    /// authenticated encryption assuring confidentiality, integrity, and authenticity.
+    fn encrypt_cookie(&self, cookie: &mut Cookie) {
+        let name = cookie.name().as_bytes();
+        let value = cookie.value().as_bytes();
+        let data = encrypt_name_value(name, value, &self.key);
+
+        // Base64 encode the nonce and encrypted value.
+        let sealed_value = base64::encode(&data);
+        cookie.set_value(sealed_value);
+    }
+
+    /// Removes `cookie` from the parent jar.
+    ///
+    /// For correct removal, the passed in `cookie` must contain the same `path`
+    /// and `domain` as the cookie that was initially set.
+    ///
+    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
+    /// details.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut private_jar = jar.private(&key);
+    ///
+    /// private_jar.add(Cookie::new("name", "value"));
+    /// assert!(private_jar.get("name").is_some());
+    ///
+    /// private_jar.remove(Cookie::named("name"));
+    /// assert!(private_jar.get("name").is_none());
+    /// ```
+    pub fn remove(&mut self, cookie: Cookie<'static>) {
+        self.parent.remove(cookie);
+    }
+}
+
+fn encrypt_name_value(name: &[u8], value: &[u8], key: &[u8]) -> Vec<u8> {
+    // Create the `SealingKey` structure.
+    let key = SealingKey::new(ALGO, key).expect("sealing key creation");
+
+    // Create a vec to hold the [nonce | cookie value | overhead].
+    let overhead = ALGO.tag_len();
+    let mut data = vec![0; NONCE_LEN + value.len() + overhead];
+
+    // Randomly generate the nonce, then copy the cookie value as input.
+    let (nonce, in_out) = data.split_at_mut(NONCE_LEN);
+    SystemRandom::new()
+        .fill(nonce)
+        .expect("couldn't random fill nonce");
+    in_out[..value.len()].copy_from_slice(value);
+    let nonce =
+        Nonce::try_assume_unique_for_key(nonce).expect("invalid length of `nonce`");
+
+    // Use cookie's name as associated data to prevent value swapping.
+    let ad = Aad::from(name);
+
+    // Perform the actual sealing operation and get the output length.
+    let output_len =
+        seal_in_place(&key, nonce, ad, in_out, overhead).expect("in-place seal");
+
+    // Remove the overhead and return the sealed content.
+    data.truncate(NONCE_LEN + output_len);
+    data
+}
+
+#[cfg(test)]
+mod test {
+    use super::{encrypt_name_value, Cookie, CookieJar, Key};
+
+    #[test]
+    fn simple() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_simple_behaviour!(jar, jar.private(&key));
+    }
+
+    #[test]
+    fn private() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_secure_behaviour!(jar, jar.private(&key));
+    }
+
+    #[test]
+    fn non_utf8() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+
+        let name = "malicious";
+        let mut assert_non_utf8 = |value: &[u8]| {
+            let sealed = encrypt_name_value(name.as_bytes(), value, &key.encryption());
+            let encoded = base64::encode(&sealed);
+            assert_eq!(
+                jar.private(&key).unseal(name, &encoded),
+                Err("bad unsealed utf8")
+            );
+            jar.add(Cookie::new(name, encoded));
+            assert_eq!(jar.private(&key).get(name), None);
+        };
+
+        assert_non_utf8(&[0x72, 0xfb, 0xdf, 0x74]); // rûst in ISO/IEC 8859-1
+
+        let mut malicious =
+            String::from(r#"{"id":"abc123??%X","admin":true}"#).into_bytes();
+        malicious[8] |= 0b1100_0000;
+        malicious[9] |= 0b1100_0000;
+        assert_non_utf8(&malicious);
+    }
+}
--- a/actix-http/src/cookie/secure/signed.rs
+++ b/actix-http/src/cookie/secure/signed.rs
@ -0,0 +1,185 @@
+use ring::digest::{Algorithm, SHA256};
+use ring::hmac::{sign, verify_with_own_key as verify, SigningKey};
+
+use super::Key;
+use crate::cookie::{Cookie, CookieJar};
+
+// Keep these in sync, and keep the key len synced with the `signed` docs as
+// well as the `KEYS_INFO` const in secure::Key.
+static HMAC_DIGEST: &'static Algorithm = &SHA256;
+const BASE64_DIGEST_LEN: usize = 44;
+pub const KEY_LEN: usize = 32;
+
+/// A child cookie jar that authenticates its cookies.
+///
+/// A _signed_ child jar signs all the cookies added to it and verifies cookies
+/// retrieved from it. Any cookies stored in a `SignedJar` are assured integrity
+/// and authenticity. In other words, clients cannot tamper with the contents of
+/// a cookie nor can they fabricate cookie values, but the data is visible in
+/// plaintext.
+///
+/// This type is only available when the `secure` feature is enabled.
+pub struct SignedJar<'a> {
+    parent: &'a mut CookieJar,
+    key: SigningKey,
+}
+
+impl<'a> SignedJar<'a> {
+    /// Creates a new child `SignedJar` with parent `parent` and key `key`. This
+    /// method is typically called indirectly via the `signed` method of
+    /// `CookieJar`.
+    #[doc(hidden)]
+    pub fn new(parent: &'a mut CookieJar, key: &Key) -> SignedJar<'a> {
+        SignedJar {
+            parent,
+            key: SigningKey::new(HMAC_DIGEST, key.signing()),
+        }
+    }
+
+    /// Given a signed value `str` where the signature is prepended to `value`,
+    /// verifies the signed value and returns it. If there's a problem, returns
+    /// an `Err` with a string describing the issue.
+    fn verify(&self, cookie_value: &str) -> Result<String, &'static str> {
+        if cookie_value.len() < BASE64_DIGEST_LEN {
+            return Err("length of value is <= BASE64_DIGEST_LEN");
+        }
+
+        let (digest_str, value) = cookie_value.split_at(BASE64_DIGEST_LEN);
+        let sig = base64::decode(digest_str).map_err(|_| "bad base64 digest")?;
+
+        verify(&self.key, value.as_bytes(), &sig)
+            .map(|_| value.to_string())
+            .map_err(|_| "value did not verify")
+    }
+
+    /// Returns a reference to the `Cookie` inside this jar with the name `name`
+    /// and verifies the authenticity and integrity of the cookie's value,
+    /// returning a `Cookie` with the authenticated value. If the cookie cannot
+    /// be found, or the cookie fails to verify, `None` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut signed_jar = jar.signed(&key);
+    /// assert!(signed_jar.get("name").is_none());
+    ///
+    /// signed_jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(signed_jar.get("name").unwrap().value(), "value");
+    /// ```
+    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
+        if let Some(cookie_ref) = self.parent.get(name) {
+            let mut cookie = cookie_ref.clone();
+            if let Ok(value) = self.verify(cookie.value()) {
+                cookie.set_value(value);
+                return Some(cookie);
+            }
+        }
+
+        None
+    }
+
+    /// Adds `cookie` to the parent jar. The cookie's value is signed assuring
+    /// integrity and authenticity.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.signed(&key).add(Cookie::new("name", "value"));
+    ///
+    /// assert_ne!(jar.get("name").unwrap().value(), "value");
+    /// assert!(jar.get("name").unwrap().value().contains("value"));
+    /// assert_eq!(jar.signed(&key).get("name").unwrap().value(), "value");
+    /// ```
+    pub fn add(&mut self, mut cookie: Cookie<'static>) {
+        self.sign_cookie(&mut cookie);
+        self.parent.add(cookie);
+    }
+
+    /// Adds an "original" `cookie` to this jar. The cookie's value is signed
+    /// assuring integrity and authenticity. Adding an original cookie does not
+    /// affect the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
+    /// computation. This method is intended to be used to seed the cookie jar
+    /// with cookies received from a client's HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.signed(&key).add_original(Cookie::new("name", "value"));
+    ///
+    /// assert_eq!(jar.iter().count(), 1);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
+        self.sign_cookie(&mut cookie);
+        self.parent.add_original(cookie);
+    }
+
+    /// Signs the cookie's value assuring integrity and authenticity.
+    fn sign_cookie(&self, cookie: &mut Cookie) {
+        let digest = sign(&self.key, cookie.value().as_bytes());
+        let mut new_value = base64::encode(digest.as_ref());
+        new_value.push_str(cookie.value());
+        cookie.set_value(new_value);
+    }
+
+    /// Removes `cookie` from the parent jar.
+    ///
+    /// For correct removal, the passed in `cookie` must contain the same `path`
+    /// and `domain` as the cookie that was initially set.
+    ///
+    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
+    /// details.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut signed_jar = jar.signed(&key);
+    ///
+    /// signed_jar.add(Cookie::new("name", "value"));
+    /// assert!(signed_jar.get("name").is_some());
+    ///
+    /// signed_jar.remove(Cookie::named("name"));
+    /// assert!(signed_jar.get("name").is_none());
+    /// ```
+    pub fn remove(&mut self, cookie: Cookie<'static>) {
+        self.parent.remove(cookie);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Cookie, CookieJar, Key};
+
+    #[test]
+    fn simple() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_simple_behaviour!(jar, jar.signed(&key));
+    }
+
+    #[test]
+    fn private() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_secure_behaviour!(jar, jar.signed(&key));
+    }
+}
--- a/actix-http/src/encoding/decoder.rs
+++ b/actix-http/src/encoding/decoder.rs
@ -12,6 +12,8 @@ use super::Writer;
 use crate::error::PayloadError;
 use crate::http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING};

+const INPLACE: usize = 2049;
+
 pub struct Decoder<S> {
    decoder: Option<ContentDecoder>,
    stream: S,
@ -53,7 +55,7 @@ where
    #[inline]
    pub fn from_headers(stream: S, headers: &HeaderMap) -> Decoder<S> {
        // check content-encoding
-        let encoding = if let Some(enc) = headers.get(CONTENT_ENCODING) {
+        let encoding = if let Some(enc) = headers.get(&CONTENT_ENCODING) {
            if let Ok(enc) = enc.to_str() {
                ContentEncoding::from(enc)
            } else {
@ -92,10 +94,18 @@ where
            match self.stream.poll()? {
                Async::Ready(Some(chunk)) => {
                    if let Some(mut decoder) = self.decoder.take() {
-                        self.fut = Some(run(move || {
+                        if chunk.len() < INPLACE {
                            let chunk = decoder.feed_data(chunk)?;
-                            Ok((chunk, decoder))
-                        }));
+                            self.decoder = Some(decoder);
+                            if let Some(chunk) = chunk {
+                                return Ok(Async::Ready(Some(chunk)));
+                            }
+                        } else {
+                            self.fut = Some(run(move || {
+                                let chunk = decoder.feed_data(chunk)?;
+                                Ok((chunk, decoder))
+                            }));
+                        }
                        continue;
                    } else {
                        return Ok(Async::Ready(Some(chunk)));
@ -103,14 +113,10 @@ where
                }
                Async::Ready(None) => {
                    self.eof = true;
-                    if let Some(mut decoder) = self.decoder.take() {
-                        self.fut = Some(run(move || {
-                            let chunk = decoder.feed_eof()?;
-                            Ok((chunk, decoder))
-                        }));
-                        continue;
+                    return if let Some(mut decoder) = self.decoder.take() {
+                        Ok(Async::Ready(decoder.feed_eof()?))
                    } else {
-                        return Ok(Async::Ready(None));
+                        Ok(Async::Ready(None))
                    };
                }
                Async::NotReady => break,
--- a/actix-http/src/encoding/encoder.rs
+++ b/actix-http/src/encoding/encoder.rs
@ -1,13 +1,13 @@
 //! Stream encoder
 use std::io::{self, Write};

-use bytes::Bytes;
-use futures::{Async, Poll};
-
+use actix_threadpool::{run, CpuFuture};
 #[cfg(feature = "brotli")]
 use brotli2::write::BrotliEncoder;
+use bytes::Bytes;
 #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
 use flate2::write::{GzEncoder, ZlibEncoder};
+use futures::{Async, Future, Poll};

 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
@ -16,9 +16,13 @@ use crate::{Error, ResponseHead};

 use super::Writer;

+const INPLACE: usize = 2049;
+
 pub struct Encoder<B> {
+    eof: bool,
    body: EncoderBody<B>,
    encoder: Option<ContentEncoder>,
+    fut: Option<CpuFuture<ContentEncoder, io::Error>>,
 }

 impl<B: MessageBody> Encoder<B> {
@ -27,73 +31,61 @@ impl<B: MessageBody> Encoder<B> {
        head: &mut ResponseHead,
        body: ResponseBody<B>,
    ) -> ResponseBody<Encoder<B>> {
-        let has_ce = head.headers().contains_key(CONTENT_ENCODING);
-        match body {
-            ResponseBody::Other(b) => match b {
-                Body::None => ResponseBody::Other(Body::None),
-                Body::Empty => ResponseBody::Other(Body::Empty),
-                Body::Bytes(buf) => {
-                    if !(has_ce
-                        || encoding == ContentEncoding::Identity
-                        || encoding == ContentEncoding::Auto)
-                    {
-                        let mut enc = ContentEncoder::encoder(encoding).unwrap();
+        let can_encode = !(head.headers().contains_key(&CONTENT_ENCODING)
+            || head.status == StatusCode::SWITCHING_PROTOCOLS
+            || head.status == StatusCode::NO_CONTENT
+            || encoding == ContentEncoding::Identity
+            || encoding == ContentEncoding::Auto);

-                        // TODO return error!
-                        let _ = enc.write(buf.as_ref());
-                        let body = enc.finish().unwrap();
-                        update_head(encoding, head);
-                        ResponseBody::Other(Body::Bytes(body))
+        let body = match body {
+            ResponseBody::Other(b) => match b {
+                Body::None => return ResponseBody::Other(Body::None),
+                Body::Empty => return ResponseBody::Other(Body::Empty),
+                Body::Bytes(buf) => {
+                    if can_encode {
+                        EncoderBody::Bytes(buf)
                    } else {
-                        ResponseBody::Other(Body::Bytes(buf))
-                    }
-                }
-                Body::Message(stream) => {
-                    if has_ce || head.status == StatusCode::SWITCHING_PROTOCOLS {
-                        ResponseBody::Body(Encoder {
-                            body: EncoderBody::Other(stream),
-                            encoder: None,
-                        })
-                    } else {
-                        update_head(encoding, head);
-                        head.no_chunking(false);
-                        ResponseBody::Body(Encoder {
-                            body: EncoderBody::Other(stream),
-                            encoder: ContentEncoder::encoder(encoding),
-                        })
+                        return ResponseBody::Other(Body::Bytes(buf));
                    }
                }
+                Body::Message(stream) => EncoderBody::BoxedStream(stream),
            },
-            ResponseBody::Body(stream) => {
-                if has_ce || head.status == StatusCode::SWITCHING_PROTOCOLS {
-                    ResponseBody::Body(Encoder {
-                        body: EncoderBody::Body(stream),
-                        encoder: None,
-                    })
-                } else {
-                    update_head(encoding, head);
-                    head.no_chunking(false);
-                    ResponseBody::Body(Encoder {
-                        body: EncoderBody::Body(stream),
-                        encoder: ContentEncoder::encoder(encoding),
-                    })
-                }
-            }
+            ResponseBody::Body(stream) => EncoderBody::Stream(stream),
+        };
+
+        if can_encode {
+            update_head(encoding, head);
+            head.no_chunking(false);
+            ResponseBody::Body(Encoder {
+                body,
+                eof: false,
+                fut: None,
+                encoder: ContentEncoder::encoder(encoding),
+            })
+        } else {
+            ResponseBody::Body(Encoder {
+                body,
+                eof: false,
+                fut: None,
+                encoder: None,
+            })
        }
    }
 }

 enum EncoderBody<B> {
-    Body(B),
-    Other(Box<dyn MessageBody>),
+    Bytes(Bytes),
+    Stream(B),
+    BoxedStream(Box<dyn MessageBody>),
 }

 impl<B: MessageBody> MessageBody for Encoder<B> {
-    fn length(&self) -> BodySize {
+    fn size(&self) -> BodySize {
        if self.encoder.is_none() {
            match self.body {
-                EncoderBody::Body(ref b) => b.length(),
-                EncoderBody::Other(ref b) => b.length(),
+                EncoderBody::Bytes(ref b) => b.size(),
+                EncoderBody::Stream(ref b) => b.size(),
+                EncoderBody::BoxedStream(ref b) => b.size(),
            }
        } else {
            BodySize::Stream
@ -102,16 +94,47 @@ impl<B: MessageBody> MessageBody for Encoder<B> {

    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        loop {
+            if self.eof {
+                return Ok(Async::Ready(None));
+            }
+
+            if let Some(ref mut fut) = self.fut {
+                let mut encoder = futures::try_ready!(fut.poll());
+                let chunk = encoder.take();
+                self.encoder = Some(encoder);
+                self.fut.take();
+                if !chunk.is_empty() {
+                    return Ok(Async::Ready(Some(chunk)));
+                }
+            }
+
            let result = match self.body {
-                EncoderBody::Body(ref mut b) => b.poll_next()?,
-                EncoderBody::Other(ref mut b) => b.poll_next()?,
+                EncoderBody::Bytes(ref mut b) => {
+                    if b.is_empty() {
+                        Async::Ready(None)
+                    } else {
+                        Async::Ready(Some(std::mem::replace(b, Bytes::new())))
+                    }
+                }
+                EncoderBody::Stream(ref mut b) => b.poll_next()?,
+                EncoderBody::BoxedStream(ref mut b) => b.poll_next()?,
            };
            match result {
                Async::NotReady => return Ok(Async::NotReady),
                Async::Ready(Some(chunk)) => {
-                    if let Some(ref mut encoder) = self.encoder {
-                        if encoder.write(&chunk)? {
-                            return Ok(Async::Ready(Some(encoder.take())));
+                    if let Some(mut encoder) = self.encoder.take() {
+                        if chunk.len() < INPLACE {
+                            encoder.write(&chunk)?;
+                            let chunk = encoder.take();
+                            self.encoder = Some(encoder);
+                            if !chunk.is_empty() {
+                                return Ok(Async::Ready(Some(chunk)));
+                            }
+                        } else {
+                            self.fut = Some(run(move || {
+                                encoder.write(&chunk)?;
+                                Ok(encoder)
+                            }));
                        }
                    } else {
                        return Ok(Async::Ready(Some(chunk)));
@ -123,6 +146,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                        if chunk.is_empty() {
                            return Ok(Async::Ready(None));
                        } else {
+                            self.eof = true;
                            return Ok(Async::Ready(Some(chunk)));
                        }
                    } else {
@ -203,11 +227,11 @@ impl ContentEncoder {
        }
    }

-    fn write(&mut self, data: &[u8]) -> Result<bool, io::Error> {
+    fn write(&mut self, data: &[u8]) -> Result<(), io::Error> {
        match *self {
            #[cfg(feature = "brotli")]
            ContentEncoder::Br(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(!encoder.get_ref().buf.is_empty()),
+                Ok(_) => Ok(()),
                Err(err) => {
                    trace!("Error decoding br encoding: {}", err);
                    Err(err)
@ -215,7 +239,7 @@ impl ContentEncoder {
            },
            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
            ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(!encoder.get_ref().buf.is_empty()),
+                Ok(_) => Ok(()),
                Err(err) => {
                    trace!("Error decoding gzip encoding: {}", err);
                    Err(err)
@ -223,7 +247,7 @@ impl ContentEncoder {
            },
            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
            ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(!encoder.get_ref().buf.is_empty()),
+                Ok(_) => Ok(()),
                Err(err) => {
                    trace!("Error decoding deflate encoding: {}", err);
                    Err(err)
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
@ -1,14 +1,13 @@
 //! Error and Result module
 use std::cell::RefCell;
+use std::io::Write;
 use std::str::Utf8Error;
 use std::string::FromUtf8Error;
 use std::{fmt, io, result};

-// use actix::MailboxError;
 pub use actix_threadpool::BlockingError;
 use actix_utils::timeout::TimeoutError;
-#[cfg(feature = "cookies")]
-use cookie;
+use bytes::BytesMut;
 use derive_more::{Display, From};
 use futures::Canceled;
 use http::uri::InvalidUri;
@ -20,10 +19,9 @@ use serde_urlencoded::ser::Error as FormError;
 use tokio_timer::Error as TimerError;

 // re-export for convinience
-#[cfg(feature = "cookies")]
-pub use cookie::ParseError as CookieParseError;
-
 use crate::body::Body;
+pub use crate::cookie::ParseError as CookieParseError;
+use crate::helpers::Writer;
 use crate::response::Response;

 /// A specialized [`Result`](https://doc.rust-lang.org/std/result/enum.Result.html)
@ -53,13 +51,6 @@ impl Error {
    pub fn as_response_error(&self) -> &ResponseError {
        self.cause.as_ref()
    }
-
-    /// Converts error to a response instance and set error message as response body
-    pub fn response_with_message(self) -> Response {
-        let message = format!("{}", self);
-        let resp: Response = self.into();
-        resp.set_body(Body::from(message))
-    }
 }

 /// Error that can be converted to `Response`
@ -70,6 +61,18 @@ pub trait ResponseError: fmt::Debug + fmt::Display {
    fn error_response(&self) -> Response {
        Response::new(StatusCode::INTERNAL_SERVER_ERROR)
    }
+
+    /// Constructs an error response
+    fn render_response(&self) -> Response {
+        let mut resp = self.error_response();
+        let mut buf = BytesMut::new();
+        let _ = write!(Writer(&mut buf), "{}", self);
+        resp.headers_mut().insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("text/plain"),
+        );
+        resp.set_body(Body::from(buf))
+    }
 }

 impl fmt::Display for Error {
@ -80,7 +83,27 @@ impl fmt::Display for Error {

 impl fmt::Debug for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}\n", &self.cause)
+        writeln!(f, "{:?}", &self.cause)
+    }
+}
+
+impl From<()> for Error {
+    fn from(_: ()) -> Self {
+        Error::from(UnitError)
+    }
+}
+
+impl std::error::Error for Error {
+    fn description(&self) -> &str {
+        "actix-http::Error"
+    }
+
+    fn cause(&self) -> Option<&dyn std::error::Error> {
+        None
+    }
+
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
    }
 }

@ -110,6 +133,13 @@ impl<E: ResponseError> ResponseError for TimeoutError<E> {
    }
 }

+#[derive(Debug, Display)]
+#[display(fmt = "UnknownError")]
+struct UnitError;
+
+/// `InternalServerError` for `UnitError`
+impl ResponseError for UnitError {}
+
 /// `InternalServerError` for `JsonError`
 impl ResponseError for JsonError {}

@ -119,6 +149,14 @@ impl ResponseError for FormError {}
 /// `InternalServerError` for `TimerError`
 impl ResponseError for TimerError {}

+#[cfg(feature = "ssl")]
+/// `InternalServerError` for `openssl::ssl::Error`
+impl ResponseError for openssl::ssl::Error {}
+
+#[cfg(feature = "ssl")]
+/// `InternalServerError` for `openssl::ssl::HandshakeError`
+impl ResponseError for openssl::ssl::HandshakeError<tokio_tcp::TcpStream> {}
+
 /// Return `BAD_REQUEST` for `de::value::Error`
 impl ResponseError for DeError {
    fn error_response(&self) -> Response {
@ -168,9 +206,6 @@ impl ResponseError for header::InvalidHeaderValueBytes {
 /// `InternalServerError` for `futures::Canceled`
 impl ResponseError for Canceled {}

-// /// `InternalServerError` for `actix::MailboxError`
-// impl ResponseError for MailboxError {}
-
 /// A set of errors that can occur during parsing HTTP streams
 #[derive(Debug, Display)]
 pub enum ParseError {
@ -323,8 +358,7 @@ impl ResponseError for PayloadError {
 }

 /// Return `BadRequest` for `cookie::ParseError`
-#[cfg(feature = "cookies")]
-impl ResponseError for cookie::ParseError {
+impl ResponseError for crate::cookie::ParseError {
    fn error_response(&self) -> Response {
        Response::new(StatusCode::BAD_REQUEST)
    }
@ -334,7 +368,10 @@ impl ResponseError for cookie::ParseError {
 /// A set of errors that can occur during dispatching http requests
 pub enum DispatchError {
    /// Service error
-    Service,
+    Service(Error),
+
+    /// Upgrade service error
+    Upgrade,

    /// An `io::Error` that occurred while trying to read or write to a network
    /// stream.
@ -460,7 +497,16 @@ where
 {
    fn error_response(&self) -> Response {
        match self.status {
-            InternalErrorType::Status(st) => Response::new(st),
+            InternalErrorType::Status(st) => {
+                let mut res = Response::new(st);
+                let mut buf = BytesMut::new();
+                let _ = write!(Writer(&mut buf), "{}", self);
+                res.headers_mut().insert(
+                    header::CONTENT_TYPE,
+                    header::HeaderValue::from_static("text/plain"),
+                );
+                res.set_body(Body::from(buf))
+            }
            InternalErrorType::Response(ref resp) => {
                if let Some(resp) = resp.borrow_mut().take() {
                    resp
@ -470,6 +516,11 @@ where
            }
        }
    }
+
+    /// Constructs an error response
+    fn render_response(&self) -> Response {
+        self.error_response()
+    }
 }

 /// Convert Response to a Error
@ -899,10 +950,8 @@ mod tests {
        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
    }

-    #[cfg(feature = "cookies")]
    #[test]
    fn test_cookie_parse() {
-        use cookie::ParseError as CookieParseError;
        let resp: Response = CookieParseError::EmptyName.error_response();
        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    }
--- a/actix-http/src/h1/client.rs
+++ b/actix-http/src/h1/client.rs
@ -10,7 +10,7 @@ use http::header::{
 use http::{Method, Version};

 use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
-use super::{decoder, encoder};
+use super::{decoder, encoder, reserve_readbuf};
 use super::{Message, MessageType};
 use crate::body::BodySize;
 use crate::config::ServiceConfig;
@ -150,6 +150,7 @@ impl Decoder for ClientCodec {
            } else {
                self.inner.payload = None;
            }
+            reserve_readbuf(src);
            Ok(Some(req))
        } else {
            Ok(None)
@ -168,7 +169,10 @@ impl Decoder for ClientPayloadCodec {
        );

        Ok(match self.inner.payload.as_mut().unwrap().decode(src)? {
-            Some(PayloadItem::Chunk(chunk)) => Some(Some(chunk)),
+            Some(PayloadItem::Chunk(chunk)) => {
+                reserve_readbuf(src);
+                Some(Some(chunk))
+            }
            Some(PayloadItem::Eof) => {
                self.inner.payload.take();
                Some(None)
--- a/actix-http/src/h1/codec.rs
+++ b/actix-http/src/h1/codec.rs
@ -1,6 +1,6 @@
 #![allow(unused_imports, unused_variables, dead_code)]
-use std::fmt;
-use std::io::{self, Write};
+use std::io::Write;
+use std::{fmt, io, net};

 use actix_codec::{Decoder, Encoder};
 use bitflags::bitflags;
@ -22,8 +22,8 @@ use crate::response::Response;
 bitflags! {
    struct Flags: u8 {
        const HEAD              = 0b0000_0001;
-        const KEEPALIVE_ENABLED = 0b0000_1000;
-        const STREAM            = 0b0001_0000;
+        const KEEPALIVE_ENABLED = 0b0000_0010;
+        const STREAM            = 0b0000_0100;
    }
 }

@ -39,7 +39,6 @@ pub struct Codec {

    // encoder part
    flags: Flags,
-    headers_size: u32,
    encoder: encoder::MessageEncoder<Response<()>>,
 }

@ -67,27 +66,34 @@ impl Codec {
        };
        Codec {
            config,
+            flags,
            decoder: decoder::MessageDecoder::default(),
            payload: None,
            version: Version::HTTP_11,
            ctype: ConnectionType::Close,
-
-            flags,
-            headers_size: 0,
            encoder: encoder::MessageEncoder::default(),
        }
    }

+    #[inline]
    /// Check if request is upgrade
    pub fn upgrade(&self) -> bool {
        self.ctype == ConnectionType::Upgrade
    }

+    #[inline]
    /// Check if last response is keep-alive
    pub fn keepalive(&self) -> bool {
        self.ctype == ConnectionType::KeepAlive
    }

+    #[inline]
+    /// Check if keep-alive enabled on server level
+    pub fn keepalive_enabled(&self) -> bool {
+        self.flags.contains(Flags::KEEPALIVE_ENABLED)
+    }
+
+    #[inline]
    /// Check last request's message type
    pub fn message_type(&self) -> MessageType {
        if self.flags.contains(Flags::STREAM) {
@ -98,6 +104,11 @@ impl Codec {
            MessageType::Payload
        }
    }
+
+    #[inline]
+    pub fn config(&self) -> &ServiceConfig {
+        &self.config
+    }
 }

 impl Decoder for Codec {
@ -176,7 +187,7 @@ impl Encoder for Codec {
                    self.ctype,
                    &self.config,
                )?;
-                self.headers_size = (dst.len() - len) as u32;
+                // self.headers_size = (dst.len() - len) as u32;
            }
            Message::Chunk(Some(bytes)) => {
                self.encoder.encode_chunk(bytes.as_ref(), dst)?;
--- a/actix-http/src/h1/decoder.rs
+++ b/actix-http/src/h1/decoder.rs
@ -5,11 +5,12 @@ use actix_codec::Decoder;
 use bytes::{Bytes, BytesMut};
 use futures::{Async, Poll};
 use http::header::{HeaderName, HeaderValue};
-use http::{header, HeaderMap, HttpTryFrom, Method, StatusCode, Uri, Version};
+use http::{header, HttpTryFrom, Method, StatusCode, Uri, Version};
 use httparse;
 use log::{debug, error, trace};

 use crate::error::ParseError;
+use crate::header::HeaderMap;
 use crate::message::{ConnectionType, ResponseHead};
 use crate::request::Request;

@ -51,6 +52,8 @@ pub(crate) enum PayloadLength {
 pub(crate) trait MessageType: Sized {
    fn set_connection_type(&mut self, ctype: Option<ConnectionType>);

+    fn set_expect(&mut self);
+
    fn headers_mut(&mut self) -> &mut HeaderMap;

    fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, ParseError>;
@ -62,6 +65,7 @@ pub(crate) trait MessageType: Sized {
    ) -> Result<PayloadLength, ParseError> {
        let mut ka = None;
        let mut has_upgrade = false;
+        let mut expect = false;
        let mut chunked = false;
        let mut content_length = None;

@ -69,73 +73,81 @@ pub(crate) trait MessageType: Sized {
            let headers = self.headers_mut();

            for idx in raw_headers.iter() {
-                if let Ok(name) = HeaderName::from_bytes(&slice[idx.name.0..idx.name.1])
-                {
-                    // Unsafe: httparse check header value for valid utf-8
-                    let value = unsafe {
-                        HeaderValue::from_shared_unchecked(
-                            slice.slice(idx.value.0, idx.value.1),
-                        )
-                    };
-                    match name {
-                        header::CONTENT_LENGTH => {
-                            if let Ok(s) = value.to_str() {
-                                if let Ok(len) = s.parse::<u64>() {
+                let name =
+                    HeaderName::from_bytes(&slice[idx.name.0..idx.name.1]).unwrap();
+
+                // Unsafe: httparse check header value for valid utf-8
+                let value = unsafe {
+                    HeaderValue::from_shared_unchecked(
+                        slice.slice(idx.value.0, idx.value.1),
+                    )
+                };
+                match name {
+                    header::CONTENT_LENGTH => {
+                        if let Ok(s) = value.to_str() {
+                            if let Ok(len) = s.parse::<u64>() {
+                                if len != 0 {
                                    content_length = Some(len);
-                                } else {
-                                    debug!("illegal Content-Length: {:?}", s);
-                                    return Err(ParseError::Header);
                                }
                            } else {
-                                debug!("illegal Content-Length: {:?}", value);
+                                debug!("illegal Content-Length: {:?}", s);
                                return Err(ParseError::Header);
                            }
+                        } else {
+                            debug!("illegal Content-Length: {:?}", value);
+                            return Err(ParseError::Header);
                        }
-                        // transfer-encoding
-                        header::TRANSFER_ENCODING => {
-                            if let Ok(s) = value.to_str().map(|s| s.trim()) {
-                                chunked = s.eq_ignore_ascii_case("chunked");
-                            } else {
-                                return Err(ParseError::Header);
-                            }
+                    }
+                    // transfer-encoding
+                    header::TRANSFER_ENCODING => {
+                        if let Ok(s) = value.to_str().map(|s| s.trim()) {
+                            chunked = s.eq_ignore_ascii_case("chunked");
+                        } else {
+                            return Err(ParseError::Header);
                        }
-                        // connection keep-alive state
-                        header::CONNECTION => {
-                            ka = if let Ok(conn) = value.to_str().map(|conn| conn.trim())
-                            {
-                                if conn.eq_ignore_ascii_case("keep-alive") {
-                                    Some(ConnectionType::KeepAlive)
-                                } else if conn.eq_ignore_ascii_case("close") {
-                                    Some(ConnectionType::Close)
-                                } else if conn.eq_ignore_ascii_case("upgrade") {
-                                    Some(ConnectionType::Upgrade)
-                                } else {
-                                    None
-                                }
+                    }
+                    // connection keep-alive state
+                    header::CONNECTION => {
+                        ka = if let Ok(conn) = value.to_str().map(|conn| conn.trim()) {
+                            if conn.eq_ignore_ascii_case("keep-alive") {
+                                Some(ConnectionType::KeepAlive)
+                            } else if conn.eq_ignore_ascii_case("close") {
+                                Some(ConnectionType::Close)
+                            } else if conn.eq_ignore_ascii_case("upgrade") {
+                                Some(ConnectionType::Upgrade)
                            } else {
                                None
-                            };
-                        }
-                        header::UPGRADE => {
-                            has_upgrade = true;
-                            // check content-length, some clients (dart)
-                            // sends "content-length: 0" with websocket upgrade
-                            if let Ok(val) = value.to_str().map(|val| val.trim()) {
-                                if val.eq_ignore_ascii_case("websocket") {
-                                    content_length = None;
-                                }
+                            }
+                        } else {
+                            None
+                        };
+                    }
+                    header::UPGRADE => {
+                        has_upgrade = true;
+                        // check content-length, some clients (dart)
+                        // sends "content-length: 0" with websocket upgrade
+                        if let Ok(val) = value.to_str().map(|val| val.trim()) {
+                            if val.eq_ignore_ascii_case("websocket") {
+                                content_length = None;
                            }
                        }
-                        _ => (),
                    }
-
-                    headers.append(name, value);
-                } else {
-                    return Err(ParseError::Header);
+                    header::EXPECT => {
+                        let bytes = value.as_bytes();
+                        if bytes.len() >= 4 && &bytes[0..4] == b"100-" {
+                            expect = true;
+                        }
+                    }
+                    _ => (),
                }
+
+                headers.append(name, value);
            }
        }
        self.set_connection_type(ka);
+        if expect {
+            self.set_expect()
+        }

        // https://tools.ietf.org/html/rfc7230#section-3.3.3
        if chunked {
@ -163,6 +175,10 @@ impl MessageType for Request {
        }
    }

+    fn set_expect(&mut self) {
+        self.head_mut().set_expect();
+    }
+
    fn headers_mut(&mut self) -> &mut HeaderMap {
        &mut self.head_mut().headers
    }
@ -198,10 +214,10 @@ impl MessageType for Request {
        let mut msg = Request::new();

        // convert headers
-        let len = msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len])?;
+        let length = msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len])?;

        // payload decoder
-        let decoder = match len {
+        let decoder = match length {
            PayloadLength::Payload(pl) => pl,
            PayloadLength::Upgrade => {
                // upgrade(websocket)
@ -235,6 +251,8 @@ impl MessageType for ResponseHead {
        }
    }

+    fn set_expect(&mut self) {}
+
    fn headers_mut(&mut self) -> &mut HeaderMap {
        &mut self.headers
    }
@ -266,13 +284,14 @@ impl MessageType for ResponseHead {
            }
        };

-        let mut msg = ResponseHead::default();
+        let mut msg = ResponseHead::new(status);
+        msg.version = ver;

        // convert headers
-        let len = msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len])?;
+        let length = msg.set_headers(&src.split_to(len).freeze(), &headers[..h_len])?;

        // message payload
-        let decoder = if let PayloadLength::Payload(pl) = len {
+        let decoder = if let PayloadLength::Payload(pl) = length {
            pl
        } else if status == StatusCode::SWITCHING_PROTOCOLS {
            // switching protocol or connect
@ -281,12 +300,15 @@ impl MessageType for ResponseHead {
            error!("MAX_BUFFER_SIZE unprocessed data reached, closing");
            return Err(ParseError::TooLarge);
        } else {
-            PayloadType::None
+            // for HTTP/1.0 read to eof and close connection
+            if msg.version == Version::HTTP_10 {
+                msg.set_connection_type(ConnectionType::Close);
+                PayloadType::Payload(PayloadDecoder::eof())
+            } else {
+                PayloadType::None
+            }
        };

-        msg.status = status;
-        msg.version = ver;
-
        Ok(Some((msg, decoder)))
    }
 }
@ -315,7 +337,7 @@ impl HeaderIndex {
    }
 }

-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 /// Http payload item
 pub enum PayloadItem {
    Chunk(Bytes),
@ -610,6 +632,7 @@ mod tests {

    use super::*;
    use crate::error::ParseError;
+    use crate::http::header::{HeaderName, SET_COOKIE};
    use crate::httpmessage::HttpMessage;

    impl PayloadType {
@ -770,7 +793,13 @@ mod tests {
        assert_eq!(req.version(), Version::HTTP_11);
        assert_eq!(*req.method(), Method::GET);
        assert_eq!(req.path(), "/test");
-        assert_eq!(req.headers().get("test").unwrap().as_bytes(), b"value");
+        assert_eq!(
+            req.headers()
+                .get(HeaderName::try_from("test").unwrap())
+                .unwrap()
+                .as_bytes(),
+            b"value"
+        );
    }

    #[test]
@ -785,12 +814,11 @@ mod tests {

        let val: Vec<_> = req
            .headers()
-            .get_all("Set-Cookie")
-            .iter()
+            .get_all(SET_COOKIE)
            .map(|v| v.to_str().unwrap().to_owned())
            .collect();
-        assert_eq!(val[0], "c1=cookie1");
-        assert_eq!(val[1], "c2=cookie2");
+        assert_eq!(val[1], "c1=cookie1");
+        assert_eq!(val[0], "c2=cookie2");
    }

    #[test]
@ -1169,4 +1197,16 @@ mod tests {
        let msg = pl.decode(&mut buf).unwrap().unwrap();
        assert!(msg.eof());
    }
+
+    #[test]
+    fn test_response_http10_read_until_eof() {
+        let mut buf = BytesMut::from(&"HTTP/1.0 200 Ok\r\n\r\ntest data"[..]);
+
+        let mut reader = MessageDecoder::<ResponseHead>::default();
+        let (_msg, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        let mut pl = pl.unwrap();
+
+        let chunk = pl.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(chunk, PayloadItem::Chunk(Bytes::from_static(b"test data")));
+    }
 }
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@ -6,15 +6,15 @@ use std::str::FromStr;
 use std::{cmp, fmt, io, mem};

 use bytes::{BufMut, Bytes, BytesMut};
-use http::header::{
-    HeaderValue, ACCEPT_ENCODING, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
-};
-use http::{HeaderMap, Method, StatusCode, Version};

 use crate::body::BodySize;
 use crate::config::ServiceConfig;
-use crate::header::ContentEncoding;
+use crate::header::{map, ContentEncoding};
 use crate::helpers;
+use crate::http::header::{
+    HeaderValue, ACCEPT_ENCODING, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
+};
+use crate::http::{HeaderMap, Method, StatusCode, Version};
 use crate::message::{ConnectionType, Head, RequestHead, ResponseHead};
 use crate::request::Request;
 use crate::response::Response;
@ -41,10 +41,12 @@ impl<T: MessageType> Default for MessageEncoder<T> {
 pub(crate) trait MessageType: Sized {
    fn status(&self) -> Option<StatusCode>;

-    // fn connection_type(&self) -> Option<ConnectionType>;
-
    fn headers(&self) -> &HeaderMap;

+    fn camel_case(&self) -> bool {
+        false
+    }
+
    fn chunked(&self) -> bool;

    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()>;
@ -59,6 +61,7 @@ pub(crate) trait MessageType: Sized {
    ) -> io::Result<()> {
        let chunked = self.chunked();
        let mut skip_len = length != BodySize::Stream;
+        let camel_case = self.camel_case();

        // Content length
        if let Some(status) = self.status() {
@ -76,32 +79,51 @@ pub(crate) trait MessageType: Sized {
        match length {
            BodySize::Stream => {
                if chunked {
-                    dst.extend_from_slice(b"\r\ntransfer-encoding: chunked\r\n")
+                    if camel_case {
+                        dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
+                    } else {
+                        dst.put_slice(b"\r\ntransfer-encoding: chunked\r\n")
+                    }
                } else {
                    skip_len = false;
-                    dst.extend_from_slice(b"\r\n");
+                    dst.put_slice(b"\r\n");
                }
            }
            BodySize::Empty => {
-                dst.extend_from_slice(b"\r\ncontent-length: 0\r\n");
+                if camel_case {
+                    dst.put_slice(b"\r\nContent-Length: 0\r\n");
+                } else {
+                    dst.put_slice(b"\r\ncontent-length: 0\r\n");
+                }
            }
            BodySize::Sized(len) => helpers::write_content_length(len, dst),
            BodySize::Sized64(len) => {
-                dst.extend_from_slice(b"\r\ncontent-length: ");
-                write!(dst.writer(), "{}", len)?;
-                dst.extend_from_slice(b"\r\n");
+                if camel_case {
+                    dst.put_slice(b"\r\nContent-Length: ");
+                } else {
+                    dst.put_slice(b"\r\ncontent-length: ");
+                }
+                write!(dst.writer(), "{}\r\n", len)?;
            }
-            BodySize::None => dst.extend_from_slice(b"\r\n"),
+            BodySize::None => dst.put_slice(b"\r\n"),
        }

        // Connection
        match ctype {
-            ConnectionType::Upgrade => dst.extend_from_slice(b"connection: upgrade\r\n"),
+            ConnectionType::Upgrade => dst.put_slice(b"connection: upgrade\r\n"),
            ConnectionType::KeepAlive if version < Version::HTTP_11 => {
-                dst.extend_from_slice(b"connection: keep-alive\r\n")
+                if camel_case {
+                    dst.put_slice(b"Connection: keep-alive\r\n")
+                } else {
+                    dst.put_slice(b"connection: keep-alive\r\n")
+                }
            }
            ConnectionType::Close if version >= Version::HTTP_11 => {
-                dst.extend_from_slice(b"connection: close\r\n")
+                if camel_case {
+                    dst.put_slice(b"Connection: close\r\n")
+                } else {
+                    dst.put_slice(b"connection: close\r\n")
+                }
            }
            _ => (),
        }
@ -111,7 +133,7 @@ pub(crate) trait MessageType: Sized {
        let mut has_date = false;
        let mut remaining = dst.remaining_mut();
        let mut buf = unsafe { &mut *(dst.bytes_mut() as *mut [u8]) };
-        for (key, value) in self.headers() {
+        for (key, value) in self.headers().inner.iter() {
            match *key {
                CONNECTION => continue,
                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => continue,
@ -120,31 +142,69 @@ pub(crate) trait MessageType: Sized {
                }
                _ => (),
            }
-
-            let v = value.as_ref();
            let k = key.as_str().as_bytes();
-            let len = k.len() + v.len() + 4;
-            if len > remaining {
-                unsafe {
-                    dst.advance_mut(pos);
+            match value {
+                map::Value::One(ref val) => {
+                    let v = val.as_ref();
+                    let len = k.len() + v.len() + 4;
+                    if len > remaining {
+                        unsafe {
+                            dst.advance_mut(pos);
+                        }
+                        pos = 0;
+                        dst.reserve(len * 2);
+                        remaining = dst.remaining_mut();
+                        unsafe {
+                            buf = &mut *(dst.bytes_mut() as *mut _);
+                        }
+                    }
+                    // use upper Camel-Case
+                    if camel_case {
+                        write_camel_case(k, &mut buf[pos..pos + k.len()]);
+                    } else {
+                        buf[pos..pos + k.len()].copy_from_slice(k);
+                    }
+                    pos += k.len();
+                    buf[pos..pos + 2].copy_from_slice(b": ");
+                    pos += 2;
+                    buf[pos..pos + v.len()].copy_from_slice(v);
+                    pos += v.len();
+                    buf[pos..pos + 2].copy_from_slice(b"\r\n");
+                    pos += 2;
+                    remaining -= len;
                }
-                pos = 0;
-                dst.reserve(len);
-                remaining = dst.remaining_mut();
-                unsafe {
-                    buf = &mut *(dst.bytes_mut() as *mut _);
+                map::Value::Multi(ref vec) => {
+                    for val in vec {
+                        let v = val.as_ref();
+                        let len = k.len() + v.len() + 4;
+                        if len > remaining {
+                            unsafe {
+                                dst.advance_mut(pos);
+                            }
+                            pos = 0;
+                            dst.reserve(len * 2);
+                            remaining = dst.remaining_mut();
+                            unsafe {
+                                buf = &mut *(dst.bytes_mut() as *mut _);
+                            }
+                        }
+                        // use upper Camel-Case
+                        if camel_case {
+                            write_camel_case(k, &mut buf[pos..pos + k.len()]);
+                        } else {
+                            buf[pos..pos + k.len()].copy_from_slice(k);
+                        }
+                        pos += k.len();
+                        buf[pos..pos + 2].copy_from_slice(b": ");
+                        pos += 2;
+                        buf[pos..pos + v.len()].copy_from_slice(v);
+                        pos += v.len();
+                        buf[pos..pos + 2].copy_from_slice(b"\r\n");
+                        pos += 2;
+                        remaining -= len;
+                    }
                }
            }
-
-            buf[pos..pos + k.len()].copy_from_slice(k);
-            pos += k.len();
-            buf[pos..pos + 2].copy_from_slice(b": ");
-            pos += 2;
-            buf[pos..pos + v.len()].copy_from_slice(v);
-            pos += v.len();
-            buf[pos..pos + 2].copy_from_slice(b"\r\n");
-            pos += 2;
-            remaining -= len;
        }
        unsafe {
            dst.advance_mut(pos);
@ -171,10 +231,6 @@ impl MessageType for Response<()> {
        self.head().chunked()
    }

-    //fn connection_type(&self) -> Option<ConnectionType> {
-    //    self.head().ctype
-    //}
-
    fn headers(&self) -> &HeaderMap {
        &self.head().headers
    }
@ -186,7 +242,7 @@ impl MessageType for Response<()> {

        // status line
        helpers::write_status_line(head.version, head.status.as_u16(), dst);
-        dst.extend_from_slice(reason);
+        dst.put_slice(reason);
        Ok(())
    }
 }
@ -200,11 +256,16 @@ impl MessageType for RequestHead {
        self.chunked()
    }

+    fn camel_case(&self) -> bool {
+        RequestHead::camel_case_headers(self)
+    }
+
    fn headers(&self) -> &HeaderMap {
        &self.headers
    }

    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
+        dst.reserve(256 + self.headers.len() * AVERAGE_HEADER_SIZE);
        write!(
            Writer(dst),
            "{} {} {}",
@ -396,11 +457,41 @@ impl<'a> io::Write for Writer<'a> {
    }
 }

+fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+    let mut index = 0;
+    let key = value;
+    let mut key_iter = key.iter();
+
+    if let Some(c) = key_iter.next() {
+        if *c >= b'a' && *c <= b'z' {
+            buffer[index] = *c ^ b' ';
+            index += 1;
+        }
+    } else {
+        return;
+    }
+
+    while let Some(c) = key_iter.next() {
+        buffer[index] = *c;
+        index += 1;
+        if *c == b'-' {
+            if let Some(c) = key_iter.next() {
+                if *c >= b'a' && *c <= b'z' {
+                    buffer[index] = *c ^ b' ';
+                    index += 1;
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use super::*;
    use bytes::Bytes;

+    use super::*;
+    use crate::http::header::{HeaderValue, CONTENT_TYPE};
+
    #[test]
    fn test_chunked_te() {
        let mut bytes = BytesMut::new();
@ -414,4 +505,77 @@ mod tests {
            Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
        );
    }
+
+    #[test]
+    fn test_camel_case() {
+        let mut bytes = BytesMut::with_capacity(2048);
+        let mut head = RequestHead::default();
+        head.set_camel_case_headers(true);
+        head.headers.insert(DATE, HeaderValue::from_static("date"));
+        head.headers
+            .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
+
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Empty,
+            ConnectionType::Close,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nContent-Length: 0\r\nConnection: close\r\nDate: date\r\nContent-Type: plain/text\r\n\r\n")
+        );
+
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Stream,
+            ConnectionType::KeepAlive,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nTransfer-Encoding: chunked\r\nDate: date\r\nContent-Type: plain/text\r\n\r\n")
+        );
+
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Sized64(100),
+            ConnectionType::KeepAlive,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nContent-Length: 100\r\nDate: date\r\nContent-Type: plain/text\r\n\r\n")
+        );
+
+        head.headers
+            .append(CONTENT_TYPE, HeaderValue::from_static("xml"));
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Stream,
+            ConnectionType::KeepAlive,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\nTransfer-Encoding: chunked\r\nDate: date\r\nContent-Type: xml\r\nContent-Type: plain/text\r\n\r\n")
+        );
+
+        head.set_camel_case_headers(false);
+        let _ = head.encode_headers(
+            &mut bytes,
+            Version::HTTP_11,
+            BodySize::Stream,
+            ConnectionType::KeepAlive,
+            &ServiceConfig::default(),
+        );
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"\r\ntransfer-encoding: chunked\r\ndate: date\r\ncontent-type: xml\r\ncontent-type: plain/text\r\n\r\n")
+        );
+    }
 }
--- a/actix-http/src/h1/expect.rs
+++ b/actix-http/src/h1/expect.rs
@ -0,0 +1,38 @@
+use actix_server_config::ServerConfig;
+use actix_service::{NewService, Service};
+use futures::future::{ok, FutureResult};
+use futures::{Async, Poll};
+
+use crate::error::Error;
+use crate::request::Request;
+
+pub struct ExpectHandler;
+
+impl NewService for ExpectHandler {
+    type Config = ServerConfig;
+    type Request = Request;
+    type Response = Request;
+    type Error = Error;
+    type Service = ExpectHandler;
+    type InitError = Error;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
+        ok(ExpectHandler)
+    }
+}
+
+impl Service for ExpectHandler {
+    type Request = Request;
+    type Response = Request;
+    type Error = Error;
+    type Future = FutureResult<Self::Response, Self::Error>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Request) -> Self::Future {
+        ok(req)
+    }
+}
--- a/actix-http/src/h1/mod.rs
+++ b/actix-http/src/h1/mod.rs
@ -1,19 +1,25 @@
 //! HTTP/1 implementation
-use bytes::Bytes;
+use bytes::{Bytes, BytesMut};

 mod client;
 mod codec;
 mod decoder;
 mod dispatcher;
 mod encoder;
+mod expect;
 mod payload;
 mod service;
+mod upgrade;
+mod utils;

 pub use self::client::{ClientCodec, ClientPayloadCodec};
 pub use self::codec::Codec;
 pub use self::dispatcher::Dispatcher;
-pub use self::payload::{Payload, PayloadBuffer};
+pub use self::expect::ExpectHandler;
+pub use self::payload::Payload;
 pub use self::service::{H1Service, H1ServiceHandler, OneRequest};
+pub use self::upgrade::UpgradeHandler;
+pub use self::utils::SendResponse;

 #[derive(Debug)]
 /// Codec message
@ -38,6 +44,16 @@ pub enum MessageType {
    Stream,
 }

+const LW: usize = 2 * 1024;
+const HW: usize = 32 * 1024;
+
+pub(crate) fn reserve_readbuf(src: &mut BytesMut) {
+    let cap = src.capacity();
+    if cap < LW {
+        src.reserve(HW - cap);
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/actix-http/src/h1/payload.rs
+++ b/actix-http/src/h1/payload.rs
@ -1,10 +1,9 @@
 //! Payload stream
 use std::cell::RefCell;
-use std::cmp;
 use std::collections::VecDeque;
 use std::rc::{Rc, Weak};

-use bytes::{Bytes, BytesMut};
+use bytes::Bytes;
 use futures::task::current as current_task;
 use futures::task::Task;
 use futures::{Async, Poll, Stream};
@ -15,7 +14,7 @@ use crate::error::PayloadError;
 pub(crate) const MAX_BUFFER_SIZE: usize = 32_768;

 #[derive(Debug, PartialEq)]
-pub(crate) enum PayloadStatus {
+pub enum PayloadStatus {
    Read,
    Pause,
    Dropped,
@ -78,14 +77,6 @@ impl Payload {
    pub fn unread_data(&mut self, data: Bytes) {
        self.inner.borrow_mut().unread_data(data);
    }
-
-    #[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 {
@ -98,58 +89,35 @@ impl Stream for Payload {
    }
 }

-impl Clone for Payload {
-    fn clone(&self) -> Payload {
-        Payload {
-            inner: Rc::clone(&self.inner),
-        }
-    }
-}
-
-/// Payload writer interface.
-pub(crate) trait PayloadWriter {
-    /// Set stream error.
-    fn set_error(&mut self, err: PayloadError);
-
-    /// Write eof into a stream which closes reading side of a stream.
-    fn feed_eof(&mut self);
-
-    /// Feed bytes into a payload stream
-    fn feed_data(&mut self, data: Bytes);
-
-    /// Need read data
-    fn need_read(&self) -> PayloadStatus;
-}
-
 /// Sender part of the payload stream
 pub struct PayloadSender {
    inner: Weak<RefCell<Inner>>,
 }

-impl PayloadWriter for PayloadSender {
+impl PayloadSender {
    #[inline]
-    fn set_error(&mut self, err: PayloadError) {
+    pub 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) {
+    pub 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) {
+    pub fn feed_data(&mut self, data: Bytes) {
        if let Some(shared) = self.inner.upgrade() {
            shared.borrow_mut().feed_data(data)
        }
    }

    #[inline]
-    fn need_read(&self) -> PayloadStatus {
+    pub fn need_read(&self) -> PayloadStatus {
        // we check need_read only if Payload (other side) is alive,
        // otherwise always return true (consume payload)
        if let Some(shared) = self.inner.upgrade() {
@ -177,7 +145,6 @@ struct Inner {
    err: Option<PayloadError>,
    need_read: bool,
    items: VecDeque<Bytes>,
-    capacity: usize,
    task: Option<Task>,
    io_task: Option<Task>,
 }
@ -190,7 +157,6 @@ impl Inner {
            err: None,
            items: VecDeque::new(),
            need_read: true,
-            capacity: MAX_BUFFER_SIZE,
            task: None,
            io_task: None,
        }
@ -210,7 +176,7 @@ impl Inner {
    fn feed_data(&mut self, data: Bytes) {
        self.len += data.len();
        self.items.push_back(data);
-        self.need_read = self.len < self.capacity;
+        self.need_read = self.len < MAX_BUFFER_SIZE;
        if let Some(task) = self.task.take() {
            task.notify()
        }
@ -224,7 +190,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;
+            self.need_read = self.len < MAX_BUFFER_SIZE;

            if self.need_read && self.task.is_none() && !self.eof {
                self.task = Some(current_task());
@ -258,407 +224,12 @@ impl Inner {
    }
 }

-/// Payload buffer
-pub struct PayloadBuffer<S> {
-    len: usize,
-    items: VecDeque<Bytes>,
-    stream: S,
-}
-
-impl<S> PayloadBuffer<S>
-where
-    S: Stream<Item = Bytes, Error = PayloadError>,
-{
-    /// Create new `PayloadBuffer` instance
-    pub fn new(stream: S) -> Self {
-        PayloadBuffer {
-            len: 0,
-            items: VecDeque::new(),
-            stream,
-        }
-    }
-
-    /// Get mutable reference to an inner stream.
-    pub fn get_mut(&mut self) -> &mut S {
-        &mut self.stream
-    }
-
-    #[inline]
-    fn poll_stream(&mut self) -> Poll<bool, PayloadError> {
-        self.stream.poll().map(|res| match res {
-            Async::Ready(Some(data)) => {
-                self.len += data.len();
-                self.items.push_back(data);
-                Async::Ready(true)
-            }
-            Async::Ready(None) => Async::Ready(false),
-            Async::NotReady => Async::NotReady,
-        })
-    }
-
-    /// Read first available chunk of bytes
-    #[inline]
-    pub fn readany(&mut self) -> Poll<Option<Bytes>, PayloadError> {
-        if let Some(data) = self.items.pop_front() {
-            self.len -= data.len();
-            Ok(Async::Ready(Some(data)))
-        } else {
-            match self.poll_stream()? {
-                Async::Ready(true) => self.readany(),
-                Async::Ready(false) => Ok(Async::Ready(None)),
-                Async::NotReady => Ok(Async::NotReady),
-            }
-        }
-    }
-
-    /// Check if buffer contains enough bytes
-    #[inline]
-    pub fn can_read(&mut self, size: usize) -> Poll<Option<bool>, PayloadError> {
-        if size <= self.len {
-            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),
-            }
-        }
-    }
-
-    /// Return reference to the first chunk of data
-    #[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),
-        }
-    }
-
-    /// Read exact number of bytes
-    #[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),
-            }
-        }
-    }
-
-    /// Remove specified amount if bytes from buffer
-    #[inline]
-    pub fn drop_bytes(&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 - len, chunk.len());
-                len += rem;
-                if rem < chunk.len() {
-                    chunk.split_to(rem);
-                    self.items.push_front(chunk);
-                }
-            }
-        }
-    }
-
-    /// Copy buffered data
-    pub fn copy(&mut self, size: usize) -> Poll<Option<BytesMut>, PayloadError> {
-        if size <= self.len {
-            let mut buf = BytesMut::with_capacity(size);
-            for chunk in &self.items {
-                if buf.len() < size {
-                    let rem = cmp::min(size - buf.len(), chunk.len());
-                    buf.extend_from_slice(&chunk[..rem]);
-                }
-                if buf.len() == size {
-                    return Ok(Async::Ready(Some(buf)));
-                }
-            }
-        }
-
-        match self.poll_stream()? {
-            Async::Ready(true) => self.copy(size),
-            Async::Ready(false) => Ok(Async::Ready(None)),
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-
-    /// Read until specified ending
-    pub fn read_until(&mut self, line: &[u8]) -> Poll<Option<Bytes>, PayloadError> {
-        let mut idx = 0;
-        let mut num = 0;
-        let mut offset = 0;
-        let mut found = false;
-        let mut length = 0;
-
-        for no in 0..self.items.len() {
-            {
-                let chunk = &self.items[no];
-                for (pos, ch) in chunk.iter().enumerate() {
-                    if *ch == line[idx] {
-                        idx += 1;
-                        if idx == line.len() {
-                            num = no;
-                            offset = pos + 1;
-                            length += pos + 1;
-                            found = true;
-                            break;
-                        }
-                    } else {
-                        idx = 0
-                    }
-                }
-                if !found {
-                    length += chunk.len()
-                }
-            }
-
-            if found {
-                let mut buf = BytesMut::with_capacity(length);
-                if num > 0 {
-                    for _ in 0..num {
-                        buf.extend_from_slice(&self.items.pop_front().unwrap());
-                    }
-                }
-                if offset > 0 {
-                    let mut chunk = self.items.pop_front().unwrap();
-                    buf.extend_from_slice(&chunk.split_to(offset));
-                    if !chunk.is_empty() {
-                        self.items.push_front(chunk)
-                    }
-                }
-                self.len -= length;
-                return Ok(Async::Ready(Some(buf.freeze())));
-            }
-        }
-
-        match self.poll_stream()? {
-            Async::Ready(true) => self.read_until(line),
-            Async::Ready(false) => Ok(Async::Ready(None)),
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-
-    /// Read bytes until new line delimiter
-    pub fn readline(&mut self) -> Poll<Option<Bytes>, PayloadError> {
-        self.read_until(b"\n")
-    }
-
-    /// Put unprocessed data back to the buffer
-    pub fn unprocessed(&mut self, data: Bytes) {
-        self.len += data.len();
-        self.items.push_front(data);
-    }
-
-    /// Get remaining data from the buffer
-    pub fn remaining(&mut self) -> Bytes {
-        self.items
-            .iter_mut()
-            .fold(BytesMut::new(), |mut b, c| {
-                b.extend_from_slice(c);
-                b
-            })
-            .freeze()
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
    use actix_rt::Runtime;
    use futures::future::{lazy, result};

-    #[test]
-    fn test_basic() {
-        Runtime::new()
-            .unwrap()
-            .block_on(lazy(|| {
-                let (_, payload) = Payload::create(false);
-                let mut payload = PayloadBuffer::new(payload);
-
-                assert_eq!(payload.len, 0);
-                assert_eq!(Async::NotReady, payload.readany().ok().unwrap());
-
-                let res: Result<(), ()> = Ok(());
-                result(res)
-            }))
-            .unwrap();
-    }
-
-    #[test]
-    fn test_eof() {
-        Runtime::new()
-            .unwrap()
-            .block_on(lazy(|| {
-                let (mut sender, payload) = Payload::create(false);
-                let mut payload = PayloadBuffer::new(payload);
-
-                assert_eq!(Async::NotReady, payload.readany().ok().unwrap());
-                sender.feed_data(Bytes::from("data"));
-                sender.feed_eof();
-
-                assert_eq!(
-                    Async::Ready(Some(Bytes::from("data"))),
-                    payload.readany().ok().unwrap()
-                );
-                assert_eq!(payload.len, 0);
-                assert_eq!(Async::Ready(None), payload.readany().ok().unwrap());
-
-                let res: Result<(), ()> = Ok(());
-                result(res)
-            }))
-            .unwrap();
-    }
-
-    #[test]
-    fn test_err() {
-        Runtime::new()
-            .unwrap()
-            .block_on(lazy(|| {
-                let (mut sender, payload) = Payload::create(false);
-                let mut payload = PayloadBuffer::new(payload);
-
-                assert_eq!(Async::NotReady, payload.readany().ok().unwrap());
-
-                sender.set_error(PayloadError::Incomplete(None));
-                payload.readany().err().unwrap();
-                let res: Result<(), ()> = Ok(());
-                result(res)
-            }))
-            .unwrap();
-    }
-
-    #[test]
-    fn test_readany() {
-        Runtime::new()
-            .unwrap()
-            .block_on(lazy(|| {
-                let (mut sender, payload) = Payload::create(false);
-                let mut payload = PayloadBuffer::new(payload);
-
-                sender.feed_data(Bytes::from("line1"));
-                sender.feed_data(Bytes::from("line2"));
-
-                assert_eq!(
-                    Async::Ready(Some(Bytes::from("line1"))),
-                    payload.readany().ok().unwrap()
-                );
-                assert_eq!(payload.len, 0);
-
-                assert_eq!(
-                    Async::Ready(Some(Bytes::from("line2"))),
-                    payload.readany().ok().unwrap()
-                );
-                assert_eq!(payload.len, 0);
-
-                let res: Result<(), ()> = Ok(());
-                result(res)
-            }))
-            .unwrap();
-    }
-
-    #[test]
-    fn test_readexactly() {
-        Runtime::new()
-            .unwrap()
-            .block_on(lazy(|| {
-                let (mut sender, payload) = Payload::create(false);
-                let mut payload = PayloadBuffer::new(payload);
-
-                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(Bytes::from_static(b"li"))),
-                    payload.read_exact(2).ok().unwrap()
-                );
-                assert_eq!(payload.len, 3);
-
-                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(None));
-                payload.read_exact(10).err().unwrap();
-
-                let res: Result<(), ()> = Ok(());
-                result(res)
-            }))
-            .unwrap();
-    }
-
-    #[test]
-    fn test_readuntil() {
-        Runtime::new()
-            .unwrap()
-            .block_on(lazy(|| {
-                let (mut sender, payload) = Payload::create(false);
-                let mut payload = PayloadBuffer::new(payload);
-
-                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.read_until(b"ne").ok().unwrap()
-                );
-                assert_eq!(payload.len, 1);
-
-                assert_eq!(
-                    Async::Ready(Some(Bytes::from("1line2"))),
-                    payload.read_until(b"2").ok().unwrap()
-                );
-                assert_eq!(payload.len, 0);
-
-                sender.set_error(PayloadError::Incomplete(None));
-                payload.read_until(b"b").err().unwrap();
-
-                let res: Result<(), ()> = Ok(());
-                result(res)
-            }))
-            .unwrap();
-    }
-
    #[test]
    fn test_unread_data() {
        Runtime::new()
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@ -1,8 +1,9 @@
-use std::fmt::Debug;
+use std::fmt;
 use std::marker::PhantomData;
+use std::rc::Rc;

-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_server_config::{Io, ServerConfig as SrvConfig};
+use actix_codec::Framed;
+use actix_server_config::{Io, IoStream, ServerConfig as SrvConfig};
 use actix_service::{IntoNewService, NewService, Service};
 use actix_utils::cloneable::CloneableService;
 use futures::future::{ok, FutureResult};
@ -10,72 +11,145 @@ use futures::{try_ready, Async, Future, IntoFuture, Poll, Stream};

 use crate::body::MessageBody;
 use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::{DispatchError, ParseError};
+use crate::error::{DispatchError, Error, ParseError};
+use crate::helpers::DataFactory;
 use crate::request::Request;
 use crate::response::Response;

 use super::codec::Codec;
 use super::dispatcher::Dispatcher;
-use super::Message;
+use super::{ExpectHandler, Message, UpgradeHandler};

 /// `NewService` implementation for HTTP1 transport
-pub struct H1Service<T, P, S, B> {
+pub struct H1Service<T, P, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
    srv: S,
    cfg: ServiceConfig,
+    expect: X,
+    upgrade: Option<U>,
+    on_connect: Option<Rc<Fn(&T) -> Box<dyn DataFactory>>>,
    _t: PhantomData<(T, P, B)>,
 }

 impl<T, P, S, B> H1Service<T, P, S, B>
 where
-    S: NewService<SrvConfig, Request = Request>,
-    S::Error: Debug,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
    S::Response: Into<Response<B>>,
-    S::Service: 'static,
    B: MessageBody,
 {
    /// Create new `HttpService` instance with default config.
-    pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self {
+    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);

        H1Service {
            cfg,
            srv: service.into_new_service(),
+            expect: ExpectHandler,
+            upgrade: None,
+            on_connect: None,
            _t: PhantomData,
        }
    }

    /// Create new `HttpService` instance with config.
-    pub fn with_config<F: IntoNewService<S, SrvConfig>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
+    pub fn with_config<F: IntoNewService<S>>(cfg: ServiceConfig, service: F) -> Self {
        H1Service {
            cfg,
            srv: service.into_new_service(),
+            expect: ExpectHandler,
+            upgrade: None,
+            on_connect: None,
            _t: PhantomData,
        }
    }
 }

-impl<T, P, S, B> NewService<SrvConfig> for H1Service<T, P, S, B>
+impl<T, P, S, B, X, U> H1Service<T, P, S, B, X, U>
 where
-    T: AsyncRead + AsyncWrite,
-    S: NewService<SrvConfig, Request = Request>,
-    S::Error: Debug,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
-    S::Service: 'static,
+    S::InitError: fmt::Debug,
    B: MessageBody,
 {
+    pub fn expect<X1>(self, expect: X1) -> H1Service<T, P, S, B, X1, U>
+    where
+        X1: NewService<Request = Request, Response = Request>,
+        X1::Error: Into<Error>,
+        X1::InitError: fmt::Debug,
+    {
+        H1Service {
+            expect,
+            cfg: self.cfg,
+            srv: self.srv,
+            upgrade: self.upgrade,
+            on_connect: self.on_connect,
+            _t: PhantomData,
+        }
+    }
+
+    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, P, S, B, X, U1>
+    where
+        U1: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
+        U1::Error: fmt::Display,
+        U1::InitError: fmt::Debug,
+    {
+        H1Service {
+            upgrade,
+            cfg: self.cfg,
+            srv: self.srv,
+            expect: self.expect,
+            on_connect: self.on_connect,
+            _t: PhantomData,
+        }
+    }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
+}
+
+impl<T, P, S, B, X, U> NewService for H1Service<T, P, S, B, X, U>
+where
+    T: IoStream,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::Response: Into<Response<B>>,
+    S::InitError: fmt::Debug,
+    B: MessageBody,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, Codec>),
+        Response = (),
+    >,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
+{
+    type Config = SrvConfig;
    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
-    type InitError = S::InitError;
-    type Service = H1ServiceHandler<T, P, S::Service, B>;
-    type Future = H1ServiceResponse<T, P, S, B>;
+    type InitError = ();
+    type Service = H1ServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
+    type Future = H1ServiceResponse<T, P, S, B, X, U>;

    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
        H1ServiceResponse {
            fut: self.srv.new_service(cfg).into_future(),
+            fut_ex: Some(self.expect.new_service(cfg)),
+            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
+            expect: None,
+            upgrade: None,
+            on_connect: self.on_connect.clone(),
            cfg: Some(self.cfg.clone()),
            _t: PhantomData,
        }
@ -83,78 +157,179 @@ where
 }

 #[doc(hidden)]
-pub struct H1ServiceResponse<T, P, S: NewService<SrvConfig, Request = Request>, B> {
-    fut: <S::Future as IntoFuture>::Future,
+pub struct H1ServiceResponse<T, P, S, B, X, U>
+where
+    S: NewService<Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    X: NewService<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
+{
+    fut: S::Future,
+    fut_ex: Option<X::Future>,
+    fut_upg: Option<U::Future>,
+    expect: Option<X::Service>,
+    upgrade: Option<U::Service>,
+    on_connect: Option<Rc<Fn(&T) -> Box<dyn DataFactory>>>,
    cfg: Option<ServiceConfig>,
    _t: PhantomData<(T, P, B)>,
 }

-impl<T, P, S, B> Future for H1ServiceResponse<T, P, S, B>
+impl<T, P, S, B, X, U> Future for H1ServiceResponse<T, P, S, B, X, U>
 where
-    T: AsyncRead + AsyncWrite,
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
-    S::Error: Debug,
+    T: IoStream,
+    S: NewService<Request = Request>,
+    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
+    S::InitError: fmt::Debug,
    B: MessageBody,
+    X: NewService<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
 {
-    type Item = H1ServiceHandler<T, P, S::Service, B>;
-    type Error = S::InitError;
+    type Item = H1ServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
+    type Error = ();

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let service = try_ready!(self.fut.poll());
+        if let Some(ref mut fut) = self.fut_ex {
+            let expect = try_ready!(fut
+                .poll()
+                .map_err(|e| log::error!("Init http service error: {:?}", e)));
+            self.expect = Some(expect);
+            self.fut_ex.take();
+        }
+
+        if let Some(ref mut fut) = self.fut_upg {
+            let upgrade = try_ready!(fut
+                .poll()
+                .map_err(|e| log::error!("Init http service error: {:?}", e)));
+            self.upgrade = Some(upgrade);
+            self.fut_ex.take();
+        }
+
+        let service = try_ready!(self
+            .fut
+            .poll()
+            .map_err(|e| log::error!("Init http service error: {:?}", e)));
        Ok(Async::Ready(H1ServiceHandler::new(
            self.cfg.take().unwrap(),
            service,
+            self.expect.take().unwrap(),
+            self.upgrade.take(),
+            self.on_connect.clone(),
        )))
    }
 }

 /// `Service` implementation for HTTP1 transport
-pub struct H1ServiceHandler<T, P, S: 'static, B> {
+pub struct H1ServiceHandler<T, P, S, B, X, U> {
    srv: CloneableService<S>,
+    expect: CloneableService<X>,
+    upgrade: Option<CloneableService<U>>,
+    on_connect: Option<Rc<Fn(&T) -> Box<dyn DataFactory>>>,
    cfg: ServiceConfig,
    _t: PhantomData<(T, P, B)>,
 }

-impl<T, P, S, B> H1ServiceHandler<T, P, S, B>
+impl<T, P, S, B, X, U> H1ServiceHandler<T, P, S, B, X, U>
 where
    S: Service<Request = Request>,
-    S::Error: Debug,
+    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    B: MessageBody,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
 {
-    fn new(cfg: ServiceConfig, srv: S) -> H1ServiceHandler<T, P, S, B> {
+    fn new(
+        cfg: ServiceConfig,
+        srv: S,
+        expect: X,
+        upgrade: Option<U>,
+        on_connect: Option<Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> H1ServiceHandler<T, P, S, B, X, U> {
        H1ServiceHandler {
            srv: CloneableService::new(srv),
+            expect: CloneableService::new(expect),
+            upgrade: upgrade.map(|s| CloneableService::new(s)),
            cfg,
+            on_connect,
            _t: PhantomData,
        }
    }
 }

-impl<T, P, S, B> Service for H1ServiceHandler<T, P, S, B>
+impl<T, P, S, B, X, U> Service for H1ServiceHandler<T, P, S, B, X, U>
 where
-    T: AsyncRead + AsyncWrite,
+    T: IoStream,
    S: Service<Request = Request>,
-    S::Error: Debug,
+    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    B: MessageBody,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
 {
    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
-    type Future = Dispatcher<T, S, B>;
+    type Future = Dispatcher<T, S, B, X, U>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.srv.poll_ready().map_err(|e| {
-            log::error!("Http service readiness error: {:?}", e);
-            DispatchError::Service
-        })
+        let ready = self
+            .expect
+            .poll_ready()
+            .map_err(|e| {
+                let e = e.into();
+                log::error!("Http service readiness error: {:?}", e);
+                DispatchError::Service(e)
+            })?
+            .is_ready();
+
+        let ready = self
+            .srv
+            .poll_ready()
+            .map_err(|e| {
+                let e = e.into();
+                log::error!("Http service readiness error: {:?}", e);
+                DispatchError::Service(e)
+            })?
+            .is_ready()
+            && ready;
+
+        if ready {
+            Ok(Async::Ready(()))
+        } else {
+            Ok(Async::NotReady)
+        }
    }

    fn call(&mut self, req: Self::Request) -> Self::Future {
-        Dispatcher::new(req.into_parts().0, self.cfg.clone(), self.srv.clone())
+        let io = req.into_parts().0;
+
+        let on_connect = if let Some(ref on_connect) = self.on_connect {
+            Some(on_connect(&io))
+        } else {
+            None
+        };
+
+        Dispatcher::new(
+            io,
+            self.cfg.clone(),
+            self.srv.clone(),
+            self.expect.clone(),
+            self.upgrade.clone(),
+            on_connect,
+        )
    }
 }

@ -167,7 +342,7 @@ pub struct OneRequest<T, P> {

 impl<T, P> OneRequest<T, P>
 where
-    T: AsyncRead + AsyncWrite,
+    T: IoStream,
 {
    /// Create new `H1SimpleService` instance.
    pub fn new() -> Self {
@ -178,10 +353,11 @@ where
    }
 }

-impl<T, P> NewService<SrvConfig> for OneRequest<T, P>
+impl<T, P> NewService for OneRequest<T, P>
 where
-    T: AsyncRead + AsyncWrite,
+    T: IoStream,
 {
+    type Config = SrvConfig;
    type Request = Io<T, P>;
    type Response = (Request, Framed<T, Codec>);
    type Error = ParseError;
@ -206,7 +382,7 @@ pub struct OneRequestService<T, P> {

 impl<T, P> Service for OneRequestService<T, P>
 where
-    T: AsyncRead + AsyncWrite,
+    T: IoStream,
 {
    type Request = Io<T, P>;
    type Response = (Request, Framed<T, Codec>);
@ -230,14 +406,14 @@ where
 #[doc(hidden)]
 pub struct OneRequestServiceResponse<T>
 where
-    T: AsyncRead + AsyncWrite,
+    T: IoStream,
 {
    framed: Option<Framed<T, Codec>>,
 }

 impl<T> Future for OneRequestServiceResponse<T>
 where
-    T: AsyncRead + AsyncWrite,
+    T: IoStream,
 {
    type Item = (Request, Framed<T, Codec>);
    type Error = ParseError;
--- a/actix-http/src/h1/upgrade.rs
+++ b/actix-http/src/h1/upgrade.rs
@ -0,0 +1,42 @@
+use std::marker::PhantomData;
+
+use actix_codec::Framed;
+use actix_server_config::ServerConfig;
+use actix_service::{NewService, Service};
+use futures::future::FutureResult;
+use futures::{Async, Poll};
+
+use crate::error::Error;
+use crate::h1::Codec;
+use crate::request::Request;
+
+pub struct UpgradeHandler<T>(PhantomData<T>);
+
+impl<T> NewService for UpgradeHandler<T> {
+    type Config = ServerConfig;
+    type Request = (Request, Framed<T, Codec>);
+    type Response = ();
+    type Error = Error;
+    type Service = UpgradeHandler<T>;
+    type InitError = Error;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
+        unimplemented!()
+    }
+}
+
+impl<T> Service for UpgradeHandler<T> {
+    type Request = (Request, Framed<T, Codec>);
+    type Response = ();
+    type Error = Error;
+    type Future = FutureResult<Self::Response, Self::Error>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, _: Self::Request) -> Self::Future {
+        unimplemented!()
+    }
+}
--- a/actix-http/src/h1/utils.rs
+++ b/actix-http/src/h1/utils.rs
@ -0,0 +1,92 @@
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use futures::{Async, Future, Poll, Sink};
+
+use crate::body::{BodySize, MessageBody, ResponseBody};
+use crate::error::Error;
+use crate::h1::{Codec, Message};
+use crate::response::Response;
+
+/// Send http/1 response
+pub struct SendResponse<T, B> {
+    res: Option<Message<(Response<()>, BodySize)>>,
+    body: Option<ResponseBody<B>>,
+    framed: Option<Framed<T, Codec>>,
+}
+
+impl<T, B> SendResponse<T, B>
+where
+    B: MessageBody,
+{
+    pub fn new(framed: Framed<T, Codec>, response: Response<B>) -> Self {
+        let (res, body) = response.into_parts();
+
+        SendResponse {
+            res: Some((res, body.size()).into()),
+            body: Some(body),
+            framed: Some(framed),
+        }
+    }
+}
+
+impl<T, B> Future for SendResponse<T, B>
+where
+    T: AsyncRead + AsyncWrite,
+    B: MessageBody,
+{
+    type Item = Framed<T, Codec>;
+    type Error = Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        loop {
+            let mut body_ready = self.body.is_some();
+            let framed = self.framed.as_mut().unwrap();
+
+            // send body
+            if self.res.is_none() && self.body.is_some() {
+                while body_ready && self.body.is_some() && !framed.is_write_buf_full() {
+                    match self.body.as_mut().unwrap().poll_next()? {
+                        Async::Ready(item) => {
+                            // body is done
+                            if item.is_none() {
+                                let _ = self.body.take();
+                            }
+                            framed.force_send(Message::Chunk(item))?;
+                        }
+                        Async::NotReady => body_ready = false,
+                    }
+                }
+            }
+
+            // flush write buffer
+            if !framed.is_write_buf_empty() {
+                match framed.poll_complete()? {
+                    Async::Ready(_) => {
+                        if body_ready {
+                            continue;
+                        } else {
+                            return Ok(Async::NotReady);
+                        }
+                    }
+                    Async::NotReady => return Ok(Async::NotReady),
+                }
+            }
+
+            // send response
+            if let Some(res) = self.res.take() {
+                framed.force_send(res)?;
+                continue;
+            }
+
+            if self.body.is_some() {
+                if body_ready {
+                    continue;
+                } else {
+                    return Ok(Async::NotReady);
+                }
+            } else {
+                break;
+            }
+        }
+        Ok(Async::Ready(self.framed.take().unwrap()))
+    }
+}
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@ -1,9 +1,10 @@
 use std::collections::VecDeque;
 use std::marker::PhantomData;
 use std::time::Instant;
-use std::{fmt, mem};
+use std::{fmt, mem, net};

 use actix_codec::{AsyncRead, AsyncWrite};
+use actix_server_config::IoStream;
 use actix_service::Service;
 use actix_utils::cloneable::CloneableService;
 use bitflags::bitflags;
@ -21,6 +22,7 @@ use tokio_timer::Delay;
 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::config::ServiceConfig;
 use crate::error::{DispatchError, Error, ParseError, PayloadError, ResponseError};
+use crate::helpers::DataFactory;
 use crate::message::ResponseHead;
 use crate::payload::Payload;
 use crate::request::Request;
@ -29,14 +31,12 @@ use crate::response::Response;
 const CHUNK_SIZE: usize = 16_384;

 /// Dispatcher for HTTP/2 protocol
-pub struct Dispatcher<
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    B: MessageBody,
-> {
+pub struct Dispatcher<T: IoStream, S: Service<Request = Request>, B: MessageBody> {
    service: CloneableService<S>,
    connection: Connection<T, Bytes>,
+    on_connect: Option<Box<dyn DataFactory>>,
    config: ServiceConfig,
+    peer_addr: Option<net::SocketAddr>,
    ka_expire: Instant,
    ka_timer: Option<Delay>,
    _t: PhantomData<B>,
@ -44,17 +44,20 @@ pub struct Dispatcher<

 impl<T, S, B> Dispatcher<T, S, B>
 where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    S::Error: fmt::Debug,
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
-    pub fn new(
+    pub(crate) fn new(
        service: CloneableService<S>,
        connection: Connection<T, Bytes>,
+        on_connect: Option<Box<dyn DataFactory>>,
        config: ServiceConfig,
        timeout: Option<Delay>,
+        peer_addr: Option<net::SocketAddr>,
    ) -> Self {
        // let keepalive = config.keep_alive_enabled();
        // let flags = if keepalive {
@ -75,9 +78,11 @@ where
        Dispatcher {
            service,
            config,
+            peer_addr,
+            connection,
+            on_connect,
            ka_expire,
            ka_timer,
-            connection,
            _t: PhantomData,
        }
    }
@ -85,9 +90,10 @@ where

 impl<T, S, B> Future for Dispatcher<T, S, B>
 where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    S::Error: fmt::Debug,
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
@ -114,8 +120,9 @@ where
                    head.uri = parts.uri;
                    head.method = parts.method;
                    head.version = parts.version;
-                    head.headers = parts.headers;
-                    tokio_current_thread::spawn(ServiceResponse::<S, B> {
+                    head.headers = parts.headers.into();
+                    head.peer_addr = self.peer_addr;
+                    tokio_current_thread::spawn(ServiceResponse::<S::Future, B> {
                        state: ServiceResponseState::ServiceCall(
                            self.service.call(req),
                            Some(res),
@ -130,31 +137,31 @@ where
    }
 }

-struct ServiceResponse<S: Service, B> {
-    state: ServiceResponseState<S, B>,
+struct ServiceResponse<F, B> {
+    state: ServiceResponseState<F, B>,
    config: ServiceConfig,
    buffer: Option<Bytes>,
 }

-enum ServiceResponseState<S: Service, B> {
-    ServiceCall(S::Future, Option<SendResponse<Bytes>>),
+enum ServiceResponseState<F, B> {
+    ServiceCall(F, Option<SendResponse<Bytes>>),
    SendPayload(SendStream<Bytes>, ResponseBody<B>),
 }

-impl<S, B> ServiceResponse<S, B>
+impl<F, B> ServiceResponse<F, B>
 where
-    S: Service<Request = Request> + 'static,
-    S::Error: fmt::Debug,
-    S::Response: Into<Response<B>>,
+    F: Future,
+    F::Error: Into<Error>,
+    F::Item: Into<Response<B>>,
    B: MessageBody + 'static,
 {
    fn prepare_response(
        &self,
        head: &ResponseHead,
-        length: &mut BodySize,
+        size: &mut BodySize,
    ) -> http::Response<()> {
        let mut has_date = false;
-        let mut skip_len = length != &BodySize::Stream;
+        let mut skip_len = size != &BodySize::Stream;

        let mut res = http::Response::new(());
        *res.status_mut() = head.status;
@ -164,14 +171,14 @@ where
        match head.status {
            http::StatusCode::NO_CONTENT
            | http::StatusCode::CONTINUE
-            | http::StatusCode::PROCESSING => *length = BodySize::None,
+            | http::StatusCode::PROCESSING => *size = BodySize::None,
            http::StatusCode::SWITCHING_PROTOCOLS => {
                skip_len = true;
-                *length = BodySize::Stream;
+                *size = BodySize::Stream;
            }
            _ => (),
        }
-        let _ = match length {
+        let _ = match size {
            BodySize::None | BodySize::Stream => None,
            BodySize::Empty => res
                .headers_mut()
@ -209,11 +216,11 @@ where
    }
 }

-impl<S, B> Future for ServiceResponse<S, B>
+impl<F, B> Future for ServiceResponse<F, B>
 where
-    S: Service<Request = Request> + 'static,
-    S::Error: fmt::Debug,
-    S::Response: Into<Response<B>>,
+    F: Future,
+    F::Error: Into<Error>,
+    F::Item: Into<Response<B>>,
    B: MessageBody + 'static,
 {
    type Item = ();
@ -227,16 +234,15 @@ where
                        let (res, body) = res.into().replace_body(());

                        let mut send = send.take().unwrap();
-                        let mut length = body.length();
-                        let h2_res = self.prepare_response(res.head(), &mut length);
+                        let mut size = body.size();
+                        let h2_res = self.prepare_response(res.head(), &mut size);

-                        let stream = send
-                            .send_response(h2_res, length.is_eof())
-                            .map_err(|e| {
+                        let stream =
+                            send.send_response(h2_res, size.is_eof()).map_err(|e| {
                                trace!("Error sending h2 response: {:?}", e);
                            })?;

-                        if length.is_eof() {
+                        if size.is_eof() {
                            Ok(Async::Ready(()))
                        } else {
                            self.state = ServiceResponseState::SendPayload(stream, body);
@ -249,16 +255,15 @@ where
                        let (res, body) = res.replace_body(());

                        let mut send = send.take().unwrap();
-                        let mut length = body.length();
-                        let h2_res = self.prepare_response(res.head(), &mut length);
+                        let mut size = body.size();
+                        let h2_res = self.prepare_response(res.head(), &mut size);

-                        let stream = send
-                            .send_response(h2_res, length.is_eof())
-                            .map_err(|e| {
+                        let stream =
+                            send.send_response(h2_res, size.is_eof()).map_err(|e| {
                                trace!("Error sending h2 response: {:?}", e);
                            })?;

-                        if length.is_eof() {
+                        if size.is_eof() {
                            Ok(Async::Ready(()))
                        } else {
                            self.state = ServiceResponseState::SendPayload(
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@ -1,9 +1,9 @@
 use std::fmt::Debug;
 use std::marker::PhantomData;
-use std::{io, net};
+use std::{io, net, rc};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_server_config::{Io, ServerConfig as SrvConfig};
+use actix_server_config::{Io, IoStream, ServerConfig as SrvConfig};
 use actix_service::{IntoNewService, NewService, Service};
 use actix_utils::cloneable::CloneableService;
 use bytes::Bytes;
@ -16,6 +16,7 @@ use log::error;
 use crate::body::MessageBody;
 use crate::config::{KeepAlive, ServiceConfig};
 use crate::error::{DispatchError, Error, ParseError, ResponseError};
+use crate::helpers::DataFactory;
 use crate::payload::Payload;
 use crate::request::Request;
 use crate::response::Response;
@ -26,50 +27,60 @@ use super::dispatcher::Dispatcher;
 pub struct H2Service<T, P, S, B> {
    srv: S,
    cfg: ServiceConfig,
+    on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
    _t: PhantomData<(T, P, B)>,
 }

 impl<T, P, S, B> H2Service<T, P, S, B>
 where
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
-    S::Error: Debug + 'static,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
+    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static,
 {
    /// Create new `HttpService` instance.
-    pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self {
+    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);

        H2Service {
            cfg,
+            on_connect: None,
            srv: service.into_new_service(),
            _t: PhantomData,
        }
    }

    /// Create new `HttpService` instance with config.
-    pub fn with_config<F: IntoNewService<S, SrvConfig>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
+    pub fn with_config<F: IntoNewService<S>>(cfg: ServiceConfig, service: F) -> Self {
        H2Service {
            cfg,
+            on_connect: None,
            srv: service.into_new_service(),
            _t: PhantomData,
        }
    }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
 }

-impl<T, P, S, B> NewService<SrvConfig> for H2Service<T, P, S, B>
+impl<T, P, S, B> NewService for H2Service<T, P, S, B>
 where
-    T: AsyncRead + AsyncWrite,
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
-    S::Error: Debug,
+    T: IoStream,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
+    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static,
 {
+    type Config = SrvConfig;
    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
@ -81,25 +92,27 @@ where
        H2ServiceResponse {
            fut: self.srv.new_service(cfg).into_future(),
            cfg: Some(self.cfg.clone()),
+            on_connect: self.on_connect.clone(),
            _t: PhantomData,
        }
    }
 }

 #[doc(hidden)]
-pub struct H2ServiceResponse<T, P, S: NewService<SrvConfig, Request = Request>, B> {
+pub struct H2ServiceResponse<T, P, S: NewService, B> {
    fut: <S::Future as IntoFuture>::Future,
    cfg: Option<ServiceConfig>,
+    on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
    _t: PhantomData<(T, P, B)>,
 }

 impl<T, P, S, B> Future for H2ServiceResponse<T, P, S, B>
 where
-    T: AsyncRead + AsyncWrite,
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
+    T: IoStream,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
-    S::Error: Debug,
+    <S::Service as Service>::Future: 'static,
    B: MessageBody + 'static,
 {
    type Item = H2ServiceHandler<T, P, S::Service, B>;
@ -109,28 +122,36 @@ where
        let service = try_ready!(self.fut.poll());
        Ok(Async::Ready(H2ServiceHandler::new(
            self.cfg.take().unwrap(),
+            self.on_connect.clone(),
            service,
        )))
    }
 }

 /// `Service` implementation for http/2 transport
-pub struct H2ServiceHandler<T, P, S: 'static, B> {
+pub struct H2ServiceHandler<T, P, S, B> {
    srv: CloneableService<S>,
    cfg: ServiceConfig,
+    on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
    _t: PhantomData<(T, P, B)>,
 }

 impl<T, P, S, B> H2ServiceHandler<T, P, S, B>
 where
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
-    fn new(cfg: ServiceConfig, srv: S) -> H2ServiceHandler<T, P, S, B> {
+    fn new(
+        cfg: ServiceConfig,
+        on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+        srv: S,
+    ) -> H2ServiceHandler<T, P, S, B> {
        H2ServiceHandler {
            cfg,
+            on_connect,
            srv: CloneableService::new(srv),
            _t: PhantomData,
        }
@ -139,9 +160,10 @@ where

 impl<T, P, S, B> Service for H2ServiceHandler<T, P, S, B>
 where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
@ -152,40 +174,53 @@ where

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
        self.srv.poll_ready().map_err(|e| {
+            let e = e.into();
            error!("Service readiness error: {:?}", e);
-            DispatchError::Service
+            DispatchError::Service(e)
        })
    }

    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let io = req.into_parts().0;
+        let peer_addr = io.peer_addr();
+        let on_connect = if let Some(ref on_connect) = self.on_connect {
+            Some(on_connect(&io))
+        } else {
+            None
+        };
+
        H2ServiceHandlerResponse {
            state: State::Handshake(
                Some(self.srv.clone()),
                Some(self.cfg.clone()),
-                server::handshake(req.into_parts().0),
+                peer_addr,
+                on_connect,
+                server::handshake(io),
            ),
        }
    }
 }

-enum State<
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    B: MessageBody,
-> {
+enum State<T: IoStream, S: Service<Request = Request>, B: MessageBody>
+where
+    S::Future: 'static,
+{
    Incoming(Dispatcher<T, S, B>),
    Handshake(
        Option<CloneableService<S>>,
        Option<ServiceConfig>,
+        Option<net::SocketAddr>,
+        Option<Box<dyn DataFactory>>,
        Handshake<T, Bytes>,
    ),
 }

 pub struct H2ServiceHandlerResponse<T, S, B>
 where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
@ -194,9 +229,10 @@ where

 impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
 where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
    S::Response: Into<Response<B>>,
    B: MessageBody,
 {
@ -206,24 +242,30 @@ where
    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        match self.state {
            State::Incoming(ref mut disp) => disp.poll(),
-            State::Handshake(ref mut srv, ref mut config, ref mut handshake) => {
-                match handshake.poll() {
-                    Ok(Async::Ready(conn)) => {
-                        self.state = State::Incoming(Dispatcher::new(
-                            srv.take().unwrap(),
-                            conn,
-                            config.take().unwrap(),
-                            None,
-                        ));
-                        self.poll()
-                    }
-                    Ok(Async::NotReady) => Ok(Async::NotReady),
-                    Err(err) => {
-                        trace!("H2 handshake error: {}", err);
-                        return Err(err.into());
-                    }
+            State::Handshake(
+                ref mut srv,
+                ref mut config,
+                ref peer_addr,
+                ref mut on_connect,
+                ref mut handshake,
+            ) => match handshake.poll() {
+                Ok(Async::Ready(conn)) => {
+                    self.state = State::Incoming(Dispatcher::new(
+                        srv.take().unwrap(),
+                        conn,
+                        on_connect.take(),
+                        config.take().unwrap(),
+                        None,
+                        peer_addr.clone(),
+                    ));
+                    self.poll()
                }
-            }
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Err(err) => {
+                    trace!("H2 handshake error: {}", err);
+                    Err(err.into())
+                }
+            },
        }
    }
 }
--- a/actix-http/src/header/common/cache_control.rs
+++ b/actix-http/src/header/common/cache_control.rs
@ -64,7 +64,7 @@ impl Header for CacheControl {
    where
        T: crate::HttpMessage,
    {
-        let directives = from_comma_delimited(msg.headers().get_all(Self::name()))?;
+        let directives = from_comma_delimited(msg.headers().get_all(&Self::name()))?;
        if !directives.is_empty() {
            Ok(CacheControl(directives))
        } else {
--- a/actix-http/src/header/common/content_disposition.rs
+++ b/actix-http/src/header/common/content_disposition.rs
@ -444,7 +444,7 @@ impl Header for ContentDisposition {
    }

    fn parse<T: crate::HttpMessage>(msg: &T) -> Result<Self, crate::error::ParseError> {
-        if let Some(h) = msg.headers().get(Self::name()) {
+        if let Some(h) = msg.headers().get(&Self::name()) {
            Self::from_raw(&h)
        } else {
            Err(crate::error::ParseError::Header)
--- a/actix-http/src/header/common/if_range.rs
+++ b/actix-http/src/header/common/if_range.rs
@ -73,12 +73,12 @@ impl Header for IfRange {
        T: HttpMessage,
    {
        let etag: Result<EntityTag, _> =
-            from_one_raw_str(msg.headers().get(header::IF_RANGE));
+            from_one_raw_str(msg.headers().get(&header::IF_RANGE));
        if let Ok(etag) = etag {
            return Ok(IfRange::EntityTag(etag));
        }
        let date: Result<HttpDate, _> =
-            from_one_raw_str(msg.headers().get(header::IF_RANGE));
+            from_one_raw_str(msg.headers().get(&header::IF_RANGE));
        if let Ok(date) = date {
            return Ok(IfRange::Date(date));
        }
--- a/actix-http/src/header/map.rs
+++ b/actix-http/src/header/map.rs
@ -0,0 +1,384 @@
+use either::Either;
+use hashbrown::hash_map::{self, Entry};
+use hashbrown::HashMap;
+use http::header::{HeaderName, HeaderValue};
+use http::HttpTryFrom;
+
+/// A set of HTTP headers
+///
+/// `HeaderMap` is an multimap of [`HeaderName`] to values.
+///
+/// [`HeaderName`]: struct.HeaderName.html
+#[derive(Debug)]
+pub struct HeaderMap {
+    pub(crate) inner: HashMap<HeaderName, Value>,
+}
+
+#[derive(Debug)]
+pub(crate) enum Value {
+    One(HeaderValue),
+    Multi(Vec<HeaderValue>),
+}
+
+impl Value {
+    fn get(&self) -> &HeaderValue {
+        match self {
+            Value::One(ref val) => val,
+            Value::Multi(ref val) => &val[0],
+        }
+    }
+
+    fn get_mut(&mut self) -> &mut HeaderValue {
+        match self {
+            Value::One(ref mut val) => val,
+            Value::Multi(ref mut val) => &mut val[0],
+        }
+    }
+
+    fn append(&mut self, val: HeaderValue) {
+        match self {
+            Value::One(_) => {
+                let data = std::mem::replace(self, Value::Multi(vec![val]));
+                match data {
+                    Value::One(val) => self.append(val),
+                    Value::Multi(_) => unreachable!(),
+                }
+            }
+            Value::Multi(ref mut vec) => vec.push(val),
+        }
+    }
+}
+
+impl HeaderMap {
+    /// Create an empty `HeaderMap`.
+    ///
+    /// The map will be created without any capacity. This function will not
+    /// allocate.
+    pub fn new() -> Self {
+        HeaderMap {
+            inner: HashMap::new(),
+        }
+    }
+
+    /// Create an empty `HeaderMap` with the specified capacity.
+    ///
+    /// The returned map will allocate internal storage in order to hold about
+    /// `capacity` elements without reallocating. However, this is a "best
+    /// effort" as there are usage patterns that could cause additional
+    /// allocations before `capacity` headers are stored in the map.
+    ///
+    /// More capacity than requested may be allocated.
+    pub fn with_capacity(capacity: usize) -> HeaderMap {
+        HeaderMap {
+            inner: HashMap::with_capacity(capacity),
+        }
+    }
+
+    /// Returns the number of keys stored in the map.
+    ///
+    /// This number could be be less than or equal to actual headers stored in
+    /// the map.
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    /// Returns true if the map contains no elements.
+    pub fn is_empty(&self) -> bool {
+        self.inner.len() == 0
+    }
+
+    /// Clears the map, removing all key-value pairs. Keeps the allocated memory
+    /// for reuse.
+    pub fn clear(&mut self) {
+        self.inner.clear();
+    }
+
+    /// Returns the number of headers the map can hold without reallocating.
+    ///
+    /// This number is an approximation as certain usage patterns could cause
+    /// additional allocations before the returned capacity is filled.
+    pub fn capacity(&self) -> usize {
+        self.inner.capacity()
+    }
+
+    /// Reserves capacity for at least `additional` more headers to be inserted
+    /// into the `HeaderMap`.
+    ///
+    /// The header map may reserve more space to avoid frequent reallocations.
+    /// Like with `with_capacity`, this will be a "best effort" to avoid
+    /// allocations until `additional` more headers are inserted. Certain usage
+    /// patterns could cause additional allocations before the number is
+    /// reached.
+    pub fn reserve(&mut self, additional: usize) {
+        self.inner.reserve(additional)
+    }
+
+    /// Returns a reference to the value associated with the key.
+    ///
+    /// If there are multiple values associated with the key, then the first one
+    /// is returned. Use `get_all` to get all values associated with a given
+    /// key. Returns `None` if there are no values associated with the key.
+    pub fn get<N: AsName>(&self, name: N) -> Option<&HeaderValue> {
+        self.get2(name).map(|v| v.get())
+    }
+
+    fn get2<N: AsName>(&self, name: N) -> Option<&Value> {
+        match name.as_name() {
+            Either::Left(name) => self.inner.get(name),
+            Either::Right(s) => {
+                if let Ok(name) = HeaderName::try_from(s) {
+                    self.inner.get(&name)
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    /// Returns a view of all values associated with a key.
+    ///
+    /// The returned view does not incur any allocations and allows iterating
+    /// the values associated with the key.  See [`GetAll`] for more details.
+    /// Returns `None` if there are no values associated with the key.
+    ///
+    /// [`GetAll`]: struct.GetAll.html
+    pub fn get_all<N: AsName>(&self, name: N) -> GetAll {
+        GetAll {
+            idx: 0,
+            item: self.get2(name),
+        }
+    }
+
+    /// Returns a mutable reference to the value associated with the key.
+    ///
+    /// If there are multiple values associated with the key, then the first one
+    /// is returned. Use `entry` to get all values associated with a given
+    /// key. Returns `None` if there are no values associated with the key.
+    pub fn get_mut<N: AsName>(&mut self, name: N) -> Option<&mut HeaderValue> {
+        match name.as_name() {
+            Either::Left(name) => self.inner.get_mut(name).map(|v| v.get_mut()),
+            Either::Right(s) => {
+                if let Ok(name) = HeaderName::try_from(s) {
+                    self.inner.get_mut(&name).map(|v| v.get_mut())
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    /// Returns true if the map contains a value for the specified key.
+    pub fn contains_key<N: AsName>(&self, key: N) -> bool {
+        match key.as_name() {
+            Either::Left(name) => self.inner.contains_key(name),
+            Either::Right(s) => {
+                if let Ok(name) = HeaderName::try_from(s) {
+                    self.inner.contains_key(&name)
+                } else {
+                    false
+                }
+            }
+        }
+    }
+
+    /// An iterator visiting all key-value pairs.
+    ///
+    /// The iteration order is arbitrary, but consistent across platforms for
+    /// the same crate version. Each key will be yielded once per associated
+    /// value. So, if a key has 3 associated values, it will be yielded 3 times.
+    pub fn iter(&self) -> Iter {
+        Iter::new(self.inner.iter())
+    }
+
+    /// An iterator visiting all keys.
+    ///
+    /// The iteration order is arbitrary, but consistent across platforms for
+    /// the same crate version. Each key will be yielded only once even if it
+    /// has multiple associated values.
+    pub fn keys(&self) -> Keys {
+        Keys(self.inner.keys())
+    }
+
+    /// Inserts a key-value pair into the map.
+    ///
+    /// If the map did not previously have this key present, then `None` is
+    /// returned.
+    ///
+    /// If the map did have this key present, the new value is associated with
+    /// the key and all previous values are removed. **Note** that only a single
+    /// one of the previous values is returned. If there are multiple values
+    /// that have been previously associated with the key, then the first one is
+    /// returned. See `insert_mult` on `OccupiedEntry` for an API that returns
+    /// all values.
+    ///
+    /// The key is not updated, though; this matters for types that can be `==`
+    /// without being identical.
+    pub fn insert(&mut self, key: HeaderName, val: HeaderValue) {
+        let _ = self.inner.insert(key, Value::One(val));
+    }
+
+    /// Inserts a key-value pair into the map.
+    ///
+    /// If the map did not previously have this key present, then `false` is
+    /// returned.
+    ///
+    /// If the map did have this key present, the new value is pushed to the end
+    /// of the list of values currently associated with the key. The key is not
+    /// updated, though; this matters for types that can be `==` without being
+    /// identical.
+    pub fn append(&mut self, key: HeaderName, value: HeaderValue) {
+        match self.inner.entry(key) {
+            Entry::Occupied(mut entry) => entry.get_mut().append(value),
+            Entry::Vacant(entry) => {
+                entry.insert(Value::One(value));
+            }
+        }
+    }
+
+    /// Removes all headers for a particular header name from the map.
+    pub fn remove<N: AsName>(&mut self, key: N) {
+        match key.as_name() {
+            Either::Left(name) => {
+                let _ = self.inner.remove(name);
+            }
+            Either::Right(s) => {
+                if let Ok(name) = HeaderName::try_from(s) {
+                    let _ = self.inner.remove(&name);
+                }
+            }
+        }
+    }
+}
+
+#[doc(hidden)]
+pub trait AsName {
+    fn as_name(&self) -> Either<&HeaderName, &str>;
+}
+
+impl AsName for HeaderName {
+    fn as_name(&self) -> Either<&HeaderName, &str> {
+        Either::Left(self)
+    }
+}
+
+impl<'a> AsName for &'a HeaderName {
+    fn as_name(&self) -> Either<&HeaderName, &str> {
+        Either::Left(self)
+    }
+}
+
+impl<'a> AsName for &'a str {
+    fn as_name(&self) -> Either<&HeaderName, &str> {
+        Either::Right(self)
+    }
+}
+
+impl AsName for String {
+    fn as_name(&self) -> Either<&HeaderName, &str> {
+        Either::Right(self.as_str())
+    }
+}
+
+impl<'a> AsName for &'a String {
+    fn as_name(&self) -> Either<&HeaderName, &str> {
+        Either::Right(self.as_str())
+    }
+}
+
+pub struct GetAll<'a> {
+    idx: usize,
+    item: Option<&'a Value>,
+}
+
+impl<'a> Iterator for GetAll<'a> {
+    type Item = &'a HeaderValue;
+
+    #[inline]
+    fn next(&mut self) -> Option<&'a HeaderValue> {
+        if let Some(ref val) = self.item {
+            match val {
+                Value::One(ref val) => {
+                    self.item.take();
+                    Some(val)
+                }
+                Value::Multi(ref vec) => {
+                    if self.idx < vec.len() {
+                        let item = Some(&vec[self.idx]);
+                        self.idx += 1;
+                        item
+                    } else {
+                        self.item.take();
+                        None
+                    }
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
+
+pub struct Keys<'a>(hash_map::Keys<'a, HeaderName, Value>);
+
+impl<'a> Iterator for Keys<'a> {
+    type Item = &'a HeaderName;
+
+    #[inline]
+    fn next(&mut self) -> Option<&'a HeaderName> {
+        self.0.next()
+    }
+}
+
+impl<'a> IntoIterator for &'a HeaderMap {
+    type Item = (&'a HeaderName, &'a HeaderValue);
+    type IntoIter = Iter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+pub struct Iter<'a> {
+    idx: usize,
+    current: Option<(&'a HeaderName, &'a Vec<HeaderValue>)>,
+    iter: hash_map::Iter<'a, HeaderName, Value>,
+}
+
+impl<'a> Iter<'a> {
+    fn new(iter: hash_map::Iter<'a, HeaderName, Value>) -> Self {
+        Self {
+            iter,
+            idx: 0,
+            current: None,
+        }
+    }
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = (&'a HeaderName, &'a HeaderValue);
+
+    #[inline]
+    fn next(&mut self) -> Option<(&'a HeaderName, &'a HeaderValue)> {
+        if let Some(ref mut item) = self.current {
+            if self.idx < item.1.len() {
+                let item = (item.0, &item.1[self.idx]);
+                self.idx += 1;
+                return Some(item);
+            } else {
+                self.idx = 0;
+                self.current.take();
+            }
+        }
+        if let Some(item) = self.iter.next() {
+            match item.1 {
+                Value::One(ref value) => Some((item.0, value)),
+                Value::Multi(ref vec) => {
+                    self.current = Some((item.0, vec));
+                    self.next()
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
--- a/actix-http/src/header/mod.rs
+++ b/actix-http/src/header/mod.rs
@ -4,7 +4,6 @@
 use std::{fmt, str::FromStr};

 use bytes::{Bytes, BytesMut};
-use http::header::GetAll;
 use http::Error as HttpError;
 use mime::Mime;

@ -14,6 +13,7 @@ use crate::error::ParseError;
 use crate::httpmessage::HttpMessage;

 mod common;
+pub(crate) mod map;
 mod shared;
 #[doc(hidden)]
 pub use self::common::*;
@ -21,6 +21,9 @@ pub use self::common::*;
 pub use self::shared::*;

 #[doc(hidden)]
+pub use self::map::GetAll;
+pub use self::map::HeaderMap;
+
 /// A trait for any object that will represent a header field and value.
 pub trait Header
 where
@ -33,7 +36,6 @@ where
    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.
@ -97,6 +99,26 @@ impl IntoHeaderValue for String {
    }
 }

+impl IntoHeaderValue for usize {
+    type Error = InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let s = format!("{}", self);
+        HeaderValue::from_shared(Bytes::from(s))
+    }
+}
+
+impl IntoHeaderValue for u64 {
+    type Error = InvalidHeaderValueBytes;
+
+    #[inline]
+    fn try_into(self) -> Result<HeaderValue, Self::Error> {
+        let s = format!("{}", self);
+        HeaderValue::from_shared(Bytes::from(s))
+    }
+}
+
 impl IntoHeaderValue for Mime {
    type Error = InvalidHeaderValueBytes;

@ -202,8 +224,8 @@ impl fmt::Write for Writer {
 #[inline]
 #[doc(hidden)]
 /// Reads a comma-delimited raw header into a Vec.
-pub fn from_comma_delimited<T: FromStr>(
-    all: GetAll<HeaderValue>,
+pub fn from_comma_delimited<'a, I: Iterator<Item = &'a HeaderValue> + 'a, T: FromStr>(
+    all: I,
 ) -> Result<Vec<T>, ParseError> {
    let mut result = Vec::new();
    for h in all {
@ -361,6 +383,17 @@ pub fn http_percent_encode(f: &mut fmt::Formatter, bytes: &[u8]) -> fmt::Result
    fmt::Display::fmt(&encoded, f)
 }

+/// Convert http::HeaderMap to a HeaderMap
+impl From<http::HeaderMap> for HeaderMap {
+    fn from(map: http::HeaderMap) -> HeaderMap {
+        let mut new_map = HeaderMap::with_capacity(map.capacity());
+        for (h, v) in map.iter() {
+            new_map.append(h.clone(), v.clone());
+        }
+        new_map
+    }
+}
+
 mod percent_encoding_http {
    use percent_encoding::{self, define_encode_set};

--- a/actix-http/src/helpers.rs
+++ b/actix-http/src/helpers.rs
@ -1,6 +1,9 @@
+use std::{io, mem, ptr, slice};
+
 use bytes::{BufMut, BytesMut};
 use http::Version;
-use std::{mem, ptr, slice};
+
+use crate::extensions::Extensions;

 const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
      2021222324252627282930313233343536373839\
@ -167,6 +170,30 @@ pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
    }
 }

+pub(crate) struct Writer<'a>(pub &'a mut BytesMut);
+
+impl<'a> io::Write for Writer<'a> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+pub(crate) trait DataFactory {
+    fn set(&self, ext: &mut Extensions);
+}
+
+pub(crate) struct Data<T>(pub(crate) T);
+
+impl<T: Clone + 'static> DataFactory for Data<T> {
+    fn set(&self, ext: &mut Extensions) {
+        ext.insert(self.0.clone())
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/actix-http/src/httpcodes.rs
+++ b/actix-http/src/httpcodes.rs
@ -8,7 +8,7 @@ macro_rules! STATIC_RESP {
    ($name:ident, $status:expr) => {
        #[allow(non_snake_case, missing_docs)]
        pub fn $name() -> ResponseBuilder {
-            Response::build($status)
+            ResponseBuilder::new($status)
        }
    };
 }
@ -60,6 +60,8 @@ impl Response {
    STATIC_RESP!(UnsupportedMediaType, StatusCode::UNSUPPORTED_MEDIA_TYPE);
    STATIC_RESP!(RangeNotSatisfiable, StatusCode::RANGE_NOT_SATISFIABLE);
    STATIC_RESP!(ExpectationFailed, StatusCode::EXPECTATION_FAILED);
+    STATIC_RESP!(UnprocessableEntity, StatusCode::UNPROCESSABLE_ENTITY);
+    STATIC_RESP!(TooManyRequests, StatusCode::TOO_MANY_REQUESTS);

    STATIC_RESP!(InternalServerError, StatusCode::INTERNAL_SERVER_ERROR);
    STATIC_RESP!(NotImplemented, StatusCode::NOT_IMPLEMENTED);
--- a/actix-http/src/httpmessage.rs
+++ b/actix-http/src/httpmessage.rs
@ -1,23 +1,16 @@
 use std::cell::{Ref, RefMut};
 use std::str;

-use encoding::all::UTF_8;
-use encoding::label::encoding_from_whatwg_label;
-use encoding::EncodingRef;
-use http::{header, HeaderMap};
+use encoding_rs::{Encoding, UTF_8};
+use http::header;
 use mime::Mime;

-use crate::error::{ContentTypeError, ParseError};
+use crate::cookie::Cookie;
+use crate::error::{ContentTypeError, CookieParseError, ParseError};
 use crate::extensions::Extensions;
-use crate::header::Header;
+use crate::header::{Header, HeaderMap};
 use crate::payload::Payload;

-#[cfg(feature = "cookies")]
-use crate::error::CookieParseError;
-#[cfg(feature = "cookies")]
-use cookie::Cookie;
-
-#[cfg(feature = "cookies")]
 struct Cookies(Vec<Cookie<'static>>);

 /// Trait that implements general purpose operations on http messages
@ -64,10 +57,12 @@ pub trait HttpMessage: Sized {
    /// Get content type encoding
    ///
    /// UTF-8 is used by default, If request charset is not set.
-    fn encoding(&self) -> Result<EncodingRef, ContentTypeError> {
+    fn encoding(&self) -> Result<&'static Encoding, ContentTypeError> {
        if let Some(mime_type) = self.mime_type()? {
            if let Some(charset) = mime_type.get_param("charset") {
-                if let Some(enc) = encoding_from_whatwg_label(charset.as_str()) {
+                if let Some(enc) =
+                    Encoding::for_label_no_replacement(charset.as_str().as_bytes())
+                {
                    Ok(enc)
                } else {
                    Err(ContentTypeError::UnknownEncoding)
@ -110,7 +105,6 @@ pub trait HttpMessage: Sized {

    /// Load request cookies.
    #[inline]
-    #[cfg(feature = "cookies")]
    fn cookies(&self) -> Result<Ref<Vec<Cookie<'static>>>, CookieParseError> {
        if self.extensions().get::<Cookies>().is_none() {
            let mut cookies = Vec::new();
@ -131,7 +125,6 @@ pub trait HttpMessage: Sized {
    }

    /// Return request cookie.
-    #[cfg(feature = "cookies")]
    fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
        if let Ok(cookies) = self.cookies() {
            for cookie in cookies.iter() {
@ -173,8 +166,7 @@ where
 #[cfg(test)]
 mod tests {
    use bytes::Bytes;
-    use encoding::all::ISO_8859_2;
-    use encoding::Encoding;
+    use encoding_rs::ISO_8859_2;
    use mime;

    use super::*;
@ -230,7 +222,7 @@ mod tests {
            "application/json; charset=ISO-8859-2",
        )
        .finish();
-        assert_eq!(ISO_8859_2.name(), req.encoding().unwrap().name());
+        assert_eq!(ISO_8859_2, req.encoding().unwrap());
    }

    #[test]
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@ -2,7 +2,7 @@
 #![allow(
    clippy::type_complexity,
    clippy::new_without_default,
-    clippy::new_without_default_derive
+    clippy::borrow_interior_mutable_const
 )]

 #[macro_use]
@ -24,6 +24,7 @@ mod request;
 mod response;
 mod service;

+pub mod cookie;
 pub mod error;
 pub mod h1;
 pub mod h2;
@ -39,23 +40,19 @@ pub use self::message::{Message, RequestHead, ResponseHead};
 pub use self::payload::{Payload, PayloadStream};
 pub use self::request::Request;
 pub use self::response::{Response, ResponseBuilder};
-pub use self::service::{HttpService, SendError, SendResponse};
+pub use self::service::HttpService;

 pub mod http {
    //! Various HTTP related types

    // re-exports
    pub use http::header::{HeaderName, HeaderValue};
+    pub use http::uri::PathAndQuery;
+    pub use http::{uri, Error, HttpTryFrom, Uri};
    pub use http::{Method, StatusCode, Version};

-    #[doc(hidden)]
-    pub use http::{uri, Error, HeaderMap, HttpTryFrom, Uri};
-
-    #[doc(hidden)]
-    pub use http::uri::PathAndQuery;
-
-    #[cfg(feature = "cookies")]
-    pub use cookie::{Cookie, CookieBuilder};
+    pub use crate::cookie::{Cookie, CookieBuilder};
+    pub use crate::header::HeaderMap;

    /// Various http headers
    pub mod header {
--- a/actix-http/src/message.rs
+++ b/actix-http/src/message.rs
@ -1,11 +1,13 @@
 use std::cell::{Ref, RefCell, RefMut};
-use std::collections::VecDeque;
+use std::net;
 use std::rc::Rc;

 use bitflags::bitflags;
+use copyless::BoxHelper;

 use crate::extensions::Extensions;
-use crate::http::{header, HeaderMap, Method, StatusCode, Uri, Version};
+use crate::header::HeaderMap;
+use crate::http::{header, Method, StatusCode, Uri, Version};

 /// Represents various types of connection
 #[derive(Copy, Clone, PartialEq, Debug)]
@ -23,7 +25,9 @@ bitflags! {
        const CLOSE       = 0b0000_0001;
        const KEEP_ALIVE  = 0b0000_0010;
        const UPGRADE     = 0b0000_0100;
-        const NO_CHUNKING = 0b0000_1000;
+        const EXPECT      = 0b0000_1000;
+        const NO_CHUNKING = 0b0001_0000;
+        const CAMEL_CASE  = 0b0010_0000;
    }
 }

@ -41,6 +45,7 @@ pub struct RequestHead {
    pub version: Version,
    pub headers: HeaderMap,
    pub extensions: RefCell<Extensions>,
+    pub peer_addr: Option<net::SocketAddr>,
    flags: Flags,
 }

@ -52,6 +57,7 @@ impl Default for RequestHead {
            version: Version::HTTP_11,
            headers: HeaderMap::with_capacity(16),
            flags: Flags::empty(),
+            peer_addr: None,
            extensions: RefCell::new(Extensions::new()),
        }
    }
@ -92,6 +98,23 @@ impl RequestHead {
        &mut self.headers
    }

+    /// Is to uppercase headers with Camel-Case.
+    /// Befault is `false`
+    #[inline]
+    pub fn camel_case_headers(&self) -> bool {
+        self.flags.contains(Flags::CAMEL_CASE)
+    }
+
+    /// Set `true` to send headers which are uppercased with Camel-Case.
+    #[inline]
+    pub fn set_camel_case_headers(&mut self, val: bool) {
+        if val {
+            self.flags.insert(Flags::CAMEL_CASE);
+        } else {
+            self.flags.remove(Flags::CAMEL_CASE);
+        }
+    }
+
    #[inline]
    /// Set connection type of the message
    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
@ -145,6 +168,17 @@ impl RequestHead {
            self.flags.remove(Flags::NO_CHUNKING);
        }
    }
+
+    #[inline]
+    /// Request contains `EXPECT` header
+    pub fn expect(&self) -> bool {
+        self.flags.contains(Flags::EXPECT)
+    }
+
+    #[inline]
+    pub(crate) fn set_expect(&mut self) {
+        self.flags.insert(Flags::EXPECT);
+    }
 }

 #[derive(Debug)]
@ -157,32 +191,20 @@ pub struct ResponseHead {
    flags: Flags,
 }

-impl Default for ResponseHead {
-    fn default() -> ResponseHead {
+impl ResponseHead {
+    /// Create new instance of `ResponseHead` type
+    #[inline]
+    pub fn new(status: StatusCode) -> ResponseHead {
        ResponseHead {
+            status,
            version: Version::default(),
-            status: StatusCode::OK,
-            headers: HeaderMap::with_capacity(16),
+            headers: HeaderMap::with_capacity(12),
            reason: None,
            flags: Flags::empty(),
            extensions: RefCell::new(Extensions::new()),
        }
    }
-}

-impl Head for ResponseHead {
-    fn clear(&mut self) {
-        self.reason = None;
-        self.flags = Flags::empty();
-        self.headers.clear();
-    }
-
-    fn pool() -> &'static MessagePool<Self> {
-        RESPONSE_POOL.with(|p| *p)
-    }
-}
-
-impl ResponseHead {
    /// Message extensions
    #[inline]
    pub fn extensions(&self) -> Ref<Extensions> {
@ -288,7 +310,6 @@ impl ResponseHead {

 pub struct Message<T: Head> {
    head: Rc<T>,
-    pool: &'static MessagePool<T>,
 }

 impl<T: Head> Message<T> {
@ -302,7 +323,6 @@ impl<T: Head> Clone for Message<T> {
    fn clone(&self) -> Self {
        Message {
            head: self.head.clone(),
-            pool: self.pool,
        }
    }
 }
@ -324,39 +344,70 @@ impl<T: Head> std::ops::DerefMut for Message<T> {
 impl<T: Head> Drop for Message<T> {
    fn drop(&mut self) {
        if Rc::strong_count(&self.head) == 1 {
-            self.pool.release(self.head.clone());
+            T::pool().release(self.head.clone());
        }
    }
 }

+pub(crate) struct BoxedResponseHead {
+    head: Option<Box<ResponseHead>>,
+}
+
+impl BoxedResponseHead {
+    /// Get new message from the pool of objects
+    pub fn new(status: StatusCode) -> Self {
+        RESPONSE_POOL.with(|p| p.get_message(status))
+    }
+}
+
+impl std::ops::Deref for BoxedResponseHead {
+    type Target = ResponseHead;
+
+    fn deref(&self) -> &Self::Target {
+        self.head.as_ref().unwrap()
+    }
+}
+
+impl std::ops::DerefMut for BoxedResponseHead {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.head.as_mut().unwrap()
+    }
+}
+
+impl Drop for BoxedResponseHead {
+    fn drop(&mut self) {
+        RESPONSE_POOL.with(|p| p.release(self.head.take().unwrap()))
+    }
+}
+
 #[doc(hidden)]
 /// Request's objects pool
-pub struct MessagePool<T: Head>(RefCell<VecDeque<Rc<T>>>);
+pub struct MessagePool<T: Head>(RefCell<Vec<Rc<T>>>);
+
+#[doc(hidden)]
+/// Request's objects pool
+pub struct BoxedResponsePool(RefCell<Vec<Box<ResponseHead>>>);

 thread_local!(static REQUEST_POOL: &'static MessagePool<RequestHead> = MessagePool::<RequestHead>::create());
-thread_local!(static RESPONSE_POOL: &'static MessagePool<ResponseHead> = MessagePool::<ResponseHead>::create());
+thread_local!(static RESPONSE_POOL: &'static BoxedResponsePool = BoxedResponsePool::create());

 impl<T: Head> MessagePool<T> {
    fn create() -> &'static MessagePool<T> {
-        let pool = MessagePool(RefCell::new(VecDeque::with_capacity(128)));
+        let pool = MessagePool(RefCell::new(Vec::with_capacity(128)));
        Box::leak(Box::new(pool))
    }

    /// Get message from the pool
    #[inline]
    fn get_message(&'static self) -> Message<T> {
-        if let Some(mut msg) = self.0.borrow_mut().pop_front() {
+        if let Some(mut msg) = self.0.borrow_mut().pop() {
            if let Some(r) = Rc::get_mut(&mut msg) {
                r.clear();
            }
-            Message {
-                head: msg,
-                pool: self,
-            }
+            Message { head: msg }
        } else {
            Message {
                head: Rc::new(T::default()),
-                pool: self,
            }
        }
    }
@ -366,7 +417,40 @@ impl<T: Head> MessagePool<T> {
    fn release(&self, msg: Rc<T>) {
        let v = &mut self.0.borrow_mut();
        if v.len() < 128 {
-            v.push_front(msg);
+            v.push(msg);
+        }
+    }
+}
+
+impl BoxedResponsePool {
+    fn create() -> &'static BoxedResponsePool {
+        let pool = BoxedResponsePool(RefCell::new(Vec::with_capacity(128)));
+        Box::leak(Box::new(pool))
+    }
+
+    /// Get message from the pool
+    #[inline]
+    fn get_message(&'static self, status: StatusCode) -> BoxedResponseHead {
+        if let Some(mut head) = self.0.borrow_mut().pop() {
+            head.reason = None;
+            head.status = status;
+            head.headers.clear();
+            head.flags = Flags::empty();
+            BoxedResponseHead { head: Some(head) }
+        } else {
+            BoxedResponseHead {
+                head: Some(Box::alloc().init(ResponseHead::new(status))),
+            }
+        }
+    }
+
+    #[inline]
+    /// Release request instance
+    fn release(&self, msg: Box<ResponseHead>) {
+        let v = &mut self.0.borrow_mut();
+        if v.len() < 128 {
+            msg.extensions.borrow_mut().clear();
+            v.push(msg);
        }
    }
 }
--- a/actix-http/src/payload.rs
+++ b/actix-http/src/payload.rs
@ -53,6 +53,7 @@ where
    type Item = Bytes;
    type Error = PayloadError;

+    #[inline]
    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
        match self {
            Payload::None => Ok(Async::Ready(None)),
--- a/actix-http/src/request.rs
+++ b/actix-http/src/request.rs
@ -1,9 +1,10 @@
 use std::cell::{Ref, RefMut};
-use std::fmt;
+use std::{fmt, net};

-use http::{header, HeaderMap, Method, Uri, Version};
+use http::{header, Method, Uri, Version};

 use crate::extensions::Extensions;
+use crate::header::HeaderMap;
 use crate::httpmessage::HttpMessage;
 use crate::message::{Message, RequestHead};
 use crate::payload::{Payload, PayloadStream};
@ -138,6 +139,7 @@ impl<P> Request<P> {
    }

    /// Check if request requires connection upgrade
+    #[inline]
    pub fn upgrade(&self) -> bool {
        if let Some(conn) = self.head().headers.get(header::CONNECTION) {
            if let Ok(s) = conn.to_str() {
@ -146,6 +148,15 @@ impl<P> Request<P> {
        }
        self.head().method == Method::CONNECT
    }
+
+    /// Peer socket address
+    ///
+    /// Peer address is actual socket address, if proxy is used in front of
+    /// actix http server, then peer address would be address of this proxy.
+    #[inline]
+    pub fn peer_addr(&self) -> Option<net::SocketAddr> {
+        self.head().peer_addr
+    }
 }

 impl<P> fmt::Debug for Request<P> {
@ -161,9 +172,34 @@ impl<P> fmt::Debug for Request<P> {
            writeln!(f, "  query: ?{:?}", q)?;
        }
        writeln!(f, "  headers:")?;
-        for (key, val) in self.headers().iter() {
+        for (key, val) in self.headers() {
            writeln!(f, "    {:?}: {:?}", key, val)?;
        }
        Ok(())
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::HttpTryFrom;
+
+    #[test]
+    fn test_basics() {
+        let msg = Message::new();
+        let mut req = Request::from(msg);
+        req.headers_mut().insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("text/plain"),
+        );
+        assert!(req.headers().contains_key(header::CONTENT_TYPE));
+
+        *req.uri_mut() = Uri::try_from("/index.html?q=1").unwrap();
+        assert_eq!(req.uri().path(), "/index.html");
+        assert_eq!(req.uri().query(), Some("q=1"));
+
+        let s = format!("{:?}", req);
+        println!("T: {:?}", s);
+        assert!(s.contains("Request HTTP/1.1 GET:/index.html"));
+    }
+}
--- a/actix-http/src/response.rs
+++ b/actix-http/src/response.rs
@ -4,24 +4,23 @@ use std::io::Write;
 use std::{fmt, str};

 use bytes::{BufMut, Bytes, BytesMut};
-#[cfg(feature = "cookies")]
-use cookie::{Cookie, CookieJar};
 use futures::future::{ok, FutureResult, IntoFuture};
 use futures::Stream;
-use http::header::{self, HeaderName, HeaderValue};
-use http::{Error as HttpError, HeaderMap, HttpTryFrom, StatusCode};
 use serde::Serialize;
 use serde_json;

 use crate::body::{Body, BodyStream, MessageBody, ResponseBody};
+use crate::cookie::{Cookie, CookieJar};
 use crate::error::Error;
 use crate::extensions::Extensions;
 use crate::header::{Header, IntoHeaderValue};
-use crate::message::{ConnectionType, Message, ResponseHead};
+use crate::http::header::{self, HeaderName, HeaderValue};
+use crate::http::{Error as HttpError, HeaderMap, HttpTryFrom, StatusCode};
+use crate::message::{BoxedResponseHead, ConnectionType, ResponseHead};

 /// An HTTP Response
 pub struct Response<B = Body> {
-    head: Message<ResponseHead>,
+    head: BoxedResponseHead,
    body: ResponseBody<B>,
    error: Option<Error>,
 }
@ -42,11 +41,8 @@ impl Response<Body> {
    /// Constructs a response
    #[inline]
    pub fn new(status: StatusCode) -> Response {
-        let mut head: Message<ResponseHead> = Message::new();
-        head.status = status;
-
        Response {
-            head,
+            head: BoxedResponseHead::new(status),
            body: ResponseBody::Body(Body::Empty),
            error: None,
        }
@ -55,7 +51,7 @@ impl Response<Body> {
    /// Constructs an error response
    #[inline]
    pub fn from_error(error: Error) -> Response {
-        let mut resp = error.as_response_error().error_response();
+        let mut resp = error.as_response_error().render_response();
        resp.error = Some(error);
        resp
    }
@ -75,6 +71,16 @@ impl Response<Body> {
 }

 impl<B> Response<B> {
+    /// Constructs a response with body
+    #[inline]
+    pub fn with_body(status: StatusCode, body: B) -> Response<B> {
+        Response {
+            head: BoxedResponseHead::new(status),
+            body: ResponseBody::Body(body),
+            error: None,
+        }
+    }
+
    #[inline]
    /// Http message part of the response
    pub fn head(&self) -> &ResponseHead {
@ -87,18 +93,6 @@ impl<B> Response<B> {
        &mut *self.head
    }

-    /// Constructs a response with body
-    #[inline]
-    pub fn with_body(status: StatusCode, body: B) -> Response<B> {
-        let mut head: Message<ResponseHead> = Message::new();
-        head.status = status;
-        Response {
-            head,
-            body: ResponseBody::Body(body),
-            error: None,
-        }
-    }
-
    /// The source `error` for this response
    #[inline]
    pub fn error(&self) -> Option<&Error> {
@ -131,16 +125,14 @@ impl<B> Response<B> {

    /// Get an iterator for the cookies set by this response
    #[inline]
-    #[cfg(feature = "cookies")]
    pub fn cookies(&self) -> CookieIter {
        CookieIter {
-            iter: self.head.headers.get_all(header::SET_COOKIE).iter(),
+            iter: self.head.headers.get_all(header::SET_COOKIE),
        }
    }

    /// Add a cookie to this response
    #[inline]
-    #[cfg(feature = "cookies")]
    pub fn add_cookie(&mut self, cookie: &Cookie) -> Result<(), HttpError> {
        let h = &mut self.head.headers;
        HeaderValue::from_str(&cookie.to_string())
@ -153,12 +145,10 @@ impl<B> Response<B> {
    /// Remove all cookies with the given name from this response. Returns
    /// the number of cookies removed.
    #[inline]
-    #[cfg(feature = "cookies")]
    pub fn del_cookie(&mut self, name: &str) -> usize {
        let h = &mut self.head.headers;
        let vals: Vec<HeaderValue> = h
            .get_all(header::SET_COOKIE)
-            .iter()
            .map(|v| v.to_owned())
            .collect();
        h.remove(header::SET_COOKIE);
@ -189,6 +179,18 @@ impl<B> Response<B> {
        self.head.keep_alive()
    }

+    /// Responses extensions
+    #[inline]
+    pub fn extensions(&self) -> Ref<Extensions> {
+        self.head.extensions.borrow()
+    }
+
+    /// Mutable reference to a the response's extensions
+    #[inline]
+    pub fn extensions_mut(&mut self) -> RefMut<Extensions> {
+        self.head.extensions.borrow_mut()
+    }
+
    /// Get body os this response
    #[inline]
    pub fn body(&self) -> &ResponseBody<B> {
@ -196,7 +198,7 @@ impl<B> Response<B> {
    }

    /// Set a body
-    pub(crate) fn set_body<B2>(self, body: B2) -> Response<B2> {
+    pub fn set_body<B2>(self, body: B2) -> Response<B2> {
        Response {
            head: self.head,
            body: ResponseBody::Body(body),
@ -204,8 +206,20 @@ impl<B> Response<B> {
        }
    }

+    /// Split response and body
+    pub fn into_parts(self) -> (Response<()>, ResponseBody<B>) {
+        (
+            Response {
+                head: self.head,
+                body: ResponseBody::Body(()),
+                error: self.error,
+            },
+            self.body,
+        )
+    }
+
    /// Drop request's body
-    pub(crate) fn drop_body(self) -> Response<()> {
+    pub fn drop_body(self) -> Response<()> {
        Response {
            head: self.head,
            body: ResponseBody::Body(()),
@ -233,8 +247,8 @@ impl<B> Response<B> {
        let body = f(&mut self.head, self.body);

        Response {
+            body,
            head: self.head,
-            body: body,
            error: self.error,
        }
    }
@ -258,7 +272,7 @@ impl<B: MessageBody> fmt::Debug for Response<B> {
        for (key, val) in self.head.headers.iter() {
            let _ = writeln!(f, "    {:?}: {:?}", key, val);
        }
-        let _ = writeln!(f, "  body: {:?}", self.body.length());
+        let _ = writeln!(f, "  body: {:?}", self.body.size());
        res
    }
 }
@ -273,12 +287,10 @@ impl IntoFuture for Response {
    }
 }

-#[cfg(feature = "cookies")]
 pub struct CookieIter<'a> {
-    iter: header::ValueIter<'a, HeaderValue>,
+    iter: header::GetAll<'a>,
 }

-#[cfg(feature = "cookies")]
 impl<'a> Iterator for CookieIter<'a> {
    type Item = Cookie<'a>;

@ -298,22 +310,18 @@ impl<'a> Iterator for CookieIter<'a> {
 /// This type can be used to construct an instance of `Response` through a
 /// builder-like pattern.
 pub struct ResponseBuilder {
-    head: Option<Message<ResponseHead>>,
+    head: Option<BoxedResponseHead>,
    err: Option<HttpError>,
-    #[cfg(feature = "cookies")]
    cookies: Option<CookieJar>,
 }

 impl ResponseBuilder {
+    #[inline]
    /// Create response builder
    pub fn new(status: StatusCode) -> Self {
-        let mut head: Message<ResponseHead> = Message::new();
-        head.status = status;
-
        ResponseBuilder {
-            head: Some(head),
+            head: Some(BoxedResponseHead::new(status)),
            err: None,
-            #[cfg(feature = "cookies")]
            cookies: None,
        }
    }
@ -329,11 +337,10 @@ impl ResponseBuilder {

    /// Set a header.
    ///
-    /// ```rust,ignore
-    /// # extern crate actix_web;
-    /// use actix_web::{http, Request, Response, Result};
+    /// ```rust
+    /// use actix_http::{http, Request, Response, Result};
    ///
-    /// fn index(req: HttpRequest) -> Result<Response> {
+    /// fn index(req: Request) -> Result<Response> {
    ///     Ok(Response::Ok()
    ///         .set(http::header::IfModifiedSince(
    ///             "Sun, 07 Nov 1994 08:48:37 GMT".parse()?,
@ -357,11 +364,10 @@ impl ResponseBuilder {

    /// Append a header to existing headers.
    ///
-    /// ```rust,ignore
-    /// # extern crate actix_web;
-    /// use actix_web::{http, Request, Response};
+    /// ```rust
+    /// use actix_http::{http, Request, Response};
    ///
-    /// fn index(req: HttpRequest) -> Response {
+    /// fn index(req: Request) -> Response {
    ///     Response::Ok()
    ///         .header("X-TEST", "value")
    ///         .header(http::header::CONTENT_TYPE, "application/json")
@ -390,11 +396,10 @@ impl ResponseBuilder {

    /// Set a header.
    ///
-    /// ```rust,ignore
-    /// # extern crate actix_web;
-    /// use actix_web::{http, Request, Response};
+    /// ```rust
+    /// use actix_http::{http, Request, Response};
    ///
-    /// fn index(req: HttpRequest) -> Response {
+    /// fn index(req: Request) -> Response {
    ///     Response::Ok()
    ///         .set_header("X-TEST", "value")
    ///         .set_header(http::header::CONTENT_TYPE, "application/json")
@ -496,11 +501,10 @@ impl ResponseBuilder {

    /// Set a cookie
    ///
-    /// ```rust,ignore
-    /// # extern crate actix_web;
-    /// use actix_web::{http, HttpRequest, Response, Result};
+    /// ```rust
+    /// use actix_http::{http, Request, Response};
    ///
-    /// fn index(req: HttpRequest) -> Response {
+    /// fn index(req: Request) -> Response {
    ///     Response::Ok()
    ///         .cookie(
    ///             http::Cookie::build("name", "value")
@ -513,7 +517,6 @@ impl ResponseBuilder {
    ///         .finish()
    /// }
    /// ```
-    #[cfg(feature = "cookies")]
    pub fn cookie<'c>(&mut self, cookie: Cookie<'c>) -> &mut Self {
        if self.cookies.is_none() {
            let mut jar = CookieJar::new();
@ -527,11 +530,10 @@ impl ResponseBuilder {

    /// Remove cookie
    ///
-    /// ```rust,ignore
-    /// # extern crate actix_web;
-    /// use actix_web::{http, HttpRequest, Response, Result};
+    /// ```rust
+    /// use actix_http::{http, Request, Response, HttpMessage};
    ///
-    /// fn index(req: &HttpRequest) -> Response {
+    /// fn index(req: Request) -> Response {
    ///     let mut builder = Response::Ok();
    ///
    ///     if let Some(ref cookie) = req.cookie("name") {
@ -541,17 +543,14 @@ impl ResponseBuilder {
    ///     builder.finish()
    /// }
    /// ```
-    #[cfg(feature = "cookies")]
    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);
+        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
    }

@ -593,6 +592,7 @@ impl ResponseBuilder {
        head.extensions.borrow_mut()
    }

+    #[inline]
    /// Set a body and generate `Response`.
    ///
    /// `ResponseBuilder` can not be used after this call.
@ -608,20 +608,14 @@ impl ResponseBuilder {
            return Response::from(Error::from(e)).into_body();
        }

-        #[allow(unused_mut)]
        let mut response = self.head.take().expect("cannot reuse response builder");

-        #[cfg(feature = "cookies")]
-        {
-            if let Some(ref jar) = self.cookies {
-                for cookie in jar.delta() {
-                    match HeaderValue::from_str(&cookie.to_string()) {
-                        Ok(val) => {
-                            let _ = response.headers.append(header::SET_COOKIE, val);
-                        }
-                        Err(e) => return Response::from(Error::from(e)).into_body(),
-                    };
-                }
+        if let Some(ref jar) = self.cookies {
+            for cookie in jar.delta() {
+                match HeaderValue::from_str(&cookie.to_string()) {
+                    Ok(val) => response.headers.append(header::SET_COOKIE, val),
+                    Err(e) => return Response::from(Error::from(e)).into_body(),
+                };
            }
        }

@ -644,6 +638,7 @@ impl ResponseBuilder {
        self.body(Body::from_message(BodyStream::new(stream)))
    }

+    #[inline]
    /// Set a json body and generate `Response`
    ///
    /// `ResponseBuilder` can not be used after this call.
@ -685,7 +680,6 @@ impl ResponseBuilder {
        ResponseBuilder {
            head: self.head.take(),
            err: self.err.take(),
-            #[cfg(feature = "cookies")]
            cookies: self.cookies.take(),
        }
    }
@ -693,22 +687,20 @@ impl ResponseBuilder {

 #[inline]
 fn parts<'a>(
-    parts: &'a mut Option<Message<ResponseHead>>,
+    parts: &'a mut Option<BoxedResponseHead>,
    err: &Option<HttpError>,
-) -> Option<&'a mut Message<ResponseHead>> {
+) -> Option<&'a mut ResponseHead> {
    if err.is_some() {
        return None;
    }
-    parts.as_mut()
+    parts.as_mut().map(|r| &mut **r)
 }

 /// Convert `Response` to a `ResponseBuilder`. Body get dropped.
 impl<B> From<Response<B>> for ResponseBuilder {
    fn from(res: Response<B>) -> ResponseBuilder {
        // If this response has cookies, load them into a jar
-        #[cfg(feature = "cookies")]
        let mut jar: Option<CookieJar> = None;
-        #[cfg(feature = "cookies")]
        for c in res.cookies() {
            if let Some(ref mut j) = jar {
                j.add_original(c.into_owned());
@ -722,7 +714,6 @@ impl<B> From<Response<B>> for ResponseBuilder {
        ResponseBuilder {
            head: Some(res.head),
            err: None,
-            #[cfg(feature = "cookies")]
            cookies: jar,
        }
    }
@ -732,36 +723,32 @@ impl<B> From<Response<B>> for ResponseBuilder {
 impl<'a> From<&'a ResponseHead> for ResponseBuilder {
    fn from(head: &'a ResponseHead) -> ResponseBuilder {
        // If this response has cookies, load them into a jar
-        #[cfg(feature = "cookies")]
        let mut jar: Option<CookieJar> = None;

-        #[cfg(feature = "cookies")]
-        {
-            let cookies = CookieIter {
-                iter: head.headers.get_all(header::SET_COOKIE).iter(),
-            };
-            for c in cookies {
-                if let Some(ref mut j) = jar {
-                    j.add_original(c.into_owned());
-                } else {
-                    let mut j = CookieJar::new();
-                    j.add_original(c.into_owned());
-                    jar = Some(j);
-                }
+        let cookies = CookieIter {
+            iter: head.headers.get_all(header::SET_COOKIE),
+        };
+        for c in cookies {
+            if let Some(ref mut j) = jar {
+                j.add_original(c.into_owned());
+            } else {
+                let mut j = CookieJar::new();
+                j.add_original(c.into_owned());
+                jar = Some(j);
            }
        }

-        let mut msg: Message<ResponseHead> = Message::new();
+        let mut msg = BoxedResponseHead::new(head.status);
        msg.version = head.version;
-        msg.status = head.status;
        msg.reason = head.reason;
-        msg.headers = head.headers.clone();
+        for (k, v) in &head.headers {
+            msg.headers.append(k.clone(), v.clone());
+        }
        msg.no_chunking(!head.chunked());

        ResponseBuilder {
            head: Some(msg),
            err: None,
-            #[cfg(feature = "cookies")]
            cookies: jar,
        }
    }
@ -777,6 +764,25 @@ impl IntoFuture for ResponseBuilder {
    }
 }

+impl fmt::Debug for ResponseBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let head = self.head.as_ref().unwrap();
+
+        let res = writeln!(
+            f,
+            "\nResponseBuilder {:?} {}{}",
+            head.version,
+            head.status,
+            head.reason.unwrap_or(""),
+        );
+        let _ = writeln!(f, "  headers:");
+        for (key, val) in head.headers.iter() {
+            let _ = writeln!(f, "    {:?}: {:?}", key, val);
+        }
+        res
+    }
+}
+
 /// Helper converters
 impl<I: Into<Response>, E: Into<Error>> From<Result<I, E>> for Response {
    fn from(res: Result<I, E>) -> Self {
@ -845,7 +851,7 @@ impl From<BytesMut> for Response {
 mod tests {
    use super::*;
    use crate::body::Body;
-    use crate::http::header::{HeaderValue, CONTENT_TYPE, COOKIE};
+    use crate::http::header::{HeaderValue, CONTENT_TYPE, COOKIE, SET_COOKIE};

    #[test]
    fn test_debug() {
@ -858,7 +864,6 @@ mod tests {
    }

    #[test]
-    #[cfg(feature = "cookies")]
    fn test_response_cookies() {
        use crate::httpmessage::HttpMessage;

@ -874,16 +879,15 @@ mod tests {
                    .domain("www.rust-lang.org")
                    .path("/test")
                    .http_only(true)
-                    .max_age(time::Duration::days(1))
+                    .max_age_time(time::Duration::days(1))
                    .finish(),
            )
-            .del_cookie(&cookies[0])
+            .del_cookie(&cookies[1])
            .finish();

        let mut val: Vec<_> = resp
            .headers()
-            .get_all("Set-Cookie")
-            .iter()
+            .get_all(SET_COOKIE)
            .map(|v| v.to_str().unwrap().to_owned())
            .collect();
        val.sort();
@ -895,7 +899,6 @@ mod tests {
    }

    #[test]
-    #[cfg(feature = "cookies")]
    fn test_update_response_cookies() {
        let mut r = Response::Ok()
            .cookie(crate::http::Cookie::new("original", "val100"))
@ -913,9 +916,9 @@ mod tests {

        let mut iter = r.cookies();
        let v = iter.next().unwrap();
-        assert_eq!((v.name(), v.value()), ("original", "val100"));
-        let v = iter.next().unwrap();
        assert_eq!((v.name(), v.value()), ("cookie3", "val300"));
+        let v = iter.next().unwrap();
+        assert_eq!((v.name(), v.value()), ("original", "val100"));
    }

    #[test]
@ -1051,12 +1054,12 @@ mod tests {
            resp.headers().get(CONTENT_TYPE).unwrap(),
            HeaderValue::from_static("application/octet-stream")
        );
+
        assert_eq!(resp.status(), StatusCode::OK);
        assert_eq!(resp.body().get_ref(), b"test");
    }

    #[test]
-    #[cfg(feature = "cookies")]
    fn test_into_builder() {
        let mut resp: Response = "test".into();
        assert_eq!(resp.status(), StatusCode::OK);
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@ -0,0 +1,603 @@
+use std::marker::PhantomData;
+use std::{fmt, io, net, rc};
+
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use actix_server_config::{
+    Io as ServerIo, IoStream, Protocol, ServerConfig as SrvConfig,
+};
+use actix_service::{IntoNewService, NewService, Service};
+use actix_utils::cloneable::CloneableService;
+use bytes::{Buf, BufMut, Bytes, BytesMut};
+use futures::{try_ready, Async, Future, IntoFuture, Poll};
+use h2::server::{self, Handshake};
+
+use crate::body::MessageBody;
+use crate::builder::HttpServiceBuilder;
+use crate::config::{KeepAlive, ServiceConfig};
+use crate::error::{DispatchError, Error};
+use crate::helpers::DataFactory;
+use crate::request::Request;
+use crate::response::Response;
+use crate::{h1, h2::Dispatcher};
+
+/// `NewService` HTTP1.1/HTTP2 transport implementation
+pub struct HttpService<T, P, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<T>> {
+    srv: S,
+    cfg: ServiceConfig,
+    expect: X,
+    upgrade: Option<U>,
+    on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    _t: PhantomData<(T, P, B)>,
+}
+
+impl<T, S, B> HttpService<T, (), S, B>
+where
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    S::Response: Into<Response<B>>,
+    <S::Service as Service>::Future: 'static,
+    B: MessageBody + 'static,
+{
+    /// Create builder for `HttpService` instance.
+    pub fn build() -> HttpServiceBuilder<T, S> {
+        HttpServiceBuilder::new()
+    }
+}
+
+impl<T, P, S, B> HttpService<T, P, S, B>
+where
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    S::Response: Into<Response<B>>,
+    <S::Service as Service>::Future: 'static,
+    B: MessageBody + 'static,
+{
+    /// Create new `HttpService` instance.
+    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
+        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);
+
+        HttpService {
+            cfg,
+            srv: service.into_new_service(),
+            expect: h1::ExpectHandler,
+            upgrade: None,
+            on_connect: None,
+            _t: PhantomData,
+        }
+    }
+
+    /// Create new `HttpService` instance with config.
+    pub(crate) fn with_config<F: IntoNewService<S>>(
+        cfg: ServiceConfig,
+        service: F,
+    ) -> Self {
+        HttpService {
+            cfg,
+            srv: service.into_new_service(),
+            expect: h1::ExpectHandler,
+            upgrade: None,
+            on_connect: None,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, P, S, B, X, U> HttpService<T, P, S, B, X, U>
+where
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
+    /// Provide service for `EXPECT: 100-Continue` support.
+    ///
+    /// Service get called with request that contains `EXPECT` header.
+    /// Service must return request in case of success, in that case
+    /// request will be forwarded to main service.
+    pub fn expect<X1>(self, expect: X1) -> HttpService<T, P, S, B, X1, U>
+    where
+        X1: NewService<Config = SrvConfig, Request = Request, Response = Request>,
+        X1::Error: Into<Error>,
+        X1::InitError: fmt::Debug,
+    {
+        HttpService {
+            expect,
+            cfg: self.cfg,
+            srv: self.srv,
+            upgrade: self.upgrade,
+            on_connect: self.on_connect,
+            _t: PhantomData,
+        }
+    }
+
+    /// Provide service for custom `Connection: UPGRADE` support.
+    ///
+    /// If service is provided then normal requests handling get halted
+    /// and this service get called with original request and framed object.
+    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, P, S, B, X, U1>
+    where
+        U1: NewService<
+            Config = SrvConfig,
+            Request = (Request, Framed<T, h1::Codec>),
+            Response = (),
+        >,
+        U1::Error: fmt::Display,
+        U1::InitError: fmt::Debug,
+    {
+        HttpService {
+            upgrade,
+            cfg: self.cfg,
+            srv: self.srv,
+            expect: self.expect,
+            on_connect: self.on_connect,
+            _t: PhantomData,
+        }
+    }
+
+    /// Set on connect callback.
+    pub(crate) fn on_connect(
+        mut self,
+        f: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> Self {
+        self.on_connect = f;
+        self
+    }
+}
+
+impl<T, P, S, B, X, U> NewService for HttpService<T, P, S, B, X, U>
+where
+    T: IoStream,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    S::Response: Into<Response<B>>,
+    <S::Service as Service>::Future: 'static,
+    B: MessageBody + 'static,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, h1::Codec>),
+        Response = (),
+    >,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
+{
+    type Config = SrvConfig;
+    type Request = ServerIo<T, P>;
+    type Response = ();
+    type Error = DispatchError;
+    type InitError = ();
+    type Service = HttpServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
+    type Future = HttpServiceResponse<T, P, S, B, X, U>;
+
+    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
+        HttpServiceResponse {
+            fut: self.srv.new_service(cfg).into_future(),
+            fut_ex: Some(self.expect.new_service(cfg)),
+            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
+            expect: None,
+            upgrade: None,
+            on_connect: self.on_connect.clone(),
+            cfg: Some(self.cfg.clone()),
+            _t: PhantomData,
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct HttpServiceResponse<T, P, S: NewService, B, X: NewService, U: NewService> {
+    fut: S::Future,
+    fut_ex: Option<X::Future>,
+    fut_upg: Option<U::Future>,
+    expect: Option<X::Service>,
+    upgrade: Option<U::Service>,
+    on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    cfg: Option<ServiceConfig>,
+    _t: PhantomData<(T, P, B)>,
+}
+
+impl<T, P, S, B, X, U> Future for HttpServiceResponse<T, P, S, B, X, U>
+where
+    T: IoStream,
+    S: NewService<Request = Request>,
+    S::Error: Into<Error>,
+    S::InitError: fmt::Debug,
+    S::Response: Into<Response<B>>,
+    <S::Service as Service>::Future: 'static,
+    B: MessageBody + 'static,
+    X: NewService<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    X::InitError: fmt::Debug,
+    U: NewService<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U::Error: fmt::Display,
+    U::InitError: fmt::Debug,
+{
+    type Item = HttpServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut_ex {
+            let expect = try_ready!(fut
+                .poll()
+                .map_err(|e| log::error!("Init http service error: {:?}", e)));
+            self.expect = Some(expect);
+            self.fut_ex.take();
+        }
+
+        if let Some(ref mut fut) = self.fut_upg {
+            let upgrade = try_ready!(fut
+                .poll()
+                .map_err(|e| log::error!("Init http service error: {:?}", e)));
+            self.upgrade = Some(upgrade);
+            self.fut_ex.take();
+        }
+
+        let service = try_ready!(self
+            .fut
+            .poll()
+            .map_err(|e| log::error!("Init http service error: {:?}", e)));
+        Ok(Async::Ready(HttpServiceHandler::new(
+            self.cfg.take().unwrap(),
+            service,
+            self.expect.take().unwrap(),
+            self.upgrade.take(),
+            self.on_connect.clone(),
+        )))
+    }
+}
+
+/// `Service` implementation for http transport
+pub struct HttpServiceHandler<T, P, S, B, X, U> {
+    srv: CloneableService<S>,
+    expect: CloneableService<X>,
+    upgrade: Option<CloneableService<U>>,
+    cfg: ServiceConfig,
+    on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    _t: PhantomData<(T, P, B, X)>,
+}
+
+impl<T, P, S, B, X, U> HttpServiceHandler<T, P, S, B, X, U>
+where
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
+    S::Response: Into<Response<B>>,
+    B: MessageBody + 'static,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U::Error: fmt::Display,
+{
+    fn new(
+        cfg: ServiceConfig,
+        srv: S,
+        expect: X,
+        upgrade: Option<U>,
+        on_connect: Option<rc::Rc<Fn(&T) -> Box<dyn DataFactory>>>,
+    ) -> HttpServiceHandler<T, P, S, B, X, U> {
+        HttpServiceHandler {
+            cfg,
+            on_connect,
+            srv: CloneableService::new(srv),
+            expect: CloneableService::new(expect),
+            upgrade: upgrade.map(|s| CloneableService::new(s)),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, P, S, B, X, U> Service for HttpServiceHandler<T, P, S, B, X, U>
+where
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
+    S::Response: Into<Response<B>>,
+    B: MessageBody + 'static,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U::Error: fmt::Display,
+{
+    type Request = ServerIo<T, P>;
+    type Response = ();
+    type Error = DispatchError;
+    type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        let ready = self
+            .expect
+            .poll_ready()
+            .map_err(|e| {
+                let e = e.into();
+                log::error!("Http service readiness error: {:?}", e);
+                DispatchError::Service(e)
+            })?
+            .is_ready();
+
+        let ready = self
+            .srv
+            .poll_ready()
+            .map_err(|e| {
+                let e = e.into();
+                log::error!("Http service readiness error: {:?}", e);
+                DispatchError::Service(e)
+            })?
+            .is_ready()
+            && ready;
+
+        if ready {
+            Ok(Async::Ready(()))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let (io, _, proto) = req.into_parts();
+
+        let on_connect = if let Some(ref on_connect) = self.on_connect {
+            Some(on_connect(&io))
+        } else {
+            None
+        };
+
+        match proto {
+            Protocol::Http2 => {
+                let peer_addr = io.peer_addr();
+                let io = Io {
+                    inner: io,
+                    unread: None,
+                };
+                HttpServiceHandlerResponse {
+                    state: State::Handshake(Some((
+                        server::handshake(io),
+                        self.cfg.clone(),
+                        self.srv.clone(),
+                        peer_addr,
+                        on_connect,
+                    ))),
+                }
+            }
+            Protocol::Http10 | Protocol::Http11 => HttpServiceHandlerResponse {
+                state: State::H1(h1::Dispatcher::new(
+                    io,
+                    self.cfg.clone(),
+                    self.srv.clone(),
+                    self.expect.clone(),
+                    self.upgrade.clone(),
+                    on_connect,
+                )),
+            },
+            _ => HttpServiceHandlerResponse {
+                state: State::Unknown(Some((
+                    io,
+                    BytesMut::with_capacity(14),
+                    self.cfg.clone(),
+                    self.srv.clone(),
+                    self.expect.clone(),
+                    self.upgrade.clone(),
+                    on_connect,
+                ))),
+            },
+        }
+    }
+}
+
+enum State<T, S, B, X, U>
+where
+    S: Service<Request = Request>,
+    S::Future: 'static,
+    S::Error: Into<Error>,
+    T: IoStream,
+    B: MessageBody,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U::Error: fmt::Display,
+{
+    H1(h1::Dispatcher<T, S, B, X, U>),
+    H2(Dispatcher<Io<T>, S, B>),
+    Unknown(
+        Option<(
+            T,
+            BytesMut,
+            ServiceConfig,
+            CloneableService<S>,
+            CloneableService<X>,
+            Option<CloneableService<U>>,
+            Option<Box<dyn DataFactory>>,
+        )>,
+    ),
+    Handshake(
+        Option<(
+            Handshake<Io<T>, Bytes>,
+            ServiceConfig,
+            CloneableService<S>,
+            Option<net::SocketAddr>,
+            Option<Box<dyn DataFactory>>,
+        )>,
+    ),
+}
+
+pub struct HttpServiceHandlerResponse<T, S, B, X, U>
+where
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
+    S::Response: Into<Response<B>>,
+    B: MessageBody + 'static,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U::Error: fmt::Display,
+{
+    state: State<T, S, B, X, U>,
+}
+
+const HTTP2_PREFACE: [u8; 14] = *b"PRI * HTTP/2.0";
+
+impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
+where
+    T: IoStream,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Future: 'static,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U::Error: fmt::Display,
+{
+    type Item = ();
+    type Error = DispatchError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.state {
+            State::H1(ref mut disp) => disp.poll(),
+            State::H2(ref mut disp) => disp.poll(),
+            State::Unknown(ref mut data) => {
+                if let Some(ref mut item) = data {
+                    loop {
+                        unsafe {
+                            let b = item.1.bytes_mut();
+                            let n = try_ready!(item.0.poll_read(b));
+                            if n == 0 {
+                                return Ok(Async::Ready(()));
+                            }
+                            item.1.advance_mut(n);
+                            if item.1.len() >= HTTP2_PREFACE.len() {
+                                break;
+                            }
+                        }
+                    }
+                } else {
+                    panic!()
+                }
+                let (io, buf, cfg, srv, expect, upgrade, on_connect) =
+                    data.take().unwrap();
+                if buf[..14] == HTTP2_PREFACE[..] {
+                    let peer_addr = io.peer_addr();
+                    let io = Io {
+                        inner: io,
+                        unread: Some(buf),
+                    };
+                    self.state = State::Handshake(Some((
+                        server::handshake(io),
+                        cfg,
+                        srv,
+                        peer_addr,
+                        on_connect,
+                    )));
+                } else {
+                    self.state = State::H1(h1::Dispatcher::with_timeout(
+                        io,
+                        h1::Codec::new(cfg.clone()),
+                        cfg,
+                        buf,
+                        None,
+                        srv,
+                        expect,
+                        upgrade,
+                        on_connect,
+                    ))
+                }
+                self.poll()
+            }
+            State::Handshake(ref mut data) => {
+                let conn = if let Some(ref mut item) = data {
+                    match item.0.poll() {
+                        Ok(Async::Ready(conn)) => conn,
+                        Ok(Async::NotReady) => return Ok(Async::NotReady),
+                        Err(err) => {
+                            trace!("H2 handshake error: {}", err);
+                            return Err(err.into());
+                        }
+                    }
+                } else {
+                    panic!()
+                };
+                let (_, cfg, srv, peer_addr, on_connect) = data.take().unwrap();
+                self.state = State::H2(Dispatcher::new(
+                    srv, conn, on_connect, cfg, None, peer_addr,
+                ));
+                self.poll()
+            }
+        }
+    }
+}
+
+/// Wrapper for `AsyncRead + AsyncWrite` types
+struct Io<T> {
+    unread: Option<BytesMut>,
+    inner: T,
+}
+
+impl<T: io::Read> io::Read for Io<T> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        if let Some(mut bytes) = self.unread.take() {
+            let size = std::cmp::min(buf.len(), bytes.len());
+            buf[..size].copy_from_slice(&bytes[..size]);
+            if bytes.len() > size {
+                bytes.split_to(size);
+                self.unread = Some(bytes);
+            }
+            Ok(size)
+        } else {
+            self.inner.read(buf)
+        }
+    }
+}
+
+impl<T: io::Write> io::Write for Io<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.write(buf)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+impl<T: AsyncRead> AsyncRead for Io<T> {
+    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
+        self.inner.prepare_uninitialized_buffer(buf)
+    }
+}
+
+impl<T: AsyncWrite> AsyncWrite for Io<T> {
+    fn shutdown(&mut self) -> Poll<(), io::Error> {
+        self.inner.shutdown()
+    }
+    fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
+        self.inner.write_buf(buf)
+    }
+}
+
+impl<T: IoStream> IoStream for Io<T> {
+    #[inline]
+    fn peer_addr(&self) -> Option<net::SocketAddr> {
+        self.inner.peer_addr()
+    }
+
+    #[inline]
+    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
+        self.inner.set_nodelay(nodelay)
+    }
+
+    #[inline]
+    fn set_linger(&mut self, dur: Option<std::time::Duration>) -> io::Result<()> {
+        self.inner.set_linger(dur)
+    }
+
+    #[inline]
+    fn set_keepalive(&mut self, dur: Option<std::time::Duration>) -> io::Result<()> {
+        self.inner.set_keepalive(dur)
+    }
+}
--- a/actix-http/src/service/mod.rs
+++ b/actix-http/src/service/mod.rs
@ -1,5 +0,0 @@
-mod senderror;
-mod service;
-
-pub use self::senderror::{SendError, SendResponse};
-pub use self::service::HttpService;
--- a/actix-http/src/service/senderror.rs
+++ b/actix-http/src/service/senderror.rs
@ -1,241 +0,0 @@
-use std::marker::PhantomData;
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_service::{NewService, Service};
-use futures::future::{ok, Either, FutureResult};
-use futures::{Async, Future, Poll, Sink};
-
-use crate::body::{BodySize, MessageBody, ResponseBody};
-use crate::error::{Error, ResponseError};
-use crate::h1::{Codec, Message};
-use crate::response::Response;
-
-pub struct SendError<T, R, E>(PhantomData<(T, R, E)>);
-
-impl<T, R, E> Default for SendError<T, R, E>
-where
-    T: AsyncRead + AsyncWrite,
-    E: ResponseError,
-{
-    fn default() -> Self {
-        SendError(PhantomData)
-    }
-}
-
-impl<T, R, E> NewService for SendError<T, R, E>
-where
-    T: AsyncRead + AsyncWrite,
-    E: ResponseError,
-{
-    type Request = Result<R, (E, Framed<T, Codec>)>;
-    type Response = R;
-    type Error = (E, Framed<T, Codec>);
-    type InitError = ();
-    type Service = SendError<T, R, E>;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(SendError(PhantomData))
-    }
-}
-
-impl<T, R, E> Service for SendError<T, R, E>
-where
-    T: AsyncRead + AsyncWrite,
-    E: ResponseError,
-{
-    type Request = Result<R, (E, Framed<T, Codec>)>;
-    type Response = R;
-    type Error = (E, Framed<T, Codec>);
-    type Future = Either<FutureResult<R, (E, Framed<T, Codec>)>, SendErrorFut<T, R, E>>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Result<R, (E, Framed<T, Codec>)>) -> Self::Future {
-        match req {
-            Ok(r) => Either::A(ok(r)),
-            Err((e, framed)) => {
-                let res = e.error_response().set_body(format!("{}", e));
-                let (res, _body) = res.replace_body(());
-                Either::B(SendErrorFut {
-                    framed: Some(framed),
-                    res: Some((res, BodySize::Empty).into()),
-                    err: Some(e),
-                    _t: PhantomData,
-                })
-            }
-        }
-    }
-}
-
-pub struct SendErrorFut<T, R, E> {
-    res: Option<Message<(Response<()>, BodySize)>>,
-    framed: Option<Framed<T, Codec>>,
-    err: Option<E>,
-    _t: PhantomData<R>,
-}
-
-impl<T, R, E> Future for SendErrorFut<T, R, E>
-where
-    E: ResponseError,
-    T: AsyncRead + AsyncWrite,
-{
-    type Item = R;
-    type Error = (E, Framed<T, Codec>);
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(res) = self.res.take() {
-            if self.framed.as_mut().unwrap().force_send(res).is_err() {
-                return Err((self.err.take().unwrap(), self.framed.take().unwrap()));
-            }
-        }
-        match self.framed.as_mut().unwrap().poll_complete() {
-            Ok(Async::Ready(_)) => {
-                Err((self.err.take().unwrap(), self.framed.take().unwrap()))
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(_) => Err((self.err.take().unwrap(), self.framed.take().unwrap())),
-        }
-    }
-}
-
-pub struct SendResponse<T, B>(PhantomData<(T, B)>);
-
-impl<T, B> Default for SendResponse<T, B> {
-    fn default() -> Self {
-        SendResponse(PhantomData)
-    }
-}
-
-impl<T, B> SendResponse<T, B>
-where
-    T: AsyncRead + AsyncWrite,
-    B: MessageBody,
-{
-    pub fn send(
-        framed: Framed<T, Codec>,
-        res: Response<B>,
-    ) -> impl Future<Item = Framed<T, Codec>, Error = Error> {
-        // extract body from response
-        let (res, body) = res.replace_body(());
-
-        // write response
-        SendResponseFut {
-            res: Some(Message::Item((res, body.length()))),
-            body: Some(body),
-            framed: Some(framed),
-        }
-    }
-}
-
-impl<T, B> NewService for SendResponse<T, B>
-where
-    T: AsyncRead + AsyncWrite,
-    B: MessageBody,
-{
-    type Request = (Response<B>, Framed<T, Codec>);
-    type Response = Framed<T, Codec>;
-    type Error = Error;
-    type InitError = ();
-    type Service = SendResponse<T, B>;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(SendResponse(PhantomData))
-    }
-}
-
-impl<T, B> Service for SendResponse<T, B>
-where
-    T: AsyncRead + AsyncWrite,
-    B: MessageBody,
-{
-    type Request = (Response<B>, Framed<T, Codec>);
-    type Response = Framed<T, Codec>;
-    type Error = Error;
-    type Future = SendResponseFut<T, B>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, (res, framed): (Response<B>, Framed<T, Codec>)) -> Self::Future {
-        let (res, body) = res.replace_body(());
-        SendResponseFut {
-            res: Some(Message::Item((res, body.length()))),
-            body: Some(body),
-            framed: Some(framed),
-        }
-    }
-}
-
-pub struct SendResponseFut<T, B> {
-    res: Option<Message<(Response<()>, BodySize)>>,
-    body: Option<ResponseBody<B>>,
-    framed: Option<Framed<T, Codec>>,
-}
-
-impl<T, B> Future for SendResponseFut<T, B>
-where
-    T: AsyncRead + AsyncWrite,
-    B: MessageBody,
-{
-    type Item = Framed<T, Codec>;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            let mut body_ready = self.body.is_some();
-            let framed = self.framed.as_mut().unwrap();
-
-            // send body
-            if self.res.is_none() && self.body.is_some() {
-                while body_ready && self.body.is_some() && !framed.is_write_buf_full() {
-                    match self.body.as_mut().unwrap().poll_next()? {
-                        Async::Ready(item) => {
-                            // body is done
-                            if item.is_none() {
-                                let _ = self.body.take();
-                            }
-                            framed.force_send(Message::Chunk(item))?;
-                        }
-                        Async::NotReady => body_ready = false,
-                    }
-                }
-            }
-
-            // flush write buffer
-            if !framed.is_write_buf_empty() {
-                match framed.poll_complete()? {
-                    Async::Ready(_) => {
-                        if body_ready {
-                            continue;
-                        } else {
-                            return Ok(Async::NotReady);
-                        }
-                    }
-                    Async::NotReady => return Ok(Async::NotReady),
-                }
-            }
-
-            // send response
-            if let Some(res) = self.res.take() {
-                framed.force_send(res)?;
-                continue;
-            }
-
-            if self.body.is_some() {
-                if body_ready {
-                    continue;
-                } else {
-                    return Ok(Async::NotReady);
-                }
-            } else {
-                break;
-            }
-        }
-        Ok(Async::Ready(self.framed.take().unwrap()))
-    }
-}
--- a/actix-http/src/service/service.rs
+++ b/actix-http/src/service/service.rs
@ -1,344 +0,0 @@
-use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::{fmt, io};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed, FramedParts};
-use actix_server_config::{Io as ServerIo, Protocol, ServerConfig as SrvConfig};
-use actix_service::{IntoNewService, NewService, Service};
-use actix_utils::cloneable::CloneableService;
-use bytes::{Buf, BufMut, Bytes, BytesMut};
-use futures::{try_ready, Async, Future, IntoFuture, Poll};
-use h2::server::{self, Handshake};
-use log::error;
-
-use crate::body::MessageBody;
-use crate::builder::HttpServiceBuilder;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::DispatchError;
-use crate::request::Request;
-use crate::response::Response;
-use crate::{h1, h2::Dispatcher};
-
-/// `NewService` HTTP1.1/HTTP2 transport implementation
-pub struct HttpService<T, P, S, B> {
-    srv: S,
-    cfg: ServiceConfig,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, S, B> HttpService<T, (), S, B>
-where
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
-    S::Error: Debug + 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    /// Create builder for `HttpService` instance.
-    pub fn build() -> HttpServiceBuilder<T, S> {
-        HttpServiceBuilder::new()
-    }
-}
-
-impl<T, P, S, B> HttpService<T, P, S, B>
-where
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
-    S::Error: Debug + 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    /// Create new `HttpService` instance.
-    pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self {
-        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);
-
-        HttpService {
-            cfg,
-            srv: service.into_new_service(),
-            _t: PhantomData,
-        }
-    }
-
-    /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoNewService<S, SrvConfig>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        HttpService {
-            cfg,
-            srv: service.into_new_service(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P, S, B> NewService<SrvConfig> for HttpService<T, P, S, B>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
-    S::Error: Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    type Request = ServerIo<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type InitError = S::InitError;
-    type Service = HttpServiceHandler<T, P, S::Service, B>;
-    type Future = HttpServiceResponse<T, P, S, B>;
-
-    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
-        HttpServiceResponse {
-            fut: self.srv.new_service(cfg).into_future(),
-            cfg: Some(self.cfg.clone()),
-            _t: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct HttpServiceResponse<T, P, S: NewService<SrvConfig>, B> {
-    fut: <S::Future as IntoFuture>::Future,
-    cfg: Option<ServiceConfig>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B> Future for HttpServiceResponse<T, P, S, B>
-where
-    T: AsyncRead + AsyncWrite,
-    S: NewService<SrvConfig, Request = Request>,
-    S::Service: 'static,
-    S::Response: Into<Response<B>>,
-    S::Error: Debug,
-    B: MessageBody + 'static,
-{
-    type Item = HttpServiceHandler<T, P, S::Service, B>;
-    type Error = S::InitError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let service = try_ready!(self.fut.poll());
-        Ok(Async::Ready(HttpServiceHandler::new(
-            self.cfg.take().unwrap(),
-            service,
-        )))
-    }
-}
-
-/// `Service` implementation for http transport
-pub struct HttpServiceHandler<T, P, S: 'static, B> {
-    srv: CloneableService<S>,
-    cfg: ServiceConfig,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B> HttpServiceHandler<T, P, S, B>
-where
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    fn new(cfg: ServiceConfig, srv: S) -> HttpServiceHandler<T, P, S, B> {
-        HttpServiceHandler {
-            cfg,
-            srv: CloneableService::new(srv),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P, S, B> Service for HttpServiceHandler<T, P, S, B>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    type Request = ServerIo<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type Future = HttpServiceHandlerResponse<T, S, B>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.srv.poll_ready().map_err(|e| {
-            error!("Service readiness error: {:?}", e);
-            DispatchError::Service
-        })
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let (io, _, proto) = req.into_parts();
-        match proto {
-            Protocol::Http2 => {
-                let io = Io {
-                    inner: io,
-                    unread: None,
-                };
-                HttpServiceHandlerResponse {
-                    state: State::Handshake(Some((
-                        server::handshake(io),
-                        self.cfg.clone(),
-                        self.srv.clone(),
-                    ))),
-                }
-            }
-            Protocol::Http10 | Protocol::Http11 => HttpServiceHandlerResponse {
-                state: State::H1(h1::Dispatcher::new(
-                    io,
-                    self.cfg.clone(),
-                    self.srv.clone(),
-                )),
-            },
-            _ => HttpServiceHandlerResponse {
-                state: State::Unknown(Some((
-                    io,
-                    BytesMut::with_capacity(14),
-                    self.cfg.clone(),
-                    self.srv.clone(),
-                ))),
-            },
-        }
-    }
-}
-
-enum State<T, S: Service<Request = Request> + 'static, B: MessageBody>
-where
-    S::Error: fmt::Debug,
-    T: AsyncRead + AsyncWrite + 'static,
-{
-    H1(h1::Dispatcher<T, S, B>),
-    H2(Dispatcher<Io<T>, S, B>),
-    Unknown(Option<(T, BytesMut, ServiceConfig, CloneableService<S>)>),
-    Handshake(Option<(Handshake<Io<T>, Bytes>, ServiceConfig, CloneableService<S>)>),
-}
-
-pub struct HttpServiceHandlerResponse<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    state: State<T, S, B>,
-}
-
-const HTTP2_PREFACE: [u8; 14] = *b"PRI * HTTP/2.0";
-
-impl<T, S, B> Future for HttpServiceHandlerResponse<T, S, B>
-where
-    T: AsyncRead + AsyncWrite,
-    S: Service<Request = Request> + 'static,
-    S::Error: Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    type Item = ();
-    type Error = DispatchError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.state {
-            State::H1(ref mut disp) => disp.poll(),
-            State::H2(ref mut disp) => disp.poll(),
-            State::Unknown(ref mut data) => {
-                if let Some(ref mut item) = data {
-                    loop {
-                        unsafe {
-                            let b = item.1.bytes_mut();
-                            let n = { try_ready!(item.0.poll_read(b)) };
-                            item.1.advance_mut(n);
-                            if item.1.len() >= HTTP2_PREFACE.len() {
-                                break;
-                            }
-                        }
-                    }
-                } else {
-                    panic!()
-                }
-                let (io, buf, cfg, srv) = data.take().unwrap();
-                if buf[..14] == HTTP2_PREFACE[..] {
-                    let io = Io {
-                        inner: io,
-                        unread: Some(buf),
-                    };
-                    self.state =
-                        State::Handshake(Some((server::handshake(io), cfg, srv)));
-                } else {
-                    let framed = Framed::from_parts(FramedParts::with_read_buf(
-                        io,
-                        h1::Codec::new(cfg.clone()),
-                        buf,
-                    ));
-                    self.state =
-                        State::H1(h1::Dispatcher::with_timeout(framed, cfg, None, srv))
-                }
-                self.poll()
-            }
-            State::Handshake(ref mut data) => {
-                let conn = if let Some(ref mut item) = data {
-                    match item.0.poll() {
-                        Ok(Async::Ready(conn)) => conn,
-                        Ok(Async::NotReady) => return Ok(Async::NotReady),
-                        Err(err) => {
-                            trace!("H2 handshake error: {}", err);
-                            return Err(err.into());
-                        }
-                    }
-                } else {
-                    panic!()
-                };
-                let (_, cfg, srv) = data.take().unwrap();
-                self.state = State::H2(Dispatcher::new(srv, conn, cfg, None));
-                self.poll()
-            }
-        }
-    }
-}
-
-/// Wrapper for `AsyncRead + AsyncWrite` types
-struct Io<T> {
-    unread: Option<BytesMut>,
-    inner: T,
-}
-
-impl<T: io::Read> io::Read for Io<T> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        if let Some(mut bytes) = self.unread.take() {
-            let size = std::cmp::min(buf.len(), bytes.len());
-            buf[..size].copy_from_slice(&bytes[..size]);
-            if bytes.len() > size {
-                bytes.split_to(size);
-                self.unread = Some(bytes);
-            }
-            Ok(size)
-        } else {
-            self.inner.read(buf)
-        }
-    }
-}
-
-impl<T: io::Write> io::Write for Io<T> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.write(buf)
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        self.inner.flush()
-    }
-}
-
-impl<T: AsyncRead + 'static> AsyncRead for Io<T> {
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
-        self.inner.prepare_uninitialized_buffer(buf)
-    }
-}
-
-impl<T: AsyncWrite + 'static> AsyncWrite for Io<T> {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        self.inner.shutdown()
-    }
-    fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
-        self.inner.write_buf(buf)
-    }
-}
--- a/actix-http/src/test.rs
+++ b/actix-http/src/test.rs
@ -1,12 +1,18 @@
 //! Test Various helpers for Actix applications to use during testing.
+use std::fmt::Write as FmtWrite;
+use std::io;
 use std::str::FromStr;

-use bytes::Bytes;
-#[cfg(feature = "cookies")]
-use cookie::{Cookie, CookieJar};
-use http::header::HeaderName;
-use http::{HeaderMap, HttpTryFrom, Method, Uri, Version};
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_server_config::IoStream;
+use bytes::{Buf, Bytes, BytesMut};
+use futures::{Async, Poll};
+use http::header::{self, HeaderName, HeaderValue};
+use http::{HttpTryFrom, Method, Uri, Version};
+use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};

+use crate::cookie::{Cookie, CookieJar};
+use crate::header::HeaderMap;
 use crate::header::{Header, IntoHeaderValue};
 use crate::payload::Payload;
 use crate::Request;
@ -45,7 +51,6 @@ struct Inner {
    method: Method,
    uri: Uri,
    headers: HeaderMap,
-    #[cfg(feature = "cookies")]
    cookies: CookieJar,
    payload: Option<Payload>,
 }
@ -57,7 +62,6 @@ impl Default for TestRequest {
            uri: Uri::from_str("/").unwrap(),
            version: Version::HTTP_11,
            headers: HeaderMap::new(),
-            #[cfg(feature = "cookies")]
            cookies: CookieJar::new(),
            payload: None,
        }))
@ -127,7 +131,6 @@ impl TestRequest {
    }

    /// Set cookie for this request
-    #[cfg(feature = "cookies")]
    pub fn cookie<'a>(&mut self, cookie: Cookie<'a>) -> &mut Self {
        parts(&mut self.0).cookies.add(cookie.into_owned());
        self
@ -161,25 +164,17 @@ impl TestRequest {
        head.version = inner.version;
        head.headers = inner.headers;

-        #[cfg(feature = "cookies")]
-        {
-            use std::fmt::Write as FmtWrite;
-
-            use http::header::{self, HeaderValue};
-            use percent_encoding::{percent_encode, USERINFO_ENCODE_SET};
-
-            let mut cookie = String::new();
-            for c in inner.cookies.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);
-            }
-            if !cookie.is_empty() {
-                head.headers.insert(
-                    header::COOKIE,
-                    HeaderValue::from_str(&cookie.as_str()[2..]).unwrap(),
-                );
-            }
+        let mut cookie = String::new();
+        for c in inner.cookies.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);
+        }
+        if !cookie.is_empty() {
+            head.headers.insert(
+                header::COOKIE,
+                HeaderValue::from_str(&cookie.as_str()[2..]).unwrap(),
+            );
        }

        req
@ -187,6 +182,89 @@ impl TestRequest {
 }

 #[inline]
-fn parts<'a>(parts: &'a mut Option<Inner>) -> &'a mut Inner {
+fn parts(parts: &mut Option<Inner>) -> &mut Inner {
    parts.as_mut().expect("cannot reuse test request builder")
 }
+
+/// Async io buffer
+pub struct TestBuffer {
+    pub read_buf: BytesMut,
+    pub write_buf: BytesMut,
+    pub err: Option<io::Error>,
+}
+
+impl TestBuffer {
+    /// Create new TestBuffer instance
+    pub fn new<T>(data: T) -> TestBuffer
+    where
+        BytesMut: From<T>,
+    {
+        TestBuffer {
+            read_buf: BytesMut::from(data),
+            write_buf: BytesMut::new(),
+            err: None,
+        }
+    }
+
+    /// Create new empty TestBuffer instance
+    pub fn empty() -> TestBuffer {
+        TestBuffer::new("")
+    }
+
+    /// Add extra data to read buffer.
+    pub fn extend_read_buf<T: AsRef<[u8]>>(&mut self, data: T) {
+        self.read_buf.extend_from_slice(data.as_ref())
+    }
+}
+
+impl io::Read for TestBuffer {
+    fn read(&mut self, dst: &mut [u8]) -> Result<usize, io::Error> {
+        if self.read_buf.is_empty() {
+            if self.err.is_some() {
+                Err(self.err.take().unwrap())
+            } else {
+                Err(io::Error::new(io::ErrorKind::WouldBlock, ""))
+            }
+        } else {
+            let size = std::cmp::min(self.read_buf.len(), dst.len());
+            let b = self.read_buf.split_to(size);
+            dst[..size].copy_from_slice(&b);
+            Ok(size)
+        }
+    }
+}
+
+impl io::Write for TestBuffer {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.write_buf.extend(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl AsyncRead for TestBuffer {}
+
+impl AsyncWrite for TestBuffer {
+    fn shutdown(&mut self) -> Poll<(), io::Error> {
+        Ok(Async::Ready(()))
+    }
+    fn write_buf<B: Buf>(&mut self, _: &mut B) -> Poll<usize, io::Error> {
+        Ok(Async::NotReady)
+    }
+}
+
+impl IoStream for TestBuffer {
+    fn set_nodelay(&mut self, _nodelay: bool) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn set_linger(&mut self, _dur: Option<std::time::Duration>) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn set_keepalive(&mut self, _dur: Option<std::time::Duration>) -> io::Result<()> {
+        Ok(())
+    }
+}
--- a/actix-http/src/ws/codec.rs
+++ b/actix-http/src/ws/codec.rs
@ -18,6 +18,8 @@ pub enum Message {
    Pong(String),
    /// Close message with optional reason
    Close(Option<CloseReason>),
+    /// No-op. Useful for actix-net services
+    Nop,
 }

 /// `WebSocket` frame
@ -35,7 +37,7 @@ pub enum Frame {
    Close(Option<CloseReason>),
 }

-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 /// WebSockets protocol codec
 pub struct Codec {
    max_size: usize,
@ -87,6 +89,7 @@ impl Encoder for Codec {
                Parser::write_message(dst, txt, OpCode::Pong, true, !self.server)
            }
            Message::Close(reason) => Parser::write_close(dst, reason, !self.server),
+            Message::Nop => (),
        }
        Ok(())
    }
--- a/actix-http/src/ws/frame.rs
+++ b/actix-http/src/ws/frame.rs
@ -172,13 +172,14 @@ impl Parser {
        };

        if payload_len < 126 {
+            dst.reserve(p_len + 2 + if mask { 4 } else { 0 });
            dst.put_slice(&[one, two | payload_len as u8]);
        } else if payload_len <= 65_535 {
-            dst.reserve(p_len + 4);
+            dst.reserve(p_len + 4 + if mask { 4 } else { 0 });
            dst.put_slice(&[one, two | 126]);
            dst.put_u16_be(payload_len as u16);
        } else {
-            dst.reserve(p_len + 10);
+            dst.reserve(p_len + 10 + if mask { 4 } else { 0 });
            dst.put_slice(&[one, two | 127]);
            dst.put_u64_be(payload_len as u64);
        };
@ -186,7 +187,7 @@ impl Parser {
        if mask {
            let mask = rand::random::<u32>();
            dst.put_u32_le(mask);
-            dst.extend_from_slice(payload.as_ref());
+            dst.put_slice(payload.as_ref());
            let pos = dst.len() - payload_len;
            apply_mask(&mut dst[pos..], mask);
        } else {
--- a/actix-http/src/ws/mod.rs
+++ b/actix-http/src/ws/mod.rs
@ -9,21 +9,18 @@ use derive_more::{Display, From};
 use http::{header, Method, StatusCode};

 use crate::error::ResponseError;
-use crate::httpmessage::HttpMessage;
-use crate::request::Request;
+use crate::message::RequestHead;
 use crate::response::{Response, ResponseBuilder};

 mod codec;
 mod frame;
 mod mask;
 mod proto;
-mod service;
 mod transport;

 pub use self::codec::{Codec, Frame, Message};
 pub use self::frame::Parser;
 pub use self::proto::{hash_key, CloseCode, CloseReason, OpCode};
-pub use self::service::VerifyWebSockets;
 pub use self::transport::Transport;

 /// Websocket protocol errors
@ -112,7 +109,7 @@ impl ResponseError for HandshakeError {
 // /// `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(req: &Request) -> Result<ResponseBuilder, HandshakeError> {
+pub fn handshake(req: &RequestHead) -> Result<ResponseBuilder, HandshakeError> {
    verify_handshake(req)?;
    Ok(handshake_response(req))
 }
@ -121,9 +118,9 @@ pub fn handshake(req: &Request) -> Result<ResponseBuilder, HandshakeError> {
 // /// `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 verify_handshake(req: &Request) -> Result<(), HandshakeError> {
+pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
    // WebSocket accepts only GET
-    if *req.method() != Method::GET {
+    if req.method != Method::GET {
        return Err(HandshakeError::GetMethodRequired);
    }

@ -171,7 +168,7 @@ pub fn verify_handshake(req: &Request) -> Result<(), HandshakeError> {
 /// Create websocket's handshake response
 ///
 /// This function returns handshake `Response`, ready to send to peer.
-pub fn handshake_response(req: &Request) -> ResponseBuilder {
+pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
    let key = {
        let key = req.headers().get(header::SEC_WEBSOCKET_KEY).unwrap();
        proto::hash_key(key.as_ref())
@ -195,13 +192,13 @@ mod tests {
        let req = TestRequest::default().method(Method::POST).finish();
        assert_eq!(
            HandshakeError::GetMethodRequired,
-            verify_handshake(&req).err().unwrap()
+            verify_handshake(req.head()).err().unwrap()
        );

        let req = TestRequest::default().finish();
        assert_eq!(
            HandshakeError::NoWebsocketUpgrade,
-            verify_handshake(&req).err().unwrap()
+            verify_handshake(req.head()).err().unwrap()
        );

        let req = TestRequest::default()
@ -209,7 +206,7 @@ mod tests {
            .finish();
        assert_eq!(
            HandshakeError::NoWebsocketUpgrade,
-            verify_handshake(&req).err().unwrap()
+            verify_handshake(req.head()).err().unwrap()
        );

        let req = TestRequest::default()
@ -220,7 +217,7 @@ mod tests {
            .finish();
        assert_eq!(
            HandshakeError::NoConnectionUpgrade,
-            verify_handshake(&req).err().unwrap()
+            verify_handshake(req.head()).err().unwrap()
        );

        let req = TestRequest::default()
@ -235,7 +232,7 @@ mod tests {
            .finish();
        assert_eq!(
            HandshakeError::NoVersionHeader,
-            verify_handshake(&req).err().unwrap()
+            verify_handshake(req.head()).err().unwrap()
        );

        let req = TestRequest::default()
@ -254,7 +251,7 @@ mod tests {
            .finish();
        assert_eq!(
            HandshakeError::UnsupportedVersion,
-            verify_handshake(&req).err().unwrap()
+            verify_handshake(req.head()).err().unwrap()
        );

        let req = TestRequest::default()
@ -273,7 +270,7 @@ mod tests {
            .finish();
        assert_eq!(
            HandshakeError::BadWebsocketKey,
-            verify_handshake(&req).err().unwrap()
+            verify_handshake(req.head()).err().unwrap()
        );

        let req = TestRequest::default()
@ -296,7 +293,7 @@ mod tests {
            .finish();
        assert_eq!(
            StatusCode::SWITCHING_PROTOCOLS,
-            handshake_response(&req).finish().status()
+            handshake_response(req.head()).finish().status()
        );
    }

--- a/actix-http/src/ws/service.rs
+++ b/actix-http/src/ws/service.rs
@ -1,52 +0,0 @@
-use std::marker::PhantomData;
-
-use actix_codec::Framed;
-use actix_service::{NewService, Service};
-use futures::future::{ok, FutureResult};
-use futures::{Async, IntoFuture, Poll};
-
-use crate::h1::Codec;
-use crate::request::Request;
-
-use super::{verify_handshake, HandshakeError};
-
-pub struct VerifyWebSockets<T> {
-    _t: PhantomData<T>,
-}
-
-impl<T> Default for VerifyWebSockets<T> {
-    fn default() -> Self {
-        VerifyWebSockets { _t: PhantomData }
-    }
-}
-
-impl<T> NewService for VerifyWebSockets<T> {
-    type Request = (Request, Framed<T, Codec>);
-    type Response = (Request, Framed<T, Codec>);
-    type Error = (HandshakeError, Framed<T, Codec>);
-    type InitError = ();
-    type Service = VerifyWebSockets<T>;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(VerifyWebSockets { _t: PhantomData })
-    }
-}
-
-impl<T> Service for VerifyWebSockets<T> {
-    type Request = (Request, Framed<T, Codec>);
-    type Response = (Request, Framed<T, Codec>);
-    type Error = (HandshakeError, Framed<T, Codec>);
-    type Future = FutureResult<Self::Response, Self::Error>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
-        match verify_handshake(&req) {
-            Err(e) => Err((e, framed)).into_future(),
-            Ok(_) => Ok((req, framed)).into_future(),
-        }
-    }
-}
--- a/actix-http/tests/cert.pem
+++ b/actix-http/tests/cert.pem
@ -1,16 +1,20 @@
 -----BEGIN CERTIFICATE-----
-MIICljCCAX4CCQDFdWu66640QjANBgkqhkiG9w0BAQsFADANMQswCQYDVQQGEwJ1
-czAeFw0xOTAyMDQyMzEyNTBaFw0yMDAyMDQyMzEyNTBaMA0xCzAJBgNVBAYTAnVz
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzZUXMnS5X8HWxTvHAc82
-Q2d32fiPQGtD+fp3OV90l6RC9jgMdH4yTVUgX5mYYcW0k89RaP8g61H6b76F9gcd
-yZ1idqKI1AU9aeBUPV8wkrouhR/6Omv8fA7yr9tVmNo53jPN7WyKoBoU0r7Yj9Ez
-g3qjv/808Jlgby3EhduruyyfdvSt5ZFXnOz2D3SF9DS4yrM2jSw4ZTuoVMfZ8vZe
-FVzLo/+sV8qokU6wBTEOAmZQ7e/zZV4qAoH2Z3Vj/uD1Zr/MXYyh81RdXpDqIXwV
-Z29LEOa2eTGFEdvfG+tdvvuIvSdF3+WbLrwn2ECfwJ8zmKyTauPRV4pj7ks+wkBI
-EQIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQB6dmuWBOpFfDdu0mdsDb8XnJY1svjH
-4kbztXhjQJ/WuhCUIwvXFyz9dqQCq+TbJUbUEzZJEfaq1uaI3iB5wd35ArSoAGJA
-k0lonzyeSM+cmNOe/5BPqWhd1qPwbsfgMoCCkZUoTT5Rvw6yt00XIqZzMqrsvRBX
-hAcUW3zBtFQNP6aQqsMdn4ClZE0WHf+LzWy2NQh+Sf46tSYBHELfdUawgR789PB4
-/gNjAeklq06JmE/3gELijwaijVIuUsMC9ua//ITk4YIFpqanPtka+7BpfTegPGNs
-HCj1g7Jot97oQMuvDOJeso91aiSA+gutepCClZICT8LxNRkY3ZlXYp92
+MIIDPjCCAiYCCQCmkoCBehOyYTANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJV
+UzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMRAwDgYDVQQKDAdDb21wYW55MQww
+CgYDVQQLDANPcmcxGDAWBgNVBAMMD3d3dy5leGFtcGxlLmNvbTAeFw0xOTAzMjky
+MzE5MDlaFw0yMDAzMjgyMzE5MDlaMGExCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJD
+QTELMAkGA1UEBwwCU0YxEDAOBgNVBAoMB0NvbXBhbnkxDDAKBgNVBAsMA09yZzEY
+MBYGA1UEAwwPd3d3LmV4YW1wbGUuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEA2uFoWm74qumqIIsBBf/rgP3ZtZw6dRQhVoYjIwYk00T1RLmmbt8r
+YNh3lehmnrQlM/YC3dzcspucGqIfvs5FEReh/vgvsqY3lfy47Q1zzdtBrKq2ZBro
+AuJUe4ayMYz/L/2jAtPtGDQqWyzhKv6x/oz6N/tKqlzoGbjSGSJUqKAV+Tuo4YI4
+xw3r/RJg3I3+ruXOgM65GBdja7usI/BhseEOp9VXotoTEItGmvG2RFZ4A7cN124x
+giFl2IeYuC60jteZ+bnhPiqxcdzf3K4dnZlzrYma+FxwWbaow4wlpQcZVFdZ+K/Y
+p/Bbm/FDKoUHnEdn/QAanTruRxSGdai0owIDAQABMA0GCSqGSIb3DQEBCwUAA4IB
+AQAEWn3WAwAbd64f5jo2w4076s2qFiCJjPWoxO6bO75FgFFtw/NNev8pxGVw1ehg
+HiTO6VRYolL5S/RKOchjA83AcDEBjgf8fKtvTmE9kxZSUIo4kIvv8V9ZM72gJhDN
+8D/lXduTZ9JMwLOa1NUB8/I6CbaU3VzWkfodArKKpQF3M+LLgK03i12PD0KPQ5zv
+bwaNoQo6cTmPNIdsVZETRvPqONiCUaQV57G74dGtjeirCh/DO5EYRtb1thgS7TGm
+Xg8OC5vZ6g0+xsrSqDBmWNtlI7S3bsL5C3LIEOOAL1ZJHRy2KvIGQ9ipb3XjnKS
+N7/wlQduRyPH7oaD/o4xf5Gt
 -----END CERTIFICATE-----
--- a/actix-http/tests/identity.pfx
+++ b/actix-http/tests/identity.pfx
--- a/actix-http/tests/key.pem
+++ b/actix-http/tests/key.pem
@ -1,28 +1,27 @@
-----BEGIN PRIVATE KEY-----
-MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDNlRcydLlfwdbF
-O8cBzzZDZ3fZ+I9Aa0P5+nc5X3SXpEL2OAx0fjJNVSBfmZhhxbSTz1Fo/yDrUfpv
-voX2Bx3JnWJ2oojUBT1p4FQ9XzCSui6FH/o6a/x8DvKv21WY2jneM83tbIqgGhTS
-vtiP0TODeqO//zTwmWBvLcSF26u7LJ929K3lkVec7PYPdIX0NLjKszaNLDhlO6hU
-x9ny9l4VXMuj/6xXyqiRTrAFMQ4CZlDt7/NlXioCgfZndWP+4PVmv8xdjKHzVF1e
-kOohfBVnb0sQ5rZ5MYUR298b612++4i9J0Xf5ZsuvCfYQJ/AnzOYrJNq49FXimPu
-Sz7CQEgRAgMBAAECggEBALC547EaKmko5wmyM4dYq9sRzTPxuqO0EkGIkIkfh8j8
-ChxDXmGeQnu8HBJSpW4XWP5fkCpkd9YTKOh6rgorX+37f7NgUaOBxaOIlqITfFwF
-9Qu3y5IBVpEHAJUwRcsaffiILBRX5GtxQElSijRHsLLr8GySZN4X25B3laNEjcJe
-NWJrDaxOn0m0MMGRvBpM8PaZu1Mn9NWxt04b/fteVLdN4TAcuY9TgvVZBq92S2FM
-qvZcnJCQckNOuMOptVdP45qPkerKUohpOcqBfIiWFaalC378jE3Dm68p7slt3R6y
-I1wVqCI4+MZfM3CtKcYJV0fdqklJCvXORvRiT8OZKakCgYEA5YnhgXOu4CO4DR1T
-Lacv716DPyHeKVa6TbHhUhWw4bLwNLUsEL98jeU9SZ6VH8enBlDm5pCsp2i//t9n
-8hoykN4L0rS4EyAGENouTRkLhtHfjTAKTKDK8cNvEaS8NOBJWrI0DTiHtFbCRBvI
-zRx5VhrB5H4DDbqn7QV9g+GBKvMCgYEA5Ug3bN0RNUi3KDoIRcnWc06HsX307su7
-tB4cGqXJqVOJCrkk5sefGF502+W8m3Ldjaakr+Q9BoOdZX6boZnFtVetT8Hyzk1C
-Rkiyz3GcwovOkQK//UmljsuRjgHF+PuQGX5ol4YlJtXU21k5bCsi1Tmyp7IufiGV
-AQRMVZVbeesCgYA/QBZGwKTgmJcf7gO8ocRAto999wwr4f0maazIHLgICXHNZFsH
-JmzhANk5jxxSjIaG5AYsZJNe8ittxQv0l6l1Z+pkHm5Wvs1NGYIGtq8JcI2kbyd3
-ZBtoMU1K1FUUUPWFq3NSbVBfrkSL1ggoFP+ObYMePmcDAntBgfDLRXl9ZwKBgQCt
-/dh5l2UIn27Gawt+EkXX6L8WVTQ6xoZhj/vZyPe4tDip14gGTXQQ5RUfDj7LZCZ2
-6P/OrpAU0mnt7F8kCfI7xBY0EUU1gvGJLn/q5heElt2hs4mIJ4woSZjiP7xBTn2y
-qveqDNVCnEBUWGg4Cp/7WTaXBaM8ejV9uQpIY/gwEwKBgQCCYnd9fD8L4nGyOLoD
-eUzMV7G8TZfinlxCNMVXfpn4Z8OaYHOk5NiujHK55w4ghx06NQw038qhnX0ogbjU
-caWOwCIbrYgx2fwYuOZbJFXdjWlpjIK3RFOcbNCNgCRLT6Lgz4uZYZ9RVftADvMi
-zR1QsLWnIvARbTtOPfZqizT2gQ==
-----END PRIVATE KEY-----
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEA2uFoWm74qumqIIsBBf/rgP3ZtZw6dRQhVoYjIwYk00T1RLmm
+bt8rYNh3lehmnrQlM/YC3dzcspucGqIfvs5FEReh/vgvsqY3lfy47Q1zzdtBrKq2
+ZBroAuJUe4ayMYz/L/2jAtPtGDQqWyzhKv6x/oz6N/tKqlzoGbjSGSJUqKAV+Tuo
+4YI4xw3r/RJg3I3+ruXOgM65GBdja7usI/BhseEOp9VXotoTEItGmvG2RFZ4A7cN
+124xgiFl2IeYuC60jteZ+bnhPiqxcdzf3K4dnZlzrYma+FxwWbaow4wlpQcZVFdZ
+K/Yp/Bbm/FDKoUHnEdn/QAanTruRxSGdai0owIDAQABAoIBAQC4lzyQd+ITEbi+
+dTxJuQj94hgHB1htgKqU888SLI5F9nP6n67y9hb5N9WygSp6UWbGqYTFYwxlPMKr
+22p2WjL5NTsTcm+XdIKQZW/3y06Mn4qFefsT9XURaZriCjihfU2BRaCCNARSUzwd
+ZH4I6n9mM7KaH71aa7v6ZVoahE9tXPR6hM+SHQEySW4pWkEu98VpNNeIt6vP7WF9
+ONGbRa+0En4xgkuaxem2ZYa/GZFFtdQRkroNMhIRlfcPpkjy8DCc8E5RAkOzKC3O
+lnxQwt+tdNNkGZz02ed2hx/YHPwFYy76y6hK5dxq74iKIaOc8U5t0HjB1zVfwiR0
+5mcxMncxAoGBAP+RivwXZ4FcxDY1uyziF+rwlC/1RujQFEWXIxsXCnba5DH3yKul
+iKEIZPZtGhpsnQe367lcXcn7tztuoVjpAnk5L+hQY64tLwYbHeRcOMJ75C2y8FFC
+NeG5sQsrk3IU1+jhGvrbE7UgOeAuWJmv0M1vPNB/+hGoZBW5W5uU1x89AoGBANtA
+AhLtAcqQ/Qh2SpVhLljh7U85Be9tbCGua09clkYFzh3bcoBolXKH18Veww0TP0yF
+0748CKw1A+ITbTVFV+vKvi4jzIxS7mr4wYtVCMssbttQN7y3l30IDxJwa9j3zTJx
+IUn5OMMLv1JyitLId8HdOy1AdU3MkpJzdLyi1mFfAoGBAL3kL4fGABM/kU7SN6RO
+zgS0AvdrYOeljBp1BRGg2hab58g02vamxVEZgqMTR7zwjPDqOIz+03U7wda4Ccyd
+PUhDNJSB/r6xNepshZZi642eLlnCRguqjYyNw72QADtYv2B6uehAlXEUY8xtw0lW
+OGgcSeyF2pH6M3tswWNlgT3lAoGAQ/BttBelOnP7NKgTLH7Usc4wjyAIaszpePZn
+Ykw6dLBP0oixzoCZ7seRYSOgJWkVcEz39Db+KP60mVWTvbIjMHm+vOVy+Pip0JQM
+xXQwKWU3ZNZSrzPkyWW55ejYQn9nIn5T5mxH3ojBXHcJ9Y8RLQ20zKzwrI77zE3i
+mqGK9NkCgYEAq3dzHI0DGAJrR19sWl2LcqI19sj5a91tHx4cl1dJXS/iApOLLieU
+zyUGkwfsqjHPAZ7GacICeBojIn/7KdPdlSKAbGVAU3d4qzvFS0qmWzObplBz3niT
+Xnep2XLaVXqwlFJZZ6AHeKzYmMH0d0raiou2bpEUBqYizy2fi3NI4mA=
+-----END RSA PRIVATE KEY-----
--- a/actix-http/tests/test_client.rs
+++ b/actix-http/tests/test_client.rs
@ -1,11 +1,8 @@
 use actix_service::NewService;
-use bytes::{Bytes, BytesMut};
+use bytes::Bytes;
 use futures::future::{self, ok};
-use futures::{Future, Stream};

-use actix_http::{
-    error::PayloadError, http, HttpMessage, HttpService, Request, Response,
-};
+use actix_http::{http, HttpService, Request, Response};
 use actix_http_test::TestServer;

 const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
@ -30,40 +27,28 @@ const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
                   Hello World Hello World Hello World Hello World Hello World \
                   Hello World Hello World Hello World Hello World Hello World";

-fn load_body<S>(stream: S) -> impl Future<Item = BytesMut, Error = PayloadError>
-where
-    S: Stream<Item = Bytes, Error = PayloadError>,
-{
-    stream.fold(BytesMut::new(), move |mut body, chunk| {
-        body.extend_from_slice(&chunk);
-        Ok::<_, PayloadError>(body)
-    })
-}
-
 #[test]
 fn test_h1_v2() {
    env_logger::init();
    let mut srv = TestServer::new(move || {
-        HttpService::build()
-            .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
-            .map(|_| ())
+        HttpService::build().finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
    });
-    let response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());

-    let request = srv.get().header("x-test", "111").send();
-    let mut response = srv.block_on(request).unwrap();
+    let request = srv.get("/").header("x-test", "111").send();
+    let response = srv.block_on(request).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));

-    let mut response = srv.block_on(srv.post().send()).unwrap();
+    let response = srv.block_on(srv.post("/").send()).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

@ -74,7 +59,7 @@ fn test_connection_close() {
            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .map(|_| ())
    });
-    let response = srv.block_on(srv.get().close_connection().send()).unwrap();
+    let response = srv.block_on(srv.get("/").force_close().send()).unwrap();
    assert!(response.status().is_success());
 }

--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@ -5,18 +5,19 @@ use std::{net, thread};
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_http_test::TestServer;
 use actix_server_config::ServerConfig;
-use actix_service::{fn_cfg_factory, NewService};
+use actix_service::{new_service_cfg, service_fn, NewService};
 use bytes::{Bytes, BytesMut};
 use futures::future::{self, ok, Future};
 use futures::stream::{once, Stream};
+use regex::Regex;
+use tokio_timer::sleep;

-use actix_http::body::Body;
 use actix_http::error::PayloadError;
 use actix_http::{
-    body, error, http, http::header, Error, HttpMessage as HttpMessage2, HttpService,
-    KeepAlive, Request, Response,
+    body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response,
 };

+#[cfg(feature = "ssl")]
 fn load_body<S>(stream: S) -> impl Future<Item = BytesMut, Error = PayloadError>
 where
    S: Stream<Item = Bytes, Error = PayloadError>,
@ -34,10 +35,13 @@ fn test_h1() {
            .keep_alive(KeepAlive::Disabled)
            .client_timeout(1000)
            .client_disconnect(1000)
-            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
+            .h1(|req: Request| {
+                assert!(req.peer_addr().is_some());
+                future::ok::<_, ()>(Response::Ok().finish())
+            })
    });

-    let response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());
 }

@ -49,13 +53,14 @@ fn test_h1_2() {
            .client_timeout(1000)
            .client_disconnect(1000)
            .finish(|req: Request| {
+                assert!(req.peer_addr().is_some());
                assert_eq!(req.version(), http::Version::HTTP_11);
                future::ok::<_, ()>(Response::Ok().finish())
            })
            .map(|_| ())
    });

-    let response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());
 }

@ -98,7 +103,7 @@ fn test_h2() -> std::io::Result<()> {
            )
    });

-    let response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert!(response.status().is_success());
    Ok(())
 }
@ -114,6 +119,7 @@ fn test_h2_1() -> std::io::Result<()> {
            .and_then(
                HttpService::build()
                    .finish(|req: Request| {
+                        assert!(req.peer_addr().is_some());
                        assert_eq!(req.version(), http::Version::HTTP_2);
                        future::ok::<_, Error>(Response::Ok().finish())
                    })
@ -121,7 +127,7 @@ fn test_h2_1() -> std::io::Result<()> {
            )
    });

-    let response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert!(response.status().is_success());
    Ok(())
 }
@ -145,14 +151,118 @@ fn test_h2_body() -> std::io::Result<()> {
            )
    });

-    let mut response = srv.block_on(srv.sget().send_body(data.clone())).unwrap();
+    let response = srv.block_on(srv.sget("/").send_body(data.clone())).unwrap();
    assert!(response.status().is_success());

-    let body = srv.block_on(load_body(response.take_payload())).unwrap();
+    let body = srv.load_body(response).unwrap();
    assert_eq!(&body, data.as_bytes());
    Ok(())
 }

+#[test]
+fn test_expect_continue() {
+    let srv = TestServer::new(|| {
+        HttpService::build()
+            .expect(service_fn(|req: Request| {
+                if req.head().uri.query() == Some("yes=") {
+                    Ok(req)
+                } else {
+                    Err(error::ErrorPreconditionFailed("error"))
+                }
+            }))
+            .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
+    });
+
+    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
+    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
+    let mut data = String::new();
+    let _ = stream.read_to_string(&mut data);
+    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
+
+    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
+    let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
+    let mut data = String::new();
+    let _ = stream.read_to_string(&mut data);
+    assert!(data.starts_with("HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK\r\n"));
+}
+
+#[test]
+fn test_expect_continue_h1() {
+    let srv = TestServer::new(|| {
+        HttpService::build()
+            .expect(service_fn(|req: Request| {
+                sleep(Duration::from_millis(20)).then(move |_| {
+                    if req.head().uri.query() == Some("yes=") {
+                        Ok(req)
+                    } else {
+                        Err(error::ErrorPreconditionFailed("error"))
+                    }
+                })
+            }))
+            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
+    });
+
+    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
+    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
+    let mut data = String::new();
+    let _ = stream.read_to_string(&mut data);
+    assert!(data.starts_with("HTTP/1.1 412 Precondition Failed\r\ncontent-length"));
+
+    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
+    let _ = stream.write_all(b"GET /test?yes= HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
+    let mut data = String::new();
+    let _ = stream.read_to_string(&mut data);
+    assert!(data.starts_with("HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK\r\n"));
+}
+
+#[test]
+fn test_chunked_payload() {
+    let chunk_sizes = vec![32768, 32, 32768];
+    let total_size: usize = chunk_sizes.iter().sum();
+
+    let srv = TestServer::new(|| {
+        HttpService::build().h1(|mut request: Request| {
+            request
+                .take_payload()
+                .map_err(|e| panic!(format!("Error reading payload: {}", e)))
+                .fold(0usize, |acc, chunk| future::ok::<_, ()>(acc + chunk.len()))
+                .map(|req_size| Response::Ok().body(format!("size={}", req_size)))
+        })
+    });
+
+    let returned_size = {
+        let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
+        let _ = stream
+            .write_all(b"POST /test HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n");
+
+        for chunk_size in chunk_sizes.iter() {
+            let mut bytes = Vec::new();
+            let random_bytes: Vec<u8> =
+                (0..*chunk_size).map(|_| rand::random::<u8>()).collect();
+
+            bytes.extend(format!("{:X}\r\n", chunk_size).as_bytes());
+            bytes.extend(&random_bytes[..]);
+            bytes.extend(b"\r\n");
+            let _ = stream.write_all(&bytes);
+        }
+
+        let _ = stream.write_all(b"0\r\n\r\n");
+        stream.shutdown(net::Shutdown::Write).unwrap();
+
+        let mut data = String::new();
+        let _ = stream.read_to_string(&mut data);
+
+        let re = Regex::new(r"size=(\d+)").unwrap();
+        let size: usize = match re.captures(&data) {
+            Some(caps) => caps.get(1).unwrap().as_str().parse().unwrap(),
+            None => panic!(format!("Failed to find size in HTTP Response: {}", data)),
+        };
+        size
+    };
+
+    assert_eq!(returned_size, total_size);
+}
+
 #[test]
 fn test_slow_request() {
    let srv = TestServer::new(|| {
@ -347,6 +457,7 @@ fn test_content_length() {
    }
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_content_length() {
    use actix_http::http::{
@ -436,14 +547,15 @@ fn test_h1_headers() {
        })
    });

-    let mut response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from(data2));
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_headers() {
    let data = STR.repeat(10);
@ -480,11 +592,11 @@ fn test_h2_headers() {
        }).map_err(|_| ()))
    });

-    let mut response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from(data2));
 }

@ -516,14 +628,15 @@ fn test_h1_body() {
        HttpService::build().h1(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
    });

-    let mut response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_body2() {
    let openssl = ssl_acceptor().unwrap();
@ -538,11 +651,11 @@ fn test_h2_body2() {
            )
    });

-    let mut response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

@ -552,7 +665,7 @@ fn test_h1_head_empty() {
        HttpService::build().h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
    });

-    let mut response = srv.block_on(srv.head().send()).unwrap();
+    let response = srv.block_on(srv.head("/").send()).unwrap();
    assert!(response.status().is_success());

    {
@ -564,10 +677,11 @@ fn test_h1_head_empty() {
    }

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert!(bytes.is_empty());
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_head_empty() {
    let openssl = ssl_acceptor().unwrap();
@ -582,7 +696,7 @@ fn test_h2_head_empty() {
            )
    });

-    let mut response = srv.block_on(srv.shead().send()).unwrap();
+    let response = srv.block_on(srv.shead("/").send()).unwrap();
    assert!(response.status().is_success());
    assert_eq!(response.version(), http::Version::HTTP_2);

@ -595,7 +709,7 @@ fn test_h2_head_empty() {
    }

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert!(bytes.is_empty());
 }

@ -607,7 +721,7 @@ fn test_h1_head_binary() {
        })
    });

-    let mut response = srv.block_on(srv.head().send()).unwrap();
+    let response = srv.block_on(srv.head("/").send()).unwrap();
    assert!(response.status().is_success());

    {
@ -619,10 +733,11 @@ fn test_h1_head_binary() {
    }

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert!(bytes.is_empty());
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_head_binary() {
    let openssl = ssl_acceptor().unwrap();
@ -641,7 +756,7 @@ fn test_h2_head_binary() {
            )
    });

-    let mut response = srv.block_on(srv.shead().send()).unwrap();
+    let response = srv.block_on(srv.shead("/").send()).unwrap();
    assert!(response.status().is_success());

    {
@ -653,7 +768,7 @@ fn test_h2_head_binary() {
    }

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert!(bytes.is_empty());
 }

@ -663,7 +778,7 @@ fn test_h1_head_binary2() {
        HttpService::build().h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
    });

-    let response = srv.block_on(srv.head().send()).unwrap();
+    let response = srv.block_on(srv.head("/").send()).unwrap();
    assert!(response.status().is_success());

    {
@ -675,6 +790,7 @@ fn test_h1_head_binary2() {
    }
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_head_binary2() {
    let openssl = ssl_acceptor().unwrap();
@ -689,7 +805,7 @@ fn test_h2_head_binary2() {
            )
    });

-    let response = srv.block_on(srv.shead().send()).unwrap();
+    let response = srv.block_on(srv.shead("/").send()).unwrap();
    assert!(response.status().is_success());

    {
@ -707,20 +823,20 @@ fn test_h1_body_length() {
        HttpService::build().h1(|_| {
            let body = once(Ok(Bytes::from_static(STR.as_ref())));
            ok::<_, ()>(
-                Response::Ok()
-                    .body(Body::from_message(body::SizedStream::new(STR.len(), body))),
+                Response::Ok().body(body::SizedStream::new(STR.len() as u64, body)),
            )
        })
    });

-    let mut response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_body_length() {
    let openssl = ssl_acceptor().unwrap();
@ -732,19 +848,20 @@ fn test_h2_body_length() {
                HttpService::build()
                    .h2(|_| {
                        let body = once(Ok(Bytes::from_static(STR.as_ref())));
-                        ok::<_, ()>(Response::Ok().body(Body::from_message(
-                            body::SizedStream::new(STR.len(), body),
-                        )))
+                        ok::<_, ()>(
+                            Response::Ok()
+                                .body(body::SizedStream::new(STR.len() as u64, body)),
+                        )
                    })
                    .map_err(|_| ()),
            )
    });

-    let mut response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert!(response.status().is_success());

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

@ -761,7 +878,7 @@ fn test_h1_body_chunked_explicit() {
        })
    });

-    let mut response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());
    assert_eq!(
        response
@ -774,12 +891,13 @@ fn test_h1_body_chunked_explicit() {
    );

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();

    // decode
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_body_chunked_explicit() {
    let openssl = ssl_acceptor().unwrap();
@ -802,12 +920,12 @@ fn test_h2_body_chunked_explicit() {
            )
    });

-    let mut response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert!(response.status().is_success());
    assert!(!response.headers().contains_key(header::TRANSFER_ENCODING));

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();

    // decode
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
@ -822,7 +940,7 @@ fn test_h1_body_chunked_implicit() {
        })
    });

-    let mut response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert!(response.status().is_success());
    assert_eq!(
        response
@ -835,14 +953,14 @@ fn test_h1_body_chunked_implicit() {
    );

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
 }

 #[test]
 fn test_h1_response_http_error_handling() {
    let mut srv = TestServer::new(|| {
-        HttpService::build().h1(fn_cfg_factory(|_: &ServerConfig| {
+        HttpService::build().h1(new_service_cfg(|_: &ServerConfig| {
            Ok::<_, ()>(|_| {
                let broken_header = Bytes::from_static(b"\0\0\0");
                ok::<_, ()>(
@ -854,14 +972,15 @@ fn test_h1_response_http_error_handling() {
        }))
    });

-    let mut response = srv.block_on(srv.get().send()).unwrap();
+    let response = srv.block_on(srv.get("/").send()).unwrap();
    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
-    assert!(bytes.is_empty());
+    let bytes = srv.load_body(response).unwrap();
+    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_response_http_error_handling() {
    let openssl = ssl_acceptor().unwrap();
@ -872,7 +991,7 @@ fn test_h2_response_http_error_handling() {
            .map_err(|e| println!("Openssl error: {}", e))
            .and_then(
                HttpService::build()
-                    .h2(fn_cfg_factory(|_: &ServerConfig| {
+                    .h2(new_service_cfg(|_: &ServerConfig| {
                        Ok::<_, ()>(|_| {
                            let broken_header = Bytes::from_static(b"\0\0\0");
                            ok::<_, ()>(
@ -886,12 +1005,12 @@ fn test_h2_response_http_error_handling() {
            )
    });

-    let mut response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
-    assert!(bytes.is_empty());
+    let bytes = srv.load_body(response).unwrap();
+    assert_eq!(bytes, Bytes::from_static(b"failed to parse header value"));
 }

 #[test]
@ -901,14 +1020,15 @@ fn test_h1_service_error() {
            .h1(|_| Err::<Response, Error>(error::ErrorBadRequest("error")))
    });

-    let mut response = srv.block_on(srv.get().send()).unwrap();
-    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
+    let response = srv.block_on(srv.get("/").send()).unwrap();
+    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
-    assert!(bytes.is_empty());
+    let bytes = srv.load_body(response).unwrap();
+    assert_eq!(bytes, Bytes::from_static(b"error"));
 }

+#[cfg(feature = "ssl")]
 #[test]
 fn test_h2_service_error() {
    let openssl = ssl_acceptor().unwrap();
@ -924,10 +1044,10 @@ fn test_h2_service_error() {
            )
    });

-    let mut response = srv.block_on(srv.sget().send()).unwrap();
+    let response = srv.block_on(srv.sget("/").send()).unwrap();
    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);

    // read response
-    let bytes = srv.block_on(load_body(response.take_payload())).unwrap();
+    let bytes = srv.load_body(response).unwrap();
    assert!(bytes.is_empty());
 }
--- a/Show More
+++ b/Show More