diff --git a/Cargo.lock b/Cargo.lock
index 6e1c87f..07be948 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -271,8 +271,6 @@ checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 [[package]]
 name = "hyper"
 version = "0.14.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e011372fa0b68db8350aa7a248930ecc7839bf46d8485577d69f117a75f164c"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -634,8 +632,6 @@ dependencies = [
 [[package]]
 name = "warp"
 version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed7b8be92646fc3d18b06147664ebc5f48d222686cb11a8755e561a735aacc6d"
 dependencies = [
  "bytes",
  "futures-channel",
diff --git a/Cargo.toml b/Cargo.toml
index 621a576..b37f8d1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,3 +10,8 @@ futures = "0"
 hyper = { version = "0", default-features = false }
 tokio = { version = "1", default-features = false }
 warp = { version = "0", default-features = false }
+
+
+[patch.crates-io]
+warp = { path = "./warp" }
+hyper = { path = "./hyper" }
\ No newline at end of file
diff --git a/hyper/.github/ISSUE_TEMPLATE/bug_report.md b/hyper/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..62d8ebc
--- /dev/null
+++ b/hyper/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,28 @@
+---
+name: "Bug report \U0001F41B"
+about: Create a report to help us improve
+title: ''
+labels: S-bug
+assignees: ''
+
+---
+
+**Version**
+List the version(s) of `hyper`, and any relevant hyper dependency (such as `h2` if this is related to HTTP/2).
+
+**Platform**
+The output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
+
+**Description**
+Enter your issue details here.
+One way to structure the description:
+
+[short summary of the bug]
+
+I tried this code:
+
+[code sample that causes the bug]
+
+I expected to see this happen: [explanation]
+
+Instead, this happened: [explanation]
diff --git a/hyper/.github/ISSUE_TEMPLATE/feature_request.md b/hyper/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..424e5ba
--- /dev/null
+++ b/hyper/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: "Feature request \U0001F4A1"
+about: Suggest an idea for this project
+title: ''
+labels: S-feature
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/hyper/.github/PULL_REQUEST_TEMPLATE b/hyper/.github/PULL_REQUEST_TEMPLATE
new file mode 100644
index 0000000..e69de29
diff --git a/hyper/.github/workflows/CI.yml b/hyper/.github/workflows/CI.yml
new file mode 100644
index 0000000..126b8f7
--- /dev/null
+++ b/hyper/.github/workflows/CI.yml
@@ -0,0 +1,262 @@
+name: CI
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+env:
+  RUST_BACKTRACE: 1
+
+jobs:
+  ci-pass:
+    name: CI is green
+    runs-on: ubuntu-latest
+    needs:
+      - style
+      - test
+      - msrv
+      - miri
+      - features
+      - ffi
+      - ffi-header
+      - doc
+    steps:
+      - run: exit 0
+
+  style:
+    name: Check Style
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt
+
+      - name: cargo fmt --check
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+  test:
+    name: Test ${{ matrix.rust }} on ${{ matrix.os }}
+    needs: [style]
+    strategy:
+      matrix:
+        rust:
+          - stable
+          - beta
+          - nightly
+
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macOS-latest
+
+        include:
+          - rust: stable
+            features: "--features full"
+          - rust: beta
+            features: "--features full"
+          - rust: nightly
+            features: "--features full,nightly"
+            benches: true
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust (${{ matrix.rust }})
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      - name: Test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: ${{ matrix.features }}
+
+      - name: Test all benches
+        if: matrix.benches
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --benches ${{ matrix.features }}
+
+  msrv:
+    name: Check MSRV (${{ matrix.rust }})
+    needs: [style]
+    strategy:
+      matrix:
+        rust:
+          - 1.56 # keep in sync with MSRV.md dev doc
+
+        os:
+          - ubuntu-latest
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust (${{ matrix.rust }})
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      - name: Check
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --features full
+
+  miri:
+    name: Test with Miri
+    needs: [style]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          components: miri
+          override: true
+
+      - name: Test
+        # Can't enable tcp feature since Miri does not support the tokio runtime
+        run: MIRIFLAGS="-Zmiri-disable-isolation" cargo miri test --features http1,http2,client,server,stream,nightly
+
+  features:
+    name: features
+    needs: [style]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+
+      - name: Install cargo-hack
+        run: cargo install cargo-hack
+
+      - name: check --feature-powerset
+        run: cargo hack check --feature-powerset --depth 2 --skip ffi -Z avoid-dev-deps
+
+  ffi:
+    name: Test C API (FFI)
+    needs: [style]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+
+      - name: Install cbindgen
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cbindgen
+
+      - name: Build FFI
+        uses: actions-rs/cargo@v1
+        env:
+          RUSTFLAGS: --cfg hyper_unstable_ffi
+        with:
+          command: rustc
+          args: --features client,http1,http2,ffi -Z unstable-options --crate-type cdylib
+
+      - name: Make Examples
+        run: cd capi/examples && make client
+
+      - name: Run FFI unit tests
+        uses: actions-rs/cargo@v1
+        env:
+          RUSTFLAGS: --cfg hyper_unstable_ffi
+        with:
+          command: test
+          args: --features full,ffi --lib
+
+  ffi-header:
+    name: Verify hyper.h is up to date
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          default: true
+          override: true
+          components: cargo
+
+      - name: Install cbindgen
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: cbindgen
+
+      - name: Build FFI
+        uses: actions-rs/cargo@v1
+        env:
+          RUSTFLAGS: --cfg hyper_unstable_ffi
+        with:
+          command: build
+          args: --features client,http1,http2,ffi
+
+      - name: Ensure that hyper.h is up to date
+        run: ./capi/gen_header.sh --verify
+
+  doc:
+    name: Build docs
+    needs: [style, test]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+
+      - name: cargo doc
+        uses: actions-rs/cargo@v1
+        with:
+          command: rustdoc
+          args: --features full,ffi -- --cfg docsrs --cfg hyper_unstable_ffi -D broken-intra-doc-links
diff --git a/hyper/.github/workflows/bench.yml b/hyper/.github/workflows/bench.yml
new file mode 100644
index 0000000..1852b68
--- /dev/null
+++ b/hyper/.github/workflows/bench.yml
@@ -0,0 +1,58 @@
+name: Benchmark
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  benchmark:
+    name: Benchmark
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        bench:
+          - connect
+          - end_to_end
+          - pipeline
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+
+      # Run benchmark and stores the output to a file
+      - name: Run benchmark
+        run: cargo bench --features full --bench ${{ matrix.bench }} | tee output.txt
+
+      # Download previous benchmark result from cache (if exists)
+      - name: Download previous benchmark data
+        uses: actions/cache@v1
+        with:
+          path: ./cache
+          key: ${{ runner.os }}-benchmark
+
+      # Run `github-action-benchmark` action
+      - name: Store benchmark result
+        uses: seanmonstar/github-action-benchmark@v1-patch-1
+        with:
+          name: ${{ matrix.bench }}
+          # What benchmark tool the output.txt came from
+          tool: 'cargo'
+          # Where the output from the benchmark tool is stored
+          output-file-path: output.txt
+          # # Where the previous data file is stored
+          # external-data-json-path: ./cache/benchmark-data.json
+          # Workflow will fail when an alert happens
+          fail-on-alert: true
+          # GitHub API token to make a commit comment
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          # Enable alert commit comment
+          comment-on-alert: true
+          #alert-comment-cc-users: '@seanmonstar'
+          auto-push: true
+
+      # Upload the updated cache file for the next job by actions/cache
diff --git a/hyper/.gitignore b/hyper/.gitignore
new file mode 100644
index 0000000..a9d37c5
--- /dev/null
+++ b/hyper/.gitignore
@@ -0,0 +1,2 @@
+target
+Cargo.lock
diff --git a/hyper/CHANGELOG.md b/hyper/CHANGELOG.md
new file mode 100644
index 0000000..a5c8fe0
--- /dev/null
+++ b/hyper/CHANGELOG.md
@@ -0,0 +1,3031 @@
+### v0.14.24 (2023-02-02)
+
+
+#### Bug Fixes
+
+* **body:** set an internal max to reserve in `to_bytes` ([4d89adce](https://github.com/hyperium/hyper/commit/4d89adce6122af1650165337d9d814314e7ee409))
+* **server:** prevent sending 100-continue if user drops request body (#3138) ([92443d7e](https://github.com/hyperium/hyper/commit/92443d7ef57ed474f0add7dd1f114c81a3faa8fe))
+
+
+#### Features
+
+* **http2:** add `http2_max_header_list_size` to `hyper::server::Builder` (#3006) ([031425f0](https://github.com/hyperium/hyper/commit/031425f087219f02a87eea3d01b14e75e35a5209))
+
+
+### v0.14.23 (2022-11-07)
+
+
+#### Bug Fixes
+
+* **http2:** Fix race condition in client dispatcher (#3041) ([2f1c0b72](https://github.com/hyperium/hyper/commit/2f1c0b720da4553fff216a38018a78ecafe23d60), closes [#2419](https://github.com/hyperium/hyper/issues/2419))
+
+
+### v0.14.22 (2022-10-31)
+
+
+#### Bug Fixes
+
+* **server:** fix compile-time cfgs for TCP keepalive options (#3039) ([e8765e0f](https://github.com/hyperium/hyper/commit/e8765e0febd0267472799dcd1109af75944c2637), closes [#3038](https://github.com/hyperium/hyper/issues/3038))
+
+
+### v0.14.21 (2022-10-31)
+
+
+#### Bug Fixes
+
+* **client:** send an error back to client when dispatch misbehaves () ([9fa36382](https://github.com/hyperium/hyper/commit/9fa363829ced232acb18c31ebab8ffb93f691ecc), closes [#2649](https://github.com/hyperium/hyper/issues/2649))
+* **http1:** fix `http1_header_read_timeout` to use same future (#2891) ([c5a14e7c](https://github.com/hyperium/hyper/commit/c5a14e7c087424001223aaeb2dad532ba4ee6063))
+
+
+#### Features
+
+* **http1:** allow ignoring invalid header lines in requests ([73dd4746](https://github.com/hyperium/hyper/commit/73dd474652f5e71fe8a87baa6f9b2490ae746eb3))
+* **server:** add `Server::tcp_keepalive_interval` and `Server::tcp_keepalive_retries` (#2991) ([287d7124](https://github.com/hyperium/hyper/commit/287d712483aec6671427438d60ed2a72f856fd9f))
+
+
+### v0.14.20 (2022-07-07)
+
+
+#### Bug Fixes
+
+* **http1:** fix `http1_header_read_timeout` to use same future (#2891) ([c5a14e7c](https://github.com/hyperium/hyper/commit/c5a14e7c087424001223aaeb2dad532ba4ee6063))
+
+
+#### Features
+
+* **ext:** support non-canonical HTTP/1 reason phrases (#2792) ([b2052a43](https://github.com/hyperium/hyper/commit/b2052a433fd151d7d745ee9c5b27a2031db1dc32))
+
+
+### v0.14.19 (2022-05-27)
+
+
+#### Bug Fixes
+
+* **http1:** fix preserving header case without enabling ffi (#2820) ([6a35c175](https://github.com/hyperium/hyper/commit/6a35c175f2b416851518b5831c2c7827d6dbd822))
+* **server:** don't add implicit content-length to HEAD responses (#2836) ([67b73138](https://github.com/hyperium/hyper/commit/67b73138f110979f3c77ef7b56588f018837e592))
+
+
+#### Features
+
+* **server:**
+  * add `Connection::http2_max_header_list_size` option (#2828) ([a32658c1](https://github.com/hyperium/hyper/commit/a32658c1ae7f1261fa234a767df963be4fc63521), closes [#2826](https://github.com/hyperium/hyper/issues/2826))
+  * add `AddrStream::local_addr()` (#2816) ([ffbf610b](https://github.com/hyperium/hyper/commit/ffbf610b1631cabfacb20886270e3c137fa93800), closes [#2773](https://github.com/hyperium/hyper/issues/2773))
+
+
+#### Breaking Changes
+
+* **ffi (unstable):**
+  * `hyper_clientconn_options_new` no longer sets the `http1_preserve_header_case` connection option by default.
+    Users should now call `hyper_clientconn_options_set_preserve_header_case` if they desire that functionality. ([78de8914](https://github.com/hyperium/hyper/commit/78de8914eadeab4b9a2c71a82c77b2ce33fe6c74))
+
+
+### v0.14.18 (2022-03-22)
+
+
+#### Bug Fixes
+
+* **ffi:** don't build C libraries by default ([1c663706](https://github.com/hyperium/hyper/commit/1c6637060e36654ddb2fdfccb0d146c7ad527476))
+
+
+#### Features
+
+* **client:** add `HttpInfo::local_addr()` method ([055b4e7e](https://github.com/hyperium/hyper/commit/055b4e7ea6bd22859c20d60776b0c8f20d27498e), closes [#2767](https://github.com/hyperium/hyper/issues/2767))
+
+
+### v0.14.17 (2022-02-10)
+
+
+#### Bug Fixes
+
+* **client:** avoid panics in uses of `Instant` (#2746) ([dcdd6d10](https://github.com/hyperium/hyper/commit/dcdd6d109069949ee68ba70ece4a2b4f21079479))
+
+
+#### Features
+
+* **client:** implement the HTTP/2 extended CONNECT protocol from RFC 8441 (#2682) ([5ec094ca](https://github.com/hyperium/hyper/commit/5ec094caa5c999e6f919a2bc82f5f3b7d40c2d8a))
+* **error:** add `Error::message` (#2737) ([6932896a](https://github.com/hyperium/hyper/commit/6932896a7fca58fe461269461f925da8fd4e8d8a), closes [#2732](https://github.com/hyperium/hyper/issues/2732))
+* **http1:** implement obsolete line folding (#2734) ([1f0c177b](https://github.com/hyperium/hyper/commit/1f0c177b35b14054eb1e5108e75f8bd3ff52813e))
+
+
+### v0.14.16 (2021-12-09)
+
+
+#### Bug Fixes
+
+* **http1:** return 414 when URI contains more than 65534 characters (#2706) ([5f938fff](https://github.com/hyperium/hyper/commit/5f938fffa64df23a2e4af81ed4e6d8bd760e2d05), closes [#2701](https://github.com/hyperium/hyper/issues/2701))
+* **http2:** received `Body::size_hint()` now return 0 if implicitly empty (#2715) ([84b78b6c](https://github.com/hyperium/hyper/commit/84b78b6c877ff9aaa28d1e348a5deb63a9282503))
+* **server:** use case-insensitive comparison for Expect: 100-continue (#2709) ([7435cc33](https://github.com/hyperium/hyper/commit/7435cc3399895643062f4e399fae6d5b20b049a1), closes [#2708](https://github.com/hyperium/hyper/issues/2708))
+
+
+#### Features
+
+* **http2:** add `http2_max_send_buf_size` option to client and server ([bff977b7](https://github.com/hyperium/hyper/commit/bff977b73ca8d737f5492c86c09fd64735c45461))
+* **server:** add HTTP/1 header read timeout option (#2675) ([842c6553](https://github.com/hyperium/hyper/commit/842c6553a5414a3a4a0fbf973079200612a9c3d2), closes [#2457](https://github.com/hyperium/hyper/issues/2457))
+
+
+### v0.14.15 (2021-11-16)
+
+#### Bug Fixes
+
+* **client:** cancel blocking DNS lookup if `GaiFuture` is dropped ([174b553d](https://github.com/hyperium/hyper/commit/174b553d)
+
+#### Features
+
+* **http1:** add `http1_writev(bool)` options to Client and Server builders, to allow forcing vectored writes ([80627141](https://github.com/hyperium/hyper/commit/80627141))
+* **upgrade:** allow http upgrades with any body type ([ab469eb3](https://github.com/hyperium/hyper/commit/ab469eb3c6cd5e7a035d734f3d21ff4d2d6a21ab))
+
+
+### v0.14.14 (2021-10-22)
+
+
+#### Bug Fixes
+
+* **client:**
+  * make ResponseFuture implement Sync ([bd6c35b9](https://github.com/hyperium/hyper/commit/bd6c35b98f9513f14ed9cecad933bc7fdb8635ea))
+  * remove ipv6 square brackets before resolving ([910e0268](https://github.com/hyperium/hyper/commit/910e02687df3245aae4bc519fb0bd7eb6a34db7d))
+
+
+#### Features
+
+* **h2:** always include original h2 error on broken pipe ([6169db25](https://github.com/hyperium/hyper/commit/6169db250c932dd012d391389826cd34833077b4))
+* **server:** Remove Send + Sync requirement for Body in with_graceful_shutdown ([1d553e52](https://github.com/hyperium/hyper/commit/1d553e52c6953ea3b039f5c3f89d35cb56e2436a))
+
+
+### v0.14.13 (2021-09-16)
+
+
+#### Bug Fixes
+
+* **client:** don't reuse a connection while still flushing ([c88011da](https://github.com/hyperium/hyper/commit/c88011da4ed5b5ca9107c4a2339a7ab054c5f27f))
+* **server:** convert panic to error if Connection::without_shutdown called on HTTP/2 conn ([ea3e2282](https://github.com/hyperium/hyper/commit/ea3e228287e714b97aa44c840a487abd3a915e15))
+
+
+#### Features
+
+* **ffi:** add hyper_request_set_uri_parts ([a54689b9](https://github.com/hyperium/hyper/commit/a54689b921ca16dd0f29b3f4a74feae60218db34))
+* **lib:**
+  * Export more things with Cargo features (server, !http1, !http2) ([0a4b56ac](https://github.com/hyperium/hyper/commit/0a4b56acb82ef41a3336f482b240c67c784c434f))
+  * Export rt module independently of Cargo features ([cf6f62c7](https://github.com/hyperium/hyper/commit/cf6f62c71eda3b3a8732d86387e4ed8711cf9a86))
+
+
+### v0.14.12 (2021-08-24)
+
+
+#### Bug Fixes
+
+* **ffi:** on_informational callback had no headers ([39b6d01a](https://github.com/hyperium/hyper/commit/39b6d01aa0e520077bb25e16811f5ece00a224d6))
+* **http1:** apply header title case for consecutive dashes (#2613) ([684f2fa7](https://github.com/hyperium/hyper/commit/684f2fa76d44fa2b1b063ad0443a1b0d16dfad0e))
+* **http2:** improve errors emitted by HTTP2 `Upgraded` stream shutdown (#2622) ([be08648e](https://github.com/hyperium/hyper/commit/be08648e8298cdb13e9879ee761a73f827268962))
+
+
+#### Features
+
+* **client:** expose http09 and http1 options on `client::conn::Builder` (#2611) ([73bff4e9](https://github.com/hyperium/hyper/commit/73bff4e98c372ce04b006370c0b0d2af29ea8718), closes [#2461](https://github.com/hyperium/hyper/issues/2461))
+
+
+### v0.14.11 (2021-07-21)
+
+
+#### Bug Fixes
+
+* **client:** retry when pool checkout returns closed HTTP2 connection (#2585) ([52214f39](https://github.com/hyperium/hyper/commit/52214f391c0a18dc66d1ccff9c0c004c5da85002))
+* **http2:**
+  * improve I/O errors emitted by H2Upgraded (#2598) ([f51c677d](https://github.com/hyperium/hyper/commit/f51c677dec9debf60cb336dc938bae103adf17a0))
+  * preserve `proxy-authenticate` and `proxy-authorization` headers (#2597) ([52435701](https://github.com/hyperium/hyper/commit/5243570137ae49628cb387fff5611eea0add33bf))
+
+
+#### Features
+
+* **ffi:** add hyper_request_on_informational ([25d18c0b](https://github.com/hyperium/hyper/commit/25d18c0b74ccf9e51f986daa3b2b98c0109f827a))
+
+
+### v0.14.10 (2021-07-07)
+
+
+#### Bug Fixes
+
+* **http1:**
+  * reject content-lengths that have a plus sign prefix ([06335158](https://github.com/hyperium/hyper/commit/06335158ca48724db9bf074398067d2db08613e7))
+  * protect against overflow in chunked decoder ([efd9a982](https://github.com/hyperium/hyper/commit/efd9a9821fd2f1ae04b545094de76a435b62e70f))
+
+
+#### Features
+
+* **ffi:** add option to get raw headers from response ([8c89a8c1](https://github.com/hyperium/hyper/commit/8c89a8c1665b6fbec3f13b8c0e84c79464179c89))
+
+
+### v0.14.9 (2021-06-07)
+
+
+#### Bug Fixes
+
+* **http1:** reduce memory used with flatten write strategy ([eb0c6463](https://github.com/hyperium/hyper/commit/eb0c64639503bbd4f6e3b1ce3a02bff8eeea7ee8))
+
+
+### v0.14.8 (2021-05-25)
+
+
+#### Features
+
+* **client:** allow to config http2 max concurrent reset streams (#2535) ([b9916c41](https://github.com/hyperium/hyper/commit/b9916c410182c6225e857f0cded355ea1b74c865))
+* **error:** add `Error::is_parse_too_large` and `Error::is_parse_status` methods (#2538) ([960a69a5](https://github.com/hyperium/hyper/commit/960a69a5878ede82c56f50ac1444a9e75e885a8f))
+* **http2:**
+  * Implement Client and Server CONNECT support over HTTP/2 (#2523) ([5442b6fa](https://github.com/hyperium/hyper/commit/5442b6faddaff9aeb7c073031a3b7aa4497fda4d), closes [#2508](https://github.com/hyperium/hyper/issues/2508))
+  * allow HTTP/2 requests by ALPN when http2_only is unset (#2527) ([be9677a1](https://github.com/hyperium/hyper/commit/be9677a1e782d33c4402772e0fc4ef0a4c49d507))
+
+
+#### Performance
+
+* **http2:** reduce amount of adaptive window pings as BDP stabilizes (#2550) ([4cd06bf2](https://github.com/hyperium/hyper/commit/4cd06bf2))
+
+
+### v0.14.7 (2021-04-22)
+
+
+#### Bug Fixes
+
+* **http1:** http1_title_case_headers should move Builder ([a303b3c3](https://github.com/hyperium/hyper/commit/a303b3c329e6b8ecfa1da0b9b9e94736628167e0))
+
+
+#### Features
+
+* **server:** implement forgotten settings for case preserving ([4fd6c4cb](https://github.com/hyperium/hyper/commit/4fd6c4cb0b58bb0831ae0f876d858aba1588d0e3))
+
+
+### v0.14.6 (2021-04-21)
+
+
+#### Features
+
+* **client:** add option to allow misplaced spaces in HTTP/1 responses (#2506) ([11345394](https://github.com/hyperium/hyper/commit/11345394d968d4817e1a0ee2550228ac0ae7ce74))
+* **http1:** add options to preserve header casing (#2480) ([dbea7716](https://github.com/hyperium/hyper/commit/dbea7716f157896bf7d2d417be7b4e382e7dc34f), closes [#2313](https://github.com/hyperium/hyper/issues/2313))
+
+
+### v0.14.5 (2021-03-26)
+
+
+#### Bug Fixes
+
+* **client:** omit default port from automatic Host headers (#2441) ([0b11eee9](https://github.com/hyperium/hyper/commit/0b11eee9bde421cdc1680cadabfd38c5aff8e62f))
+* **headers:** Support multiple Content-Length values on same line (#2471) ([48fdaf16](https://github.com/hyperium/hyper/commit/48fdaf160689f333e9bb63388d0b1d0fa29a1391), closes [#2470](https://github.com/hyperium/hyper/issues/2470))
+* **server:** skip automatic Content-Length headers when not allowed (#2216) ([8cbf9527](https://github.com/hyperium/hyper/commit/8cbf9527dfb313b3f84fcd83260c5c72ce4a1beb), closes [#2215](https://github.com/hyperium/hyper/issues/2215))
+
+
+#### Features
+
+* **client:** allow HTTP/0.9 responses behind a flag (#2473) ([68d4e4a3](https://github.com/hyperium/hyper/commit/68d4e4a3db91fb43f41a8c4fce1175ddb56816af), closes [#2468](https://github.com/hyperium/hyper/issues/2468))
+* **server:** add `AddrIncoming::from_listener` constructor (#2439) ([4c946af4](https://github.com/hyperium/hyper/commit/4c946af49cc7fbbc6bd4894283a654625c2ea383))
+
+
+### v0.14.4 (2021-02-05)
+
+
+#### Bug Fixes
+
+* **build**: Fix compile error when only `http1` feature was enabled.
+
+
+### v0.14.3 (2021-02-05)
+
+
+#### Bug Fixes
+
+* **client:** HTTP/1 client "Transfer-Encoding" repair code would panic (#2410) ([2c8121f1](https://github.com/hyperium/hyper/commit/2c8121f1735aa8efeb0d5e4ef595363c373ba470), closes [#2409](https://github.com/hyperium/hyper/issues/2409))
+* **http1:** fix server misinterpretting multiple Transfer-Encoding headers ([8f93123e](https://github.com/hyperium/hyper/commit/8f93123efef5c1361086688fe4f34c83c89cec02))
+
+
+#### Features
+
+* **body:**
+  * reexport `hyper::body::SizeHint` (#2404) ([9956587f](https://github.com/hyperium/hyper/commit/9956587f83428a5dbe338ba0b55c1dc0bce8c282))
+  * add `send_trailers` to Body channel's `Sender` (#2387) ([bf8d74ad](https://github.com/hyperium/hyper/commit/bf8d74ad1cf7d0b33b470b1e61625ebac56f9c4c), closes [#2260](https://github.com/hyperium/hyper/issues/2260))
+* **ffi:**
+  * add HYPERE_INVALID_PEER_MESSAGE error code for parse errors ([1928682b](https://github.com/hyperium/hyper/commit/1928682b33f98244435ba6d574677546205a15ec))
+  * Initial C API for hyper ([3ae1581a](https://github.com/hyperium/hyper/commit/3ae1581a539b67363bd87d9d8fc8635a204eec5d))
+
+
+### v0.14.2 (2020-12-29)
+
+
+#### Features
+
+* **client:** expose `connect` types without proto feature (#2377) ([73a59e5f](https://github.com/hyperium/hyper/commit/73a59e5fc7ddedcb7cbd91e97b33385fde57aa10))
+* **server:** expose `Accept` without httpX features (#2382) ([a6d4fcbe](https://github.com/hyperium/hyper/commit/a6d4fcbee65bebf461291def75f4c512ec62a664))
+
+
+### v0.14.1 (2020-12-23)
+
+* Fixes building documentation.
+
+
+## v0.14.0 (2020-12-23)
+
+
+#### Bug Fixes
+
+* **client:** log socket option errors instead of returning error (#2361) ([dad5c879](https://github.com/hyperium/hyper/commit/dad5c8792fec7b586b41b5237bc161d8f0c09f72), closes [#2359](https://github.com/hyperium/hyper/issues/2359))
+* **http1:**
+  * ignore chunked trailers (#2357) ([1dd761c8](https://github.com/hyperium/hyper/commit/1dd761c87de226261599ff2518fe9d231ba1c82d), closes [#2171](https://github.com/hyperium/hyper/issues/2171))
+  * ending close-delimited body should close (#2322) ([71f34024](https://github.com/hyperium/hyper/commit/71f340242120f1ea52c7446b4bae37b894b83912))
+
+
+#### Features
+
+* **client:**
+  * change DNS Resolver to resolve to SocketAddrs (#2346) ([b4e24332](https://github.com/hyperium/hyper/commit/b4e24332a0cd44068a806081d51686f50c086056), closes [#1937](https://github.com/hyperium/hyper/issues/1937))
+  * Make `client` an optional feature ([4e55583d](https://github.com/hyperium/hyper/commit/4e55583d30a597884883f1a51b678f5c57c76765))
+* **http1:** Make HTTP/1 support an optional feature ([2a19ab74](https://github.com/hyperium/hyper/commit/2a19ab74ed69bc776da25544e98979c9fb6e1834))
+* **http2:** Make HTTP/2 support an optional feature ([b819b428](https://github.com/hyperium/hyper/commit/b819b428d314f2203642a015545967601b8e518a))
+* **lib:**
+  * Upgrade to Tokio 1.0, Bytes 1.0, http-body 0.4 (#2369) ([fad42acc](https://github.com/hyperium/hyper/commit/fad42acc79b54ce38adf99c58c894f29fa2665ad), closes [#2370](https://github.com/hyperium/hyper/issues/2370))
+  * remove dependency on `tracing`'s `log` feature (#2342) ([db32e105](https://github.com/hyperium/hyper/commit/db32e1050cf1eae63af0365c97e920f1295b6bea), closes [#2326](https://github.com/hyperium/hyper/issues/2326))
+  * disable all optional features by default (#2336) ([ed2b22a7](https://github.com/hyperium/hyper/commit/ed2b22a7f66899d338691552fbcb6c0f2f4e06b9))
+* **server:** Make the `server` code an optional feature (#2334) ([bdb5e5d6](https://github.com/hyperium/hyper/commit/bdb5e5d6946f4e3f8115a6b1683aff6a04df73de))
+* **upgrade:** Moved HTTP upgrades off `Body` to a new API (#2337) ([121c3313](https://github.com/hyperium/hyper/commit/121c33132c0950aaa422848cdc43f6691ddf5785), closes [#2086](https://github.com/hyperium/hyper/issues/2086))
+
+
+#### Breaking Changes
+
+* hyper depends on `tokio` v1 and `bytes` v1.
+* Custom resolvers used with `HttpConnector` must change
+  to resolving to an iterator of `SocketAddr`s instead of `IpAddr`s.
+ ([b4e24332](https://github.com/hyperium/hyper/commit/b4e24332a0cd44068a806081d51686f50c086056))
+* hyper no longer emits `log` records automatically.
+  If you need hyper to integrate with a `log` logger (as opposed to `tracing`),
+  you can add `tracing = { version = "0.1", features = ["log"] }` to activate them.
+ ([db32e105](https://github.com/hyperium/hyper/commit/db32e1050cf1eae63af0365c97e920f1295b6bea))
+* Removed `http1_writev` methods from `client::Builder`,
+  `client::conn::Builder`, `server::Builder`, and `server::conn::Builder`.
+  
+  Vectored writes are now enabled based on whether the `AsyncWrite`
+  implementation in use supports them, rather than though adaptive
+  detection. To explicitly disable vectored writes, users may wrap the IO
+  in a newtype that implements `AsyncRead` and `AsyncWrite` and returns
+  `false` from its `AsyncWrite::is_write_vectored` method.
+ ([d6aadb83](https://github.com/hyperium/hyper/commit/d6aadb830072959497f414c01bcdba4c8e681088))
+* The method `Body::on_upgrade()` is gone. It is
+  essentially replaced with `hyper::upgrade::on(msg)`.
+ ([121c3313](https://github.com/hyperium/hyper/commit/121c33132c0950aaa422848cdc43f6691ddf5785))
+* All optional features have been disabled by default.
+ ([ed2b22a7](https://github.com/hyperium/hyper/commit/ed2b22a7f66899d338691552fbcb6c0f2f4e06b9))
+* The HTTP server code is now an optional feature. To
+  enable the server, add `features = ["server"]` to the dependency in
+  your `Cargo.toml`.
+ ([bdb5e5d6](https://github.com/hyperium/hyper/commit/bdb5e5d6946f4e3f8115a6b1683aff6a04df73de))
+* The HTTP client of hyper is now an optional feature. To
+  enable the client, add `features = ["client"]` to the dependency in
+  your `Cargo.toml`.
+ ([4e55583d](https://github.com/hyperium/hyper/commit/4e55583d30a597884883f1a51b678f5c57c76765))
+* This puts all HTTP/1 methods and support behind an
+  `http1` cargo feature, which will not be enabled by default. To use
+  HTTP/1, add `features = ["http1"]` to the hyper dependency in your
+  `Cargo.toml`.
+
+ ([2a19ab74](https://github.com/hyperium/hyper/commit/2a19ab74ed69bc776da25544e98979c9fb6e1834))
+* This puts all HTTP/2 methods and support behind an
+  `http2` cargo feature, which will not be enabled by default. To use
+  HTTP/2, add `features = ["http2"]` to the hyper dependency in your
+  `Cargo.toml`.
+
+ ([b819b428](https://github.com/hyperium/hyper/commit/b819b428d314f2203642a015545967601b8e518a))
+
+
+### v0.13.9 (2020-11-02)
+
+
+#### Bug Fixes
+
+* **client:** fix panic when addrs in ConnectingTcpRemote is empty (#2292) ([01103da5](https://github.com/hyperium/hyper/commit/01103da5d9b15e2a7fdc2f1dfec2c23a890d5c16), closes [#2291](https://github.com/hyperium/hyper/issues/2291))
+* **http2:** reschedule keep alive interval timer once a pong is received ([2a938d96](https://github.com/hyperium/hyper/commit/2a938d96aec62603dcb548834676ae2c71ae8be2), closes [#2310](https://github.com/hyperium/hyper/issues/2310))
+
+
+#### Features
+
+* **client:**
+  * add `HttpConnector::set_local_addresses` to set both IPv6 and IPv4 local addrs ( ([fb19f3a8](https://github.com/hyperium/hyper/commit/fb19f3a86997af1c8a31a7d5ce6f2b018c9b5a0d))
+  * Add accessors to `Connected` fields (#2290) ([2dc9768d](https://github.com/hyperium/hyper/commit/2dc9768d2d3884afa20c08b7cd8782c870d925d2))
+
+
+### v0.13.8 (2020-09-18)
+
+
+#### Bug Fixes
+
+* **http1:** return error if user body ends prematurely ([1ecbcbb1](https://github.com/hyperium/hyper/commit/1ecbcbb119e221f60d37b934b81d18493ebded1b), closes [#2263](https://github.com/hyperium/hyper/issues/2263))
+
+
+#### Features
+
+* **lib:** Setting `http1_writev(true)` will now force writev queue usage ([187c22af](https://github.com/hyperium/hyper/commit/187c22afb5a13d4fa9a3b938a1d71b11b337ac97), closes [#2282](https://github.com/hyperium/hyper/issues/2282))
+* **server:** implement `AsRawFd` for `AddrStream` (#2246) ([b5d5e214](https://github.com/hyperium/hyper/commit/b5d5e21449eb613a3c92dcced6f38d227e405594), closes [#2245](https://github.com/hyperium/hyper/issues/2245))
+
+
+### v0.13.7 (2020-07-13)
+
+
+#### Bug Fixes
+
+* **client:** don't panic in DNS resolution when task cancelled (#2229) ([0d0d3635](https://github.com/hyperium/hyper/commit/0d0d3635476ba22e5a2b39b0e4b243f57f1f36d2))
+
+
+#### Features
+
+* **client:** impl tower_service::Service for &Client (#2089) ([77c3b5bc](https://github.com/hyperium/hyper/commit/77c3b5bc0c0d58ecd9f3c004287f65b8a94cc429))
+* **http2:** configure HTTP/2 frame size in the high-level builders too (#2214) ([2354a7ee](https://github.com/hyperium/hyper/commit/2354a7eec352b1f72cd8989d29d73dff211403a1))
+* **lib:** Move from `log` to `tracing` in a backwards-compatible way (#2204) ([9832aef9](https://github.com/hyperium/hyper/commit/9832aef9eeaeff8979354d5de04b8706ff79a233))
+
+
+### v0.13.6 (2020-05-29)
+
+
+#### Features
+
+* **body:** remove Sync bound for Body::wrap_stream ([042c7706](https://github.com/hyperium/hyper/commit/042c770603a212f22387807efe4fc672959df40c))
+* **http2:** allow configuring the HTTP/2 frame size ([b6446456](https://github.com/hyperium/hyper/commit/b64464562a02a642a3cf16ea072f39621da21980))
+
+
+### v0.13.5 (2020-04-17)
+
+
+#### Bug Fixes
+
+* **server:** fix panic in Connection::graceful_shutdown ([fce3ddce](https://github.com/hyperium/hyper/commit/fce3ddce4671e7df439a9d8fdc469b079fc07318))
+
+
+### v0.13.4 (2020-03-20)
+
+
+#### Bug Fixes
+
+* **http1:** try to drain connection buffer if user drops Body ([d838d54f](https://github.com/hyperium/hyper/commit/d838d54fdf0fc4a613612f68274f3520f333dd8e))
+
+
+#### Features
+
+* **http2:** add HTTP2 keep-alive support for client and server ([9a8413d9](https://github.com/hyperium/hyper/commit/9a8413d91081ad5a949276f05337e984c455e251))
+
+
+### v0.13.3 (2020-03-03)
+
+
+#### Features
+
+* **client:** rename `client::Builder` pool options (#2142) ([a82fd6c9](https://github.com/hyperium/hyper/commit/a82fd6c94aa4ce11fe685f9ccfb85c596d596c6e))
+* **http2:** add adaptive window size support using BDP (#2138) ([48102d61](https://github.com/hyperium/hyper/commit/48102d61228b592b466af273a81207e729315681))
+* **server:** add `poll_peek` to `AddrStream` (#2127) ([24d53d3f](https://github.com/hyperium/hyper/commit/24d53d3f66f843a6c19204cc7c52cd80e327d41a))
+
+
+### v0.13.2 (2020-01-29)
+
+
+#### Bug Fixes
+
+* **body:** return exactly 0 SizeHint for empty body (#2122) ([dc882047](https://github.com/hyperium/hyper/commit/dc88204716664d12e20598c78cb87cd44c6f23af))
+* **client:** strip path from Uri before calling Connector (#2109) ([ba2a144f](https://github.com/hyperium/hyper/commit/ba2a144f8b81042247088215425f91760d8694a1))
+* **http1:**
+  * only send `100 Continue` if request body is polled ([c4bb4db5](https://github.com/hyperium/hyper/commit/c4bb4db5c219459b37d796f9aa2b3cdc93325621))
+  * remove panic for HTTP upgrades that have been ignored (#2115) ([1881db63](https://github.com/hyperium/hyper/commit/1881db6391acc949384f8ddfcac8c82a2b133c8d), closes [#2114](https://github.com/hyperium/hyper/issues/2114))
+* **http2:** don't add client content-length if method doesn't require it ([fb90d30c](https://github.com/hyperium/hyper/commit/fb90d30c02d8f7cdc9a643597d5c4ca7a123f3dd))
+
+
+#### Features
+
+* **service:** Implement Clone/Copy on ServiceFn and MakeServiceFn (#2104) ([a5720fab](https://github.com/hyperium/hyper/commit/a5720fab4ced447b8ade43cc1ce8b35442ebf234))
+
+
+### v0.13.1 (2019-12-13)
+
+
+#### Bug Fixes
+
+* **http1:** fix response with non-chunked transfer-encoding to be close-delimited ([cb71d2cd](https://github.com/hyperium/hyper/commit/cb71d2cdbd22e538663e724916dc343430efcf29), closes [#2058](https://github.com/hyperium/hyper/issues/2058))
+
+
+#### Features
+
+* **body:** implement `HttpBody` for `Request` and `Response` ([4b6099c7](https://github.com/hyperium/hyper/commit/4b6099c7aa558e6b1fda146ce6179cb0c67858d7), closes [#2067](https://github.com/hyperium/hyper/issues/2067))
+* **client:** expose `hyper::client::connect::Connect` trait alias ([2553ea1a](https://github.com/hyperium/hyper/commit/2553ea1a7ae3d11f0232a5818949146fa3f68a29))
+
+
+## v0.13.0 (2019-12-10)
+
+
+#### Bug Fixes
+
+* **client:**
+  * fix polling dispatch channel after it has closed ([039281b8](https://github.com/hyperium/hyper/commit/039281b89cf1ab54a0ecc10c5e7fee56d4da0cf4))
+  * fix panic from unreachable code ([e6027bc0](https://github.com/hyperium/hyper/commit/e6027bc02db92d1137c54a26eef2e1cb4d810e25))
+* **dependencies:** require correct bytes minimum version (#1975) ([536b1e18](https://github.com/hyperium/hyper/commit/536b1e184e9704f50716cf10bf9d4e11a79337da))
+* **server:**
+  * change `Builder` window size methods to be by-value ([a22dabd0](https://github.com/hyperium/hyper/commit/a22dabd0935e5471fb6b7e511fc9c585ced0a53a), closes [#1814](https://github.com/hyperium/hyper/issues/1814))
+  * ignore expect-continue with no body in debug mode ([ca5836f1](https://github.com/hyperium/hyper/commit/ca5836f1ece7c4a67172bcbe72745cb49e8951b0), closes [#1843](https://github.com/hyperium/hyper/issues/1843))
+  * Remove unneeded `'static` bound of `Service` on `Connection` (#1971) ([4d147126](https://github.com/hyperium/hyper/commit/4d14712643e4c2ba235a569bb5d9e3099101c1a1))
+
+
+#### Features
+
+* **body:**
+  * change `Sender::send_data` to an `async fn`. ([62a96c07](https://github.com/hyperium/hyper/commit/62a96c077b85792fbf6eb080ec8fec646c47e385))
+  * require `Sync` when wrapping a dynamic `Stream` ([44413721](https://github.com/hyperium/hyper/commit/4441372121e8b278ac773ddd4e408a642dadf2d8))
+  * add `body::aggregate` and `body::to_bytes` functions ([8ba9a8d2](https://github.com/hyperium/hyper/commit/8ba9a8d2c4bab0f44b3f94a326b3b91c82d7877e))
+  * replace `Chunk` type with `Bytes` ([5a598757](https://github.com/hyperium/hyper/commit/5a59875742500672f253719c1e1a16b4eddfacc7), closes [#1931](https://github.com/hyperium/hyper/issues/1931))
+  * replace the `Payload` trait with `HttpBody` ([c63728eb](https://github.com/hyperium/hyper/commit/c63728eb38182ad2f93edd729dbf50f3d5c40479))
+* **client:**
+  * impl tower_service::Service for Client ([edbd10ac](https://github.com/hyperium/hyper/commit/edbd10ac96c5cc6dbeca80ada80f143dbd13d118))
+  * provide tower::Service support for clients (#1915) ([eee2a728](https://github.com/hyperium/hyper/commit/eee2a728797346f8c96c15c5958a05432a4e4453))
+  * change connectors to return an `impl Connection` ([4d7a2266](https://github.com/hyperium/hyper/commit/4d7a2266b88b2c5c92231bcd2bd75d5842198add))
+  * remove `Destination` for `http::Uri` in connectors ([319e8aee](https://github.com/hyperium/hyper/commit/319e8aee1571d8d3639b3259e7a1edb964e6a26c))
+  * filter remote IP addresses by family of given local IP address ([131962c8](https://github.com/hyperium/hyper/commit/131962c86ab0a31c2413261cf4532eca88d67dcb))
+  * change `Resolve` to be `Service<Name>` ([9d9233ce](https://github.com/hyperium/hyper/commit/9d9233ce7ceddb0fa6f5e725b0a781929add3c58), closes [#1903](https://github.com/hyperium/hyper/issues/1903))
+  * change `Connect` trait into an alias for `Service` ([d67e49f1](https://github.com/hyperium/hyper/commit/d67e49f1491327a78f804bab32804dc6c73d2974), closes [#1902](https://github.com/hyperium/hyper/issues/1902))
+  * change `GaiResolver` to use a global blocking threadpool ([049b5132](https://github.com/hyperium/hyper/commit/049b5132dbb6199a32e1795d005003f99d0e0b74))
+  * Add connect timeout to HttpConnector (#1972) ([4179297a](https://github.com/hyperium/hyper/commit/4179297ac9805af8f84d54525e089ff3f19008ab))
+* **lib:**
+  * update to `std::future::Future` ([8f4b05ae](https://github.com/hyperium/hyper/commit/8f4b05ae78567dfc52236bc83d7be7b7fc3eebb0))
+  * add optional `tcp` feature, split from `runtime` ([5b348b82](https://github.com/hyperium/hyper/commit/5b348b821c3f43d8dd71179862190932fcca6a1c))
+  * make `Stream` trait usage optional behind the `stream` feature, enabled by default ([0b03b730](https://github.com/hyperium/hyper/commit/0b03b730531654b1b5f632099386ab27c94eb9f4), closes [#2034](https://github.com/hyperium/hyper/issues/2034))
+  * update Tokio, bytes, http, h2, and http-body ([cb3f39c2](https://github.com/hyperium/hyper/commit/cb3f39c2dc6340060f6b17f354f04c872a947574))
+* **rt:** introduce `rt::Executor` trait ([6ae5889f](https://github.com/hyperium/hyper/commit/6ae5889f8378b6454d4dc620f33bd1678d0e00e4), closes [#1944](https://github.com/hyperium/hyper/issues/1944))
+* **server:**
+  * introduce `Accept` trait ([b3e55062](https://github.com/hyperium/hyper/commit/b3e5506261c33dcaca39a126e891a0b9d5df5eea))
+  * give `Server::local_addr` a more general type ([3cc93e79](https://github.com/hyperium/hyper/commit/3cc93e796aad59b3996fc26b8839a783e0307925))
+  * change `http1_half_close` option default to disabled ([7e31fd88](https://github.com/hyperium/hyper/commit/7e31fd88a86ac032d05670ba4e293e3e5fcccbaf))
+* **service:**
+    * use tower_service::Service for hyper::service ([ec520d56](https://github.com/hyperium/hyper/commit/ec520d5602d819fd92f497cc230df436c1a39eb0))
+  * rename `Service` to `HttpService`, re-export `tower::Service` ([4f274399](https://github.com/hyperium/hyper/commit/4f2743991c227836c3886778512afe1297df3e5b), closes [#1959](https://github.com/hyperium/hyper/issues/1959))
+
+
+#### Breaking Changes
+
+* All usage of async traits (`Future`, `Stream`,
+`AsyncRead`, `AsyncWrite`, etc) are updated to newer versions.
+
+ ([8f4b05ae](https://github.com/hyperium/hyper/commit/8f4b05ae78567dfc52236bc83d7be7b7fc3eebb0))
+* All usage of `hyper::Chunk` should be replaced with
+  `bytes::Bytes` (or `hyper::body::Bytes`).
+
+ ([5a598757](https://github.com/hyperium/hyper/commit/5a59875742500672f253719c1e1a16b4eddfacc7))
+* Using a `Body` as a `Stream`, and constructing one via
+  `Body::wrap_stream`, require enabling the `stream` feature.
+
+ ([511ea388](https://github.com/hyperium/hyper/commit/511ea3889b5cceccb3a42aa72465fe38adef71a4))
+* Calls to `GaiResolver::new` and `HttpConnector::new` no
+  longer should pass an integer argument for the number of threads.
+
+ ([049b5132](https://github.com/hyperium/hyper/commit/049b5132dbb6199a32e1795d005003f99d0e0b74))
+* Connectors no longer return a tuple of
+  `(T, Connected)`, but a single `T: Connection`.
+
+ ([4d7a2266](https://github.com/hyperium/hyper/commit/4d7a2266b88b2c5c92231bcd2bd75d5842198add))
+* All usage of `hyper::client::connect::Destination`
+  should be replaced with `http::Uri`.
+
+ ([319e8aee](https://github.com/hyperium/hyper/commit/319e8aee1571d8d3639b3259e7a1edb964e6a26c))
+* All usage of `hyper::body::Payload` should be replaced
+  with `hyper::body::HttpBody`.
+
+ ([c63728eb](https://github.com/hyperium/hyper/commit/c63728eb38182ad2f93edd729dbf50f3d5c40479))
+* Any type passed to the `executor` builder methods must
+  now implement `hyper::rt::Executor`.
+
+  `hyper::rt::spawn` usage should be replaced with `tokio::task::spawn`.
+
+  `hyper::rt::run` usage should be replaced with `#[tokio::main]` or
+  managing a `tokio::runtime::Runtime` manually.
+
+ ([6ae5889f](https://github.com/hyperium/hyper/commit/6ae5889f8378b6454d4dc620f33bd1678d0e00e4))
+* The `Resolve` trait is gone. All custom resolvers should
+  implement `tower::Service` instead.
+
+  The error type of `HttpConnector` has been changed away from
+  `std::io::Error`.
+
+ ([9d9233ce](https://github.com/hyperium/hyper/commit/9d9233ce7ceddb0fa6f5e725b0a781929add3c58))
+* Any manual implementations of `Connect` must instead
+  implement `tower::Service<Uri>`.
+
+ ([d67e49f1](https://github.com/hyperium/hyper/commit/d67e49f1491327a78f804bab32804dc6c73d2974))
+* The server's behavior will now by default close
+  connections when receiving a read EOF. To allow for clients to close
+  the read half, call `http1_half_close(true)` when configuring a
+  server.
+
+ ([7e31fd88](https://github.com/hyperium/hyper/commit/7e31fd88a86ac032d05670ba4e293e3e5fcccbaf))
+* Passing a `Stream` to `Server::builder` or
+  `Http::serve_incoming` must be changed to pass an `Accept` instead. The
+  `stream` optional feature can be enabled, and then a stream can be
+  converted using `hyper::server::accept::from_stream`.
+
+ ([b3e55062](https://github.com/hyperium/hyper/commit/b3e5506261c33dcaca39a126e891a0b9d5df5eea))
+* Usage of `send_data` should either be changed to
+  async/await or use `try_send_data`.
+
+ ([62a96c07](https://github.com/hyperium/hyper/commit/62a96c077b85792fbf6eb080ec8fec646c47e385))
+
+
+### v0.12.35 (2019-09-13)
+
+
+#### Features
+
+* **body:** identify aborted body write errors ([32869224](https://github.com/hyperium/hyper/commit/3286922460ab63d0a804d8170d862ff4ba5951dd))
+
+
+### v0.12.34 (2019-09-04)
+
+
+#### Bug Fixes
+
+* **client:** allow client GET requests with explicit body headers ([23fc8b08](https://github.com/hyperium/hyper/commit/23fc8b0806e7fde435ca00479cd5e3c8c5bdeee7), closes [#1925](https://github.com/hyperium/hyper/issues/1925))
+
+
+### v0.12.33 (2019-09-04)
+
+
+### v0.12.32 (2019-07-08)
+
+
+#### Features
+
+* **client:** `HttpConnector`: allow to set socket buffer sizes ([386109c4](https://github.com/hyperium/hyper/commit/386109c421c21e6e2d70e76d7dd072ef3bb62c58))
+
+
+### v0.12.31 (2019-06-25)
+
+
+### v0.12.30 (2019-06-14)
+
+
+#### Bug Fixes
+
+* **http1:** force always-ready connections to yield after a few spins ([8316f96d](https://github.com/hyperium/hyper/commit/8316f96d807454b76cde3cc6a7be552c02000529))
+* **http2:** correctly propagate HTTP2 request cancellation ([50198851](https://github.com/hyperium/hyper/commit/50198851a2b1e47c5ad60565eacb712fb3df1ad6))
+
+
+### v0.12.29 (2019-05-16)
+
+
+#### Bug Fixes
+
+* **server:** skip automatic Content-Length header for HTTP 304 responses ([b342c38f](https://github.com/hyperium/hyper/commit/b342c38f08972fe8be4ef9844e30f1e7a121bbc4), closes [#1797](https://github.com/hyperium/hyper/issues/1797))
+
+
+#### Features
+
+* **body:** implement `http_body::Body` for `hyper::Body` ([2d9f3490](https://github.com/hyperium/hyper/commit/2d9f3490aa04393a12854680aa3e6d6117ba2407))
+* **client:** Implement `TryFrom` for `Destination` (#1810) ([d1183a80](https://github.com/hyperium/hyper/commit/d1183a80278decf3955874629e9cff427edecb05), closes [#1808](https://github.com/hyperium/hyper/issues/1808))
+* **server:** add initial window builder methods that take self by-val (#1817) ([8b45af7f](https://github.com/hyperium/hyper/commit/8b45af7f314cea7d1db5cb6990088dd8442aa87b))
+
+
+### v0.12.28 (2019-04-29)
+
+
+#### Bug Fixes
+
+* **client:**
+  * detect HTTP2 connection closures sooner ([e0ec5cad](https://github.com/hyperium/hyper/commit/e0ec5cad9ae3eaa5d9fffeeb636b1363029fcb9c))
+  * fix a rare connection pool race condition ([4133181b](https://github.com/hyperium/hyper/commit/4133181bb20f8d7e990994b2119c590f832a95f1))
+
+
+#### Features
+
+* **server:** impl Sink for Body::Sender ([8d70baca](https://github.com/hyperium/hyper/commit/8d70baca611869c1997571e8513717396b13328b), closes [#1781](https://github.com/hyperium/hyper/issues/1781))
+
+
+### v0.12.27 (2019-04-10)
+
+
+#### Bug Fixes
+
+* **http2:** fix import of h2::Reason to work on 1.26 ([5680d944](https://github.com/hyperium/hyper/commit/5680d9441903d6c8d17c19b3ea1e054af76bb08d))
+
+
+### v0.12.26 (2019-04-09)
+
+
+#### Bug Fixes
+
+* **http2:** send a GOAWAY when the user's Service::poll_ready errors ([42c5efc0](https://github.com/hyperium/hyper/commit/42c5efc085ac71223e4b57d0e1b866e64d41f4e5))
+* **server:** prohibit the length headers on successful CONNECT ([d1501a0f](https://github.com/hyperium/hyper/commit/d1501a0fd3b616d3e42459fc83bdd7ebd01d217e), closes [#1783](https://github.com/hyperium/hyper/issues/1783))
+
+
+#### Features
+
+* **http2:** check `Error::source()` for an HTTP2 error code to send in reset ([fc18b680](https://github.com/hyperium/hyper/commit/fc18b680a5656a0c31bc09c1c70571956a1fd013))
+
+
+### v0.12.25 (2019-03-01)
+
+
+#### Bug Fixes
+
+* **client:** coerce HTTP_2 requests to HTTP_11 ([3a6080b1](https://github.com/hyperium/hyper/commit/3a6080b14abecc29c9aed77be6d60d34a12b368c), closes [#1770](https://github.com/hyperium/hyper/issues/1770))
+* **http2:** send INTERNAL_ERROR when user's Service errors ([8f926a0d](https://github.com/hyperium/hyper/commit/8f926a0daeaf4716cfb2e6db143c524da34421de))
+
+
+#### Features
+
+* **error:** implement `Error::source` when available ([4cf22dfa](https://github.com/hyperium/hyper/commit/4cf22dfa2139f072e0ee937de343a0b0b0a77a22), closes [#1768](https://github.com/hyperium/hyper/issues/1768))
+* **http2:** Add window size config options for Client and Server ([7dcd4618](https://github.com/hyperium/hyper/commit/7dcd4618c059cc76987a32d3acb75e2aaed4419e), closes [#1771](https://github.com/hyperium/hyper/issues/1771))
+* **server:** add `http2_max_concurrent_streams` builder option ([cbae4294](https://github.com/hyperium/hyper/commit/cbae4294c416a64b56f30be7b6494f9934016d1e), closes [#1772](https://github.com/hyperium/hyper/issues/1772))
+* **service:**
+  * add `poll_ready` to `Service` and `MakeService` (#1767) ([0bf30ccc](https://github.com/hyperium/hyper/commit/0bf30ccc68feefb0196d2db9536232e5913598da))
+  * allow `FnMut` with `service_fn` ([877606d5](https://github.com/hyperium/hyper/commit/877606d5c81195374259561aa98b973a00fa6056))
+
+
+### v0.12.24 (2019-02-11)
+
+
+#### Bug Fixes
+
+* **client:** fix panic when CONNECT request doesn't have a port ([d16b2c30](https://github.com/hyperium/hyper/commit/d16b2c30810a2d96ab226997930d953b2fc2626b))
+
+
+#### Features
+
+* **server:**
+  * add `http1_max_buf_size` in the `server::Builder` (#1761) ([3e9782c2](https://github.com/hyperium/hyper/commit/3e9782c2a9501a3122df8a54775a1fa7f2386fea))
+  * add `into_inner` to `AddrStream` (#1762) ([e52f80df](https://github.com/hyperium/hyper/commit/e52f80df5a114844d239561218112a650067f006))
+
+
+### v0.12.23 (2019-01-24)
+
+
+#### Bug Fixes
+
+* **http2:** revert http2 refactor causing a client hang ([9aa7e990](https://github.com/hyperium/hyper/commit/9aa7e99010a1a0f086ade27f99cf4b8da00ae750))
+
+
+#### Features
+
+* **client:** add `conn::Builder::max_buf_size()` ([078ed82d](https://github.com/hyperium/hyper/commit/078ed82dd5fed2f6c4399ff041ef116c712eaaf8), closes [#1748](https://github.com/hyperium/hyper/issues/1748))
+
+
+### v0.12.22 (2019-01-23)
+
+
+#### Bug Fixes
+
+* **client:** parse IPv6 hosts correctly in HttpConnector ([c328c62e](https://github.com/hyperium/hyper/commit/c328c62ec29cd328c1c7331bb316fe4a548f11d7))
+
+
+### v0.12.21 (2019-01-15)
+
+
+#### Features
+
+* **client:**
+  * add `Destination::try_from_uri` constructor ([c809542c](https://github.com/hyperium/hyper/commit/c809542c830c8d542877a22dd54b1c5c679ae433))
+  * Add useful trait impls to Name ([be5ec455](https://github.com/hyperium/hyper/commit/be5ec45571e0b1c6c2b20fe4ab49ef1b0226a004))
+  * add FromStr impl for Name ([607c4da0](https://github.com/hyperium/hyper/commit/607c4da0b96ca430593599c928c882a17a7914d5))
+
+
+### v0.12.20 (2019-01-07)
+
+
+#### Bug Fixes
+
+* **dependencies:** disable unneeded optional tokio features ([e5135dd6](https://github.com/hyperium/hyper/commit/e5135dd6f619b5817e31572c98b45d7c4b34f43a), closes [#1739](https://github.com/hyperium/hyper/issues/1739))
+* **http2:** don't consider an h2 send request error as canceled ([cf034e99](https://github.com/hyperium/hyper/commit/cf034e99fa895fdf4b66edf392f8c7ca366448fd))
+
+
+### v0.12.19 (2018-12-18)
+
+
+#### Bug Fixes
+
+* **rt:** prevent fallback reactor thread from being created accidentally ([1d253b4d](https://github.com/hyperium/hyper/commit/1d253b4d4759e045409fcf140adda7d327a05c8a))
+
+
+### v0.12.18 (2018-12-11)
+
+
+#### Features
+
+* **server:** add `server::conn::AddrIncoming::bind` constructor ([2d5eabde](https://github.com/hyperium/hyper/commit/2d5eabdeed06ea1c88d88dff464929616710ee9a))
+
+
+### v0.12.17 (2018-12-05)
+
+
+#### Features
+
+* **error:** add `Error::is_connect` method ([01f64983](https://github.com/hyperium/hyper/commit/01f64983559602b9ebaaeecf6d33e97a88185676))
+* **server:**
+  * add `tcp_sleep_on_accept_errors` builder method ([a6fff13a](https://github.com/hyperium/hyper/commit/a6fff13a392d3394cacb1215f83bd8ec87671566), closes [#1713](https://github.com/hyperium/hyper/issues/1713))
+  * add `http1_half_close(bool)` option ([73345be6](https://github.com/hyperium/hyper/commit/73345be65f895660492e28e718786b66034a4d03), closes [#1716](https://github.com/hyperium/hyper/issues/1716))
+* **service:** export `hyper::service::MakeServiceRef` ([a522c315](https://github.com/hyperium/hyper/commit/a522c3151abd11795d3263f6607a7caf7c19a585))
+
+#### Performance
+
+* **http1:** implement an adaptive read buffer strategy which helps with throughput and memory management ([fd25129d](https://github.com/hyperium/hyper/commit/fd25129dc0e543538ccbd1794d22014bc187e050), closes [#1708](https://github.com/hyperium/hyper/issues/1708))
+
+### v0.12.16 (2018-11-21)
+
+
+#### Bug Fixes
+
+* **client:** fix connection leak when Response finishes before Request body ([e455fa24](https://github.com/hyperium/hyper/commit/e455fa2452cf45d66de6b4c3dc567e2b5d2368a4), closes [#1717](https://github.com/hyperium/hyper/issues/1717))
+
+
+#### Features
+
+* **client:** add `http1_read_buf_exact_size` Builder option ([2e7250b6](https://github.com/hyperium/hyper/commit/2e7250b6698407b97961b8fcae78696e94d6ea57))
+
+
+### v0.12.15 (2018-11-20)
+
+
+#### Features
+
+* **client:** add client::conn::Builder::executor method ([95446cc3](https://github.com/hyperium/hyper/commit/95446cc338f8055539dd3503c482d649f42a531c))
+* **server:** change `NewService` to `MakeService` with connection context ([30870029](https://github.com/hyperium/hyper/commit/30870029b9eb162f566d8dddd007fb6df9cd69af), closes [#1650](https://github.com/hyperium/hyper/issues/1650))
+
+
+### v0.12.14 (2018-11-07)
+
+
+#### Bug Fixes
+
+* **header:** fix panic when parsing header names larger than 64kb ([9245e940](https://github.com/hyperium/hyper/commit/9245e9409aeb5bb3e31b7f7c0e125583d1318465))
+
+
+#### Features
+
+* **client:** add ALPN h2 support for client connectors ([976a77a6](https://github.com/hyperium/hyper/commit/976a77a67360a2590699c0b2bb3a4c3ccc0ff1ba))
+
+
+### v0.12.13 (2018-10-26)
+
+
+#### Features
+
+* **client:**
+  * add `Resolve`, used by `HttpConnector` ([2d5af177](https://github.com/hyperium/hyper/commit/2d5af177c1f0cfa3f592eec56f3a971fd9770f72), closes [#1517](https://github.com/hyperium/hyper/issues/1517))
+  * adds `HttpInfo` to responses when `HttpConnector` is used ([13d53e1d](https://github.com/hyperium/hyper/commit/13d53e1d0c095a61f64ff1712042aa615122d33d), closes [#1402](https://github.com/hyperium/hyper/issues/1402))
+* **dns:**
+  * export `client::connect::dns` module, and `TokioThreadpoolGaiResolver` type. ([34d780ac](https://github.com/hyperium/hyper/commit/34d780acd0fd7fe6a41b3eca1641791c7a33b366))
+  * tokio_threadpool::blocking resolver ([1e8d6439](https://github.com/hyperium/hyper/commit/1e8d6439cf4f9c7224fe80f0aeee32e2af1adbb0), closes [#1676](https://github.com/hyperium/hyper/issues/1676))
+* **http:** reexport `http` crate ([d55b5efb](https://github.com/hyperium/hyper/commit/d55b5efb890ef04e37825221deae9c57e9e602fa))
+* **server:** allow `!Send` Servers ([ced949cb](https://github.com/hyperium/hyper/commit/ced949cb6b798f25c2ffbdb3ebda6858c18393a7))
+
+
+### v0.12.12 (2018-10-16)
+
+
+#### Bug Fixes
+
+* **armv7:** split record_header_indices loop to work around rustc/LLVM bug ([30a4f237](https://github.com/hyperium/hyper/commit/30a4f2376a392e50ade48685f92e930385ebb68f))
+* **http2:** add Date header if not present for HTTP2 server responses ([37ec724f](https://github.com/hyperium/hyper/commit/37ec724fd6405dd97c5873dddc956df1711b29ab))
+* **server:** log and ignore connection errors on newly accepted sockets ([66a857d8](https://github.com/hyperium/hyper/commit/66a857d801c1fc82d35b6da2d27441aa046aae47))
+
+
+### v0.12.11 (2018-09-28)
+
+
+#### Bug Fixes
+
+* **client:** allow calling `Destination::set_host` with IPv6 addresses ([af5e4f3e](https://github.com/hyperium/hyper/commit/af5e4f3ec24a490e209e3e73f86207b63ce7191a), closes [#1661](https://github.com/hyperium/hyper/issues/1661))
+* **server:** use provided executor if fallback to HTTP2 ([1370a6f8](https://github.com/hyperium/hyper/commit/1370a6f8f06f9906ff75dec904ab9c6d763e37f0))
+
+
+### v0.12.10 (2018-09-14)
+
+
+#### Bug Fixes
+
+* **http1:** fix title-case option when header names have symbols ([ca5e520e](https://github.com/hyperium/hyper/commit/ca5e520e7aa6d0a211e3c152c09095d35326ca12))
+
+
+### v0.12.9 (2018-08-28)
+
+
+#### Bug Fixes
+
+* **http2:** allow TE "trailers" request headers ([24f11a42](https://github.com/hyperium/hyper/commit/24f11a421d8422714bf023a602d7718b885a39a0), closes [#1642](https://github.com/hyperium/hyper/issues/1642))
+* **server:** properly handle keep-alive for HTTP/1.0 ([1448e406](https://github.com/hyperium/hyper/commit/1448e4067b10da6fe4584921314afc1f5f4e3c8d), closes [#1614](https://github.com/hyperium/hyper/issues/1614))
+
+
+#### Features
+
+* **client:** add `max_idle_per_host` configuration option ([a3c44ded](https://github.com/hyperium/hyper/commit/a3c44ded556b7ef9487ec48cf42fa948d64f5a83))
+* **server:** add `Server::with_graceful_shutdown` method ([168c7d21](https://github.com/hyperium/hyper/commit/168c7d2155952ba09f781c331fd67593b820af20), closes [#1575](https://github.com/hyperium/hyper/issues/1575))
+
+
+### v0.12.8 (2018-08-10)
+
+
+#### Bug Fixes
+
+* **server:** coerce responses with HTTP2 version to HTTP/1.1 when protocol is 1.x ([195fbb2a](https://github.com/hyperium/hyper/commit/195fbb2a3728460e7f7eca2035461ce055db6cd0))
+
+
+#### Features
+
+* **server:**
+  * add Builder::http1_keepalive method ([b459adb4](https://github.com/hyperium/hyper/commit/b459adb43a753ba082f1fc03c90ff4e76625666f))
+  * add `Server::from_tcp` constructor ([bb4c5e24](https://github.com/hyperium/hyper/commit/bb4c5e24c846995b66e361d1c2446cb81984bbbd), closes [#1602](https://github.com/hyperium/hyper/issues/1602))
+  * add remote_addr method to AddrStream ([26f3a5ed](https://github.com/hyperium/hyper/commit/26f3a5ed317330db39dd33f49bafd859bc867d8a))
+
+
+### v0.12.7 (2018-07-23)
+
+
+#### Bug Fixes
+
+* **http1:** reduce closed connections when body is dropped ([6530a00a](https://github.com/hyperium/hyper/commit/6530a00a8e3449a8fd7e4ed6ad1231b6b1579c38))
+
+
+### v0.12.6 (2018-07-11)
+
+
+#### Features
+
+* **client:**
+  * add ability to include `SO_REUSEADDR` option on sockets ([13862d11](https://github.com/hyperium/hyper/commit/13862d11ad329e5198622ad3e924e1aa05ab2c8a), closes [#1599](https://github.com/hyperium/hyper/issues/1599))
+  * implement rfc 6555 (happy eyeballs) ([02a9c29e](https://github.com/hyperium/hyper/commit/02a9c29e2e816c8a583f65b372fcf7b8503e6bad))
+* **server:** add `Builder::http1_pipeline_flush` configuration ([5b5e3090](https://github.com/hyperium/hyper/commit/5b5e3090955c1b6c1e7a8cb97b43de8d099f5303))
+
+
+### v0.12.5 (2018-06-28)
+
+
+### v0.12.4 (2018-06-28)
+
+
+#### Bug Fixes
+
+* **client:**
+  * fix keep-alive header detection when parsing responses ([c03c39e0](https://github.com/hyperium/hyper/commit/c03c39e0ffca94bce265db92281a50b2abae6f2b))
+  * try to reuse connections when pool checkout wins ([f2d464ac](https://github.com/hyperium/hyper/commit/f2d464ac79b47f988bffc826b80cf7d107f80694))
+
+
+### v0.12.3 (2018-06-25)
+
+
+#### Features
+
+* **client:** enable CONNECT requests through the `Client` ([2a3844ac](https://github.com/hyperium/hyper/commit/2a3844acc393d42ff1b75f798dcc321a20956bea))
+* **http2:** quickly cancel when receiving RST_STREAM ([ffdb4788](https://github.com/hyperium/hyper/commit/ffdb47883190a8889cf30b716294383392a763c5))
+
+
+### v0.12.2 (2018-06-19)
+
+
+#### Bug Fixes
+
+* **http2:**
+  * implement `graceful_shutdown` for HTTP2 server connections ([b7a0c2d5](https://github.com/hyperium/hyper/commit/b7a0c2d5967d9ca22bd5e031166876c81ae80606), closes [#1550](https://github.com/hyperium/hyper/issues/1550))
+  * send trailers if Payload includes them ([3affe2a0](https://github.com/hyperium/hyper/commit/3affe2a0af445a01acb75181b16e71eb9fef4ae2))
+* **lib:** return an error instead of panic if execute fails ([482a5f58](https://github.com/hyperium/hyper/commit/482a5f589ea2bdb798f01645653975089f40ef44), closes [#1566](https://github.com/hyperium/hyper/issues/1566))
+* **server:**
+  * fix debug assert failure when kept-alive connections see a parse error ([396fe80e](https://github.com/hyperium/hyper/commit/396fe80e76840dea9373ca448b20cf7a9babd2f8))
+  * correctly handle CONNECT requests ([d7ab0166](https://github.com/hyperium/hyper/commit/d7ab01667659290784bfe685951c83a6f69e415e))
+
+
+#### Features
+
+* **body:**
+  * make `Body` know about incoming `Content-Length` ([a0a0fcdd](https://github.com/hyperium/hyper/commit/a0a0fcdd9b126ee2c0810b2839c7ab847f5788ad), closes [#1545](https://github.com/hyperium/hyper/issues/1545))
+  * add `Sender::abort` ([a096799c](https://github.com/hyperium/hyper/commit/a096799c1b4581ce1a47ed0817069997a9031828))
+* **client:** add `set_scheme`, `set_host`, and `set_port` for `Destination` ([27db8b00](https://github.com/hyperium/hyper/commit/27db8b0061f85d89ec94e07295463e8d1030d94f), closes [#1564](https://github.com/hyperium/hyper/issues/1564))
+* **error:** add `Error::cause2` and `Error::into_cause` ([bc5e22f5](https://github.com/hyperium/hyper/commit/bc5e22f58095f294333f49f12eeb7e504cda666c), closes [#1542](https://github.com/hyperium/hyper/issues/1542))
+* **http1:** Add higher-level HTTP upgrade support to Client and Server (#1563) ([fea29b29](https://github.com/hyperium/hyper/commit/fea29b29e2bbbba10760917a234a8cf4a6133be4), closes [#1395](https://github.com/hyperium/hyper/issues/1395))
+* **http2:**
+  * implement flow control for h2 bodies ([1c3fbfd6](https://github.com/hyperium/hyper/commit/1c3fbfd6bf6b627f75ef694e69c8074745276e9b), closes [#1548](https://github.com/hyperium/hyper/issues/1548))
+  * Add `content_length()` value to incoming h2 `Body` ([9a28268b](https://github.com/hyperium/hyper/commit/9a28268b98f30fd25e862b4a182a853a9a6e1841), closes [#1546](https://github.com/hyperium/hyper/issues/1546))
+  * set Content-Length header on outgoing messages ([386fc0d7](https://github.com/hyperium/hyper/commit/386fc0d70b70d36ac44ec5562cd26babdfd46fc9), closes [#1547](https://github.com/hyperium/hyper/issues/1547))
+  * Strip connection headers before sending ([f20afba5](https://github.com/hyperium/hyper/commit/f20afba57d6fabb04085968342e5fd62b45bc8df))
+
+
+### v0.12.1 (2018-06-04)
+
+
+#### Bug Fixes
+
+* **server:** add upgrading process to `poll_without_shutdown()` (#1530) ([c6e90b7b](https://github.com/hyperium/hyper/commit/c6e90b7b6509276c744b531f8b1f7b043059c4ec))
+
+
+#### Features
+
+* **client:** implement `Clone` for `Destination` ([15188b7c](https://github.com/hyperium/hyper/commit/15188b7c7fc6774301a16923127df596486cc913))
+* **server:**
+  * add `http1_writev` config option for servers ([810435f1](https://github.com/hyperium/hyper/commit/810435f1469eb028c6a819368d63edb54d6c341c), closes [#1527](https://github.com/hyperium/hyper/issues/1527))
+  * add `http1_only` configuration ([14d9246d](https://github.com/hyperium/hyper/commit/14d9246de2e97908c915caf254a37fd62edb25d3), closes [#1512](https://github.com/hyperium/hyper/issues/1512))
+  * add `try_into_parts()` to `conn::Connection` (#1531) ([c615a324](https://github.com/hyperium/hyper/commit/c615a3242f2518bc8acf05116ebe87ea98773c28))
+
+
+## v0.12.0 (2018-06-01)
+
+#### Features
+
+* **lib:**
+  * add HTTP/2 support for Client and Server ([c119097f](https://github.com/hyperium/hyper/commit/c119097fd072db51751b100fa186b6f64785954d))
+  * convert to use tokio 0.1 ([27b8db3a](https://github.com/hyperium/hyper/commit/27b8db3af8852ba8280a2868f703d3230a1db85e))
+  * replace types with those from `http` crate ([3cd48b45](https://github.com/hyperium/hyper/commit/3cd48b45fb622fb9e69ba773e7f92b9d3e9ac018))
+* **body:**
+  * remove `Body::is_empty()` ([19f90242](https://github.com/hyperium/hyper/commit/19f90242f8a3768b2d8d4bff4044a2d6c77d40aa))
+  * change `Payload::Data` to be a `Buf` ([a3be110a](https://github.com/hyperium/hyper/commit/a3be110a55571a1ee9a31b2335d7aec27c04e96a), closes [#1508](https://github.com/hyperium/hyper/issues/1508))
+  * add `From<Box<Stream>>` impl for `Body` ([45efba27](https://github.com/hyperium/hyper/commit/45efba27df90650bf4669738102ad6e432ddc75d))
+  * introduce a `Payload` trait to represent bodies ([fbc449e4](https://github.com/hyperium/hyper/commit/fbc449e49cc4a4f8319647dccfb288d3d83df2bd), closes [#1438](https://github.com/hyperium/hyper/issues/1438))
+* **client:**
+  * rename `FutureResponse` to `ResponseFuture` ([04c74ef5](https://github.com/hyperium/hyper/commit/04c74ef596eb313b785ecad6c42c0375ddbb1e96))
+  * support local bind for `HttpConnector` ([b6a3c85d](https://github.com/hyperium/hyper/commit/b6a3c85d0f9ede10759dc2309502e88ea3e513f7), closes [#1498](https://github.com/hyperium/hyper/issues/1498))
+  * add support for title case header names (#1497) ([a02fec8c](https://github.com/hyperium/hyper/commit/a02fec8c7898792cbeadde7e0f5bf111d55dd335), closes [#1492](https://github.com/hyperium/hyper/issues/1492))
+  * add support to set `SO_NODELAY` on client HTTP sockets ([016d79ed](https://github.com/hyperium/hyper/commit/016d79ed2633e3f939a2cd10454cbfc5882effb4), closes [#1473](https://github.com/hyperium/hyper/issues/1473))
+  * improve construction of `Client`s ([fe1578ac](https://github.com/hyperium/hyper/commit/fe1578acf628844d7cccb3e896c5e0bb2a0be729))
+  * redesign the `Connect` trait ([8c52c2df](https://github.com/hyperium/hyper/commit/8c52c2dfd342e798420a0b83cde7d54f3af5e351), closes [#1428](https://github.com/hyperium/hyper/issues/1428))
+* **error:** revamp `hyper::Error` type ([5d3c4722](https://github.com/hyperium/hyper/commit/5d3c472228d40b57e47ea26004b3710cfdd451f3), closes [#1128](https://github.com/hyperium/hyper/issues/1128), [#1130](https://github.com/hyperium/hyper/issues/1130), [#1431](https://github.com/hyperium/hyper/issues/1431), [#1338](https://github.com/hyperium/hyper/issues/1338))
+* **rt:** make tokio runtime optional ([d127201e](https://github.com/hyperium/hyper/commit/d127201ef22b10ab1d84b3f2215863eb2d03bfcb))
+* **server:**
+  * support HTTP1 and HTTP2 automatically ([bc6af88a](https://github.com/hyperium/hyper/commit/bc6af88a32e29e5a4f3719d8abc664f9ab10dddd), closes [#1486](https://github.com/hyperium/hyper/issues/1486))
+  * re-design `Server` as higher-level API ([c4974500](https://github.com/hyperium/hyper/commit/c4974500abee45b95b0b54109cad15978ef8ced9), closes [#1322](https://github.com/hyperium/hyper/issues/1322), [#1263](https://github.com/hyperium/hyper/issues/1263))
+* **service:** introduce hyper-specific `Service` ([2dc6202f](https://github.com/hyperium/hyper/commit/2dc6202fe7294fa74cf1ba58a45e48b8a927934f), closes [#1461](https://github.com/hyperium/hyper/issues/1461))
+
+#### Bug Fixes
+
+* **lib:** remove deprecated tokio-proto APIs ([a37e6b59](https://github.com/hyperium/hyper/commit/a37e6b59e6d6936ee31c6d52939869933c709c78))
+* **server:** panic on max_buf_size too small ([aac250f2](https://github.com/hyperium/hyper/commit/aac250f29d3b05d8c07681a407825811ec6a0b56))
+
+#### Breaking Changes
+
+* `Body::is_empty()` is gone. Replace with
+  `Body::is_end_stream()`, from the `Payload` trait.
+
+  ([19f90242](https://github.com/hyperium/hyper/commit/19f90242f8a3768b2d8d4bff4044a2d6c77d40aa))
+* Each payload chunk must implement `Buf`, instead of
+  just `AsRef<[u8]>`.
+
+  ([a3be110a](https://github.com/hyperium/hyper/commit/a3be110a55571a1ee9a31b2335d7aec27c04e96a))
+* Replace any references of
+  `hyper::client::FutureResponse` to `hyper::client::ResponseFuture`.
+
+  ([04c74ef5](https://github.com/hyperium/hyper/commit/04c74ef596eb313b785ecad6c42c0375ddbb1e96))
+* The `Service` trait has changed: it has some changed
+  associated types, and `call` is now bound to `&mut self`.
+
+  The `NewService` trait has changed: it has some changed associated
+  types, and `new_service` now returns a `Future`.
+
+  `Client` no longer implements `Service` for now.
+
+  `hyper::server::conn::Serve` now returns `Connecting` instead of
+  `Connection`s, since `new_service` can now return a `Future`. The
+  `Connecting` is a future wrapping the new service future, returning
+  a `Connection` afterwards. In many cases, `Future::flatten` can be
+  used.
+
+  ([2dc6202f](https://github.com/hyperium/hyper/commit/2dc6202fe7294fa74cf1ba58a45e48b8a927934f))
+* The `Server` is no longer created from `Http::bind`,
+  nor is it `run`. It is a `Future` that must be polled by an
+  `Executor`.
+
+  The `hyper::server::Http` type has move to
+  `hyper::server::conn::Http`.
+
+  ([c4974500](https://github.com/hyperium/hyper/commit/c4974500abee45b95b0b54109cad15978ef8ced9))
+* `Client:new(&handle)` and `Client::configure()` are now
+  `Client::new()` and `Client::builder()`.
+
+  ([fe1578ac](https://github.com/hyperium/hyper/commit/fe1578acf628844d7cccb3e896c5e0bb2a0be729))
+* `Error` is no longer an enum to pattern match over, or
+  to construct. Code will need to be updated accordingly.
+
+  For body streams or `Service`s, inference might be unable to determine
+  what error type you mean to return.
+
+  ([5d3c4722](https://github.com/hyperium/hyper/commit/5d3c472228d40b57e47ea26004b3710cfdd451f3))
+* All uses of `Handle` now need to be new-tokio `Handle`.
+
+  ([27b8db3a](https://github.com/hyperium/hyper/commit/27b8db3af8852ba8280a2868f703d3230a1db85e))
+* Custom connectors should now implement `Connect`
+  directly, instead of `Service`.
+
+  Calls to `connect` no longer take `Uri`s, but `Destination`. There
+  are `scheme`, `host`, and `port` methods to query relevant
+  information.
+
+  The returned future must be a tuple of the transport and `Connected`.
+  If no relevant extra information is needed, simply return
+  `Connected::new()`.
+
+  ([8c52c2df](https://github.com/hyperium/hyper/commit/8c52c2dfd342e798420a0b83cde7d54f3af5e351))
+* All code that was generic over the body as `Stream` must
+  be adjusted to use a `Payload` instead.
+
+  `hyper::Body` can still be used as a `Stream`.
+
+  Passing a custom `impl Stream` will need to either implement
+  `Payload`, or as an easier option, switch to `Body::wrap_stream`.
+
+  `Body::pair` has been replaced with `Body::channel`, which returns a
+  `hyper::body::Sender` instead of a `futures::sync::mpsc::Sender`.
+
+  ([fbc449e4](https://github.com/hyperium/hyper/commit/fbc449e49cc4a4f8319647dccfb288d3d83df2bd))
+* `Method`, `Request`, `Response`, `StatusCode`,
+  `Version`, and `Uri` have been replaced with types from the `http`
+  crate.
+
+  ([3cd48b45](https://github.com/hyperium/hyper/commit/3cd48b45fb622fb9e69ba773e7f92b9d3e9ac018))
+  * The variants of `Method` are now uppercase, for instance, `Method::Get` is now `Method::GET`.
+  * The variants of `StatusCode` are now uppercase, for instance, `StatusCode::Ok` is now `StatusCode::OK`.
+  * The variants of `Version` are now uppercase, for instance, `HttpVersion::Http11` is now `Version::HTTP_11`.
+*  The typed headers from `hyper::header` are gone for now.
+
+  The `http::header` module is re-exported as `hyper::header`.
+
+  For example, a before setting the content-length:
+
+  ```rust
+  use hyper::header::ContentLength;
+  res.headers_mut().set(ContentLength(15));
+  ```
+
+  And now **after**, with the `http` types:
+
+  ```rust
+  use hyper::header::{CONTENT_LENGTH, HeaderValue};
+  res.headers_mut().insert(CONTENT_LENGTH, HeaderValue::from_static("15"));
+  ```
+
+  ([3cd48b45](https://github.com/hyperium/hyper/commit/3cd48b45fb622fb9e69ba773e7f92b9d3e9ac018))
+* The `mime` crate is no longer re-exported as `hyper::mime`.
+
+  The typed headers don't exist, and so they do not need the `mime` crate.
+
+  To continue using `mime` for other purposes, add it directly to your `Cargo.toml`
+  as a dependency.
+
+  ([3cd48b45](https://github.com/hyperium/hyper/commit/3cd48b45fb622fb9e69ba773e7f92b9d3e9ac018))
+* Removed `compat` cargo feature, and `compat` related API. This was the conversion methods for hyper's
+  types to and from `http` crate's types.
+
+  ([3cd48b45](https://github.com/hyperium/hyper/commit/3cd48b45fb622fb9e69ba773e7f92b9d3e9ac018))
+* Removed deprecated APIs:
+  ([a37e6b59](https://github.com/hyperium/hyper/commit/a37e6b59e6d6936ee31c6d52939869933c709c78))
+  * The `server-proto` cargo feature, which included `impl ServerProto for Http`, and related associated types.
+  * `client::Config::no_proto()`
+  * `tokio_proto::streaming::Body::from(hyper::Body)`
+  * `hyper::Body::from(tokio_proto::streaming::Body)`
+  * `hyper::Body::from(futures::sync::mpsc::Receiver)`
+  * `Http::no_proto()`
+
+
+### v0.11.27 (2018-05-16)
+
+
+#### Bug Fixes
+
+* **client:** prevent pool checkout looping on not-ready connections ([ccec79da](https://github.com/hyperium/hyper/commit/ccec79dadc84f1e9fced9159189d9f8caa6e17a4), closes [#1519](https://github.com/hyperium/hyper/issues/1519))
+* **server:** skip SO_REUSEPORT errors ([2c48101a](https://github.com/hyperium/hyper/commit/2c48101a6ee1269d7c94a0c3e606b2d635b20615), closes [#1509](https://github.com/hyperium/hyper/issues/1509))
+
+
+### v0.11.26 (2018-05-05)
+
+
+#### Features
+
+* **server:** add Server::run_threads to run on multiple threads ([8b644c1a](https://github.com/hyperium/hyper/commit/8b644c1a2a1a629be9b263d8fae5963a61af91cd))
+
+
+### v0.11.25 (2018-04-04)
+
+
+#### Bug Fixes
+
+* **client:** ensure idle connection is pooled before response body finishes ([7fe9710a](https://github.com/hyperium/hyper/commit/7fe9710a98650efc37f35bb21b19926c015f0631))
+
+
+### v0.11.24 (2018-03-22)
+
+
+#### Bug Fixes
+
+* **header:** remove charset=utf8 from `ContentType::text()` ([ba789e65](https://github.com/hyperium/hyper/commit/ba789e6552eb74afb98f4d462d5c06c6643535d3))
+
+
+### v0.11.23 (2018-03-22)
+
+
+#### Bug Fixes
+
+* **server:** prevent to output Transfer-encoding when server upgrade (#1465) ([eb105679](https://github.com/hyperium/hyper/commit/eb105679271a6e0ccc09f37978314a1a8d686217))
+
+
+#### Features
+
+* **client:** introduce lower-level Connection API ([1207c2b6](https://github.com/hyperium/hyper/commit/1207c2b62456fc729c3a29c56c3966b319b474a9), closes [#1449](https://github.com/hyperium/hyper/issues/1449))
+* **header:** add `text()` and `text_utf8()` constructors to `ContentType` ([45cf8c57](https://github.com/hyperium/hyper/commit/45cf8c57c932a2756365748dc1e598ad3ee4b8ef))
+* **server:**
+  * add `service` property to `server::conn::Parts` ([bf7c0bbf](https://github.com/hyperium/hyper/commit/bf7c0bbf4f55fdf465407874b0b2d4bd748e6783), closes [#1471](https://github.com/hyperium/hyper/issues/1471))
+    * add upgrade support to lower-level Connection API (#1459) ([d58aa732](https://github.com/hyperium/hyper/commit/d58aa73246112f69410cc3fe912622f284427067), closes [#1323](https://github.com/hyperium/hyper/issues/1323))
+
+
+### v0.11.22 (2018-03-07)
+
+
+#### Bug Fixes
+
+* **client:** return error if Request has `CONNECT` method ([bfcdbd9f](https://github.com/hyperium/hyper/commit/bfcdbd9f86480cf6531544ecca247562a18172af))
+* **dependencies:** require tokio-core 0.1.11 ([49fcb066](https://github.com/hyperium/hyper/commit/49fcb0663cc30bbfc82cfc3c8e42d539211a3f3f))
+
+
+#### Features
+
+* **client:** add `Config::set_host` option ([33a385c6](https://github.com/hyperium/hyper/commit/33a385c6b677cce4ece2843c11ac78711fd5b898))
+
+
+### v0.11.21 (2018-02-28)
+
+
+#### Bug Fixes
+
+* **client:**
+  * check conn is closed in expire interval ([2fa0c845](https://github.com/hyperium/hyper/commit/2fa0c845b5f3f07e039522a9112a14593e02fe1b))
+  * schedule interval to clear expired idle connections ([727b7479](https://github.com/hyperium/hyper/commit/727b74797e5754af8abba8812a876c3c8fda6d94))
+  * never call connect if idle connection is available ([13741f51](https://github.com/hyperium/hyper/commit/13741f5145eb3dc894d2bc8d8486fc51c29e2e41))
+
+
+### v0.11.20 (2018-02-26)
+
+
+#### Bug Fixes
+
+* **server:**
+  * Make sleep_on_errors configurable and use it in example ([3a36eb55](https://github.com/hyperium/hyper/commit/3a36eb559676349d8a321c3159684503014f7fbe))
+  * Sleep on socket IO errors ([68458cde](https://github.com/hyperium/hyper/commit/68458cde57a20f4b3c9c306eaf9801189262e0a6))
+
+
+#### Features
+
+* **body:** add `Body::is_empty()` method ([2f45d539](https://github.com/hyperium/hyper/commit/2f45d5394a2f8a49442ff4798a4b1651c079f0ff))
+* **request:** add `Request::body_mut()` method ([3fa191a2](https://github.com/hyperium/hyper/commit/3fa191a2676feb86c91abf8dfcc8e63477980297))
+
+
+### v0.11.19 (2018-02-21)
+
+
+#### Bug Fixes
+
+* **client:**
+  * prevent empty bodies sending transfer-encoding for GET, HEAD ([77adab4e](https://github.com/hyperium/hyper/commit/77adab4ebf0fadd9ccd014d24ff0bcec1bce1e8b))
+  * detect connection closes as pool tries to use ([dc619a8f](https://github.com/hyperium/hyper/commit/dc619a8fa01616b260ef32a35b35963460987206), closes [#1439](https://github.com/hyperium/hyper/issues/1439))
+* **uri:** make absolute-form uris always have a path ([a9413d73](https://github.com/hyperium/hyper/commit/a9413d7367e8b9f0245fc8a90a22ece7d55e7e04))
+
+
+#### Features
+
+* **client:** Client will retry requests on fresh connections ([ee61ea9a](https://github.com/hyperium/hyper/commit/ee61ea9adf86b309490a68d044e40bd1090338e8))
+
+
+### v0.11.18 (2018-02-07)
+
+
+#### Bug Fixes
+
+* **client:** send an `Error::Cancel` if a queued request is dropped ([88f01793](https://github.com/hyperium/hyper/commit/88f01793bec5830370cb88f74a64a2e20a440c17))
+
+
+#### Features
+
+* **client:** add `http1_writev` configuration option ([b0aa6497](https://github.com/hyperium/hyper/commit/b0aa6497258c20354ae0fe36d668e0c2361b3151))
+
+
+### v0.11.17 (2018-02-05)
+
+
+#### Bug Fixes
+
+* **client:** more reliably detect closed pooled connections (#1434) ([265ad67c](https://github.com/hyperium/hyper/commit/265ad67c86379841a5aa821543a01648ccc8c26c))
+* **h1:** fix hung streaming bodies over HTTPS ([73109694](https://github.com/hyperium/hyper/commit/731096947d0704de58b75d17e05af956bcb21bd9))
+
+
+### v0.11.16 (2018-01-30)
+
+
+#### Bug Fixes
+
+* **client:**
+  * check for dead connections in Pool ([44af2738](https://github.com/hyperium/hyper/commit/44af273853f82b81591b813d13627e143a14a6b7), closes [#1429](https://github.com/hyperium/hyper/issues/1429))
+  * error on unsupport 101 responses, ignore other 1xx codes ([22774222](https://github.com/hyperium/hyper/commit/227742221fa7830a14c18becbbc6137d97b57729))
+* **server:**
+  * send 400 responses on parse errors before closing connection ([7cb72d20](https://github.com/hyperium/hyper/commit/7cb72d2019bffbc667b9ad2d8cbc19c1a513fcf7))
+  * error if Response code is 1xx ([44c34ce9](https://github.com/hyperium/hyper/commit/44c34ce9adc888916bd67656cc54c35f7908f536))
+
+
+#### Features
+
+* **server:** add `Http::max_buf_size()` option ([d22deb65](https://github.com/hyperium/hyper/commit/d22deb6572c279e11773b6bcb862415c08f19c2e), closes [#1368](https://github.com/hyperium/hyper/issues/1368))
+* **uri:** Add a `PartialEq<str>` impl for `Uri` ([11b49c2c](https://github.com/hyperium/hyper/commit/11b49c2cc84695e966e9d9a0b05781853b28d7a8))
+
+#### Performance
+
+- **h1:** utilize `writev` when possible, reducing copies ([68377ede](https://github.com/hyperium/hyper/commit/68377ede))
+
+### v0.11.15 (2018-01-22)
+
+
+#### Bug Fixes
+
+* **lib:** properly handle HTTP/1.0 remotes ([36e66a50](https://github.com/hyperium/hyper/commit/36e66a50546347c6f9b74c6d3c26e8b910483a4b), closes [#1304](https://github.com/hyperium/hyper/issues/1304))
+
+
+#### Features
+
+* **client:** add `executor` method when configuring a `Client` ([c89019eb](https://github.com/hyperium/hyper/commit/c89019eb100d00b5235d3b9a0d0b672ab0ef8ddc))
+
+
+### v0.11.14 (2018-01-16)
+
+
+#### Bug Fixes
+
+* **tokio-proto:** return end-of-body frame correctly for tokio-proto ([14e4c741](https://github.com/hyperium/hyper/commit/14e4c741dc48a386d7bdc6f8e9e279e60f172722), closes [#1414](https://github.com/hyperium/hyper/issues/1414))
+
+
+### v0.11.13 (2018-01-12)
+
+
+#### Bug Fixes
+
+* **client:**
+  * change connection errors to debug log level ([2fe90f25](https://github.com/hyperium/hyper/commit/2fe90f256420ff668966290ac96686ce061453e4), closes [#1412](https://github.com/hyperium/hyper/issues/1412))
+  * don't error on read before writing request ([7976023b](https://github.com/hyperium/hyper/commit/7976023b594ec6784e40a147d3baec99a947b118))
+* **lib:** properly handle body streaming errors ([7a48d0e8](https://github.com/hyperium/hyper/commit/7a48d0e8b4ad465c0205ddfb116b6bd60dbdec71))
+
+
+### v0.11.12 (2018-01-08)
+
+
+#### Bug Fixes
+
+* **server:** add remote_addr back to Request when using Http::bind ([fa7f4377](https://github.com/hyperium/hyper/commit/fa7f4377c1d783ca860820aefc41d0eab73be14c), closes [#1410](https://github.com/hyperium/hyper/issues/1410))
+
+
+### v0.11.11 (2018-01-05)
+
+
+#### Features
+
+* **client:** replace default dispatcher ([0892cb27](https://github.com/hyperium/hyper/commit/0892cb27777858737449a012bc6ea08ee080e5b7))
+* **server:** change default dispatcher ([6ade21aa](https://github.com/hyperium/hyper/commit/6ade21aa7f16dfeb6c0c53fe39c3f168f5f8aec1))
+
+
+### v0.11.10 (2017-12-26)
+
+
+#### Bug Fixes
+
+* **client:**
+  * fix panic when request body is empty string ([bfb0f84d](https://github.com/hyperium/hyper/commit/bfb0f84d372ec4251a20d16a1ac514a4177e2a3b))
+  * close connections when Response Future or Body is dropped ([ef400812](https://github.com/hyperium/hyper/commit/ef4008121e4faa9383fe4661ebd05de5efe7ee9c), closes [#1397](https://github.com/hyperium/hyper/issues/1397))
+  * properly close idle connections after timeout ([139dc7ab](https://github.com/hyperium/hyper/commit/139dc7ab2be271cd58b909db16c6ddbe5109f133), closes [#1397](https://github.com/hyperium/hyper/issues/1397))
+* **conn:** don't double shutdown in some cases ([7d3abfbc](https://github.com/hyperium/hyper/commit/7d3abfbcf33946cb8831103c3b55f9966fa9469d))
+
+
+### v0.11.9 (2017-12-09)
+
+
+#### Bug Fixes
+
+* **client:** detect valid eof after reading a body ([15fdd53d](https://github.com/hyperium/hyper/commit/15fdd53d4cb1cd0fef41c4bed509020f44512a00), closes [#1396](https://github.com/hyperium/hyper/issues/1396))
+
+
+#### Features
+
+* **log:** improve quality of debug level logs ([7b593112](https://github.com/hyperium/hyper/commit/7b5931122a07f2a766d3e103001bcb5ee1f983f3))
+
+
+### v0.11.8 (2017-12-06)
+
+
+#### Bug Fixes
+
+* **client:**
+  * return error instead of unmatched response when idle ([95e0164e](https://github.com/hyperium/hyper/commit/95e0164e8f0f03742f71868cb2828bcd4bfa5cfc))
+  * remove idle connections when read eof is found ([cecef9d4](https://github.com/hyperium/hyper/commit/cecef9d402b76af12e6415519deb2b604f77b195))
+  * always wait on reads for pooled connections ([9f212410](https://github.com/hyperium/hyper/commit/9f212410026c780ea2a76ba81705ed137022260d))
+  * don't leak connections with no keep-alive ([d2aa5d86](https://github.com/hyperium/hyper/commit/d2aa5d862c95168f4e71cc65155c2dc41f306f36), closes [#1383](https://github.com/hyperium/hyper/issues/1383))
+* **conn:** handle when pre-emptive flushing closes the write state ([8f938d97](https://github.com/hyperium/hyper/commit/8f938d97e7f25ca9e8c9ae65f756f952753d9bf7), closes [#1391](https://github.com/hyperium/hyper/issues/1391))
+* **lib:** fix `no_proto` dispatcher to flush queue before polling more body ([121b5eef](https://github.com/hyperium/hyper/commit/121b5eef19e65acfecb8261d865554e173f2fc78))
+* **server:** allow TLS shutdown before dropping connections with `no_proto` ([60d0eaf8](https://github.com/hyperium/hyper/commit/60d0eaf8916f7cb5073105778f25dff21bd504bb), closes [#1380](https://github.com/hyperium/hyper/issues/1380))
+
+
+#### Features
+
+* **headers:** Implement `ProxyAuthorization` (#1394) ([c93cdb29](https://github.com/hyperium/hyper/commit/c93cdb290875cb86900e84c333725aefa4d7fad5))
+* **server:**
+  * Allow keep alive to be turned off for a connection (#1390) ([eb9590e3](https://github.com/hyperium/hyper/commit/eb9590e3da65299928938ae8bb830dfb008fdadd), closes [#1365](https://github.com/hyperium/hyper/issues/1365))
+  * add `Http.serve_incoming` to wrap generic accept steams ([e4864a2b](https://github.com/hyperium/hyper/commit/e4864a2bea59b40fb07e6d18329f75817803a3f3))
+
+
+### v0.11.7 (2017-11-14)
+
+
+#### Bug Fixes
+
+* **client:**
+  * drop in-use connections when they finish if Client is dropped ([b1765dd1](https://github.com/hyperium/hyper/commit/b1765dd168b24912fbd36682f1f6df70eeb1acd5))
+  * don't read extra bytes on idle connections ([7c4b814e](https://github.com/hyperium/hyper/commit/7c4b814e6b95bdb22b11e027b2da16c5abb8399f))
+* **server:** GET requests with no body have None instead of Empty ([8bf79648](https://github.com/hyperium/hyper/commit/8bf7964875205155e3018902a6e8facee6c145b6), closes [#1373](https://github.com/hyperium/hyper/issues/1373))
+
+
+#### Features
+
+* **client:**
+  * skip dns resolution when host is a valid ip addr ([b1785c66](https://github.com/hyperium/hyper/commit/b1785c662bc75f7bbd36a242c379d120ff7c6cd2))
+  * allow custom executors for HttpConnector ([ed497bf5](https://github.com/hyperium/hyper/commit/ed497bf5e6f1d651e3b30fd42c10245c560aff5b))
+  * add names to DNS threads ([e0de55da](https://github.com/hyperium/hyper/commit/e0de55daa2ec241f97fc5ed14f5ec933bde110d7))
+* **header:** implement `ByteRangeSpec::to_satisfiable_range` ([bb54e36c](https://github.com/hyperium/hyper/commit/bb54e36c90dc9c2ca876cd7f2c7dc7250d217552))
+* **lib:** add support to disable tokio-proto internals ([f7532b71](https://github.com/hyperium/hyper/commit/f7532b71d141ebe41172dbb863d58d519e387a4e))
+* **server:**
+  * add `const_service` and `service_fn` helpers ([fe38aa4b](https://github.com/hyperium/hyper/commit/fe38aa4bc1c8fdcaefb0d839239c14620a7b8f0a))
+  * add `server::Serve` that can use a shared Handle ([39cf6ef7](https://github.com/hyperium/hyper/commit/39cf6ef7d26b3d829ec19fb1db176e8221170cb3))
+  * allow creating Server with shared Handle ([0844dede](https://github.com/hyperium/hyper/commit/0844dede191d720e0336ee4aca63af2255abe458))
+
+
+### v0.11.6 (2017-10-02)
+
+
+#### Bug Fixes
+
+* **server:** fix experimental pipeline flushing ([6b4635fd](https://github.com/hyperium/hyper/commit/6b4635fd13f5fe91ad6d388c5e66394627ad7ba2))
+
+
+### v0.11.5 (2017-10-02)
+
+
+#### Bug Fixes
+
+* **http:** avoid infinite recursion when Body::from is called with Cow::Owned. (#1343) ([e8d61737](https://github.com/hyperium/hyper/commit/e8d6173734b0fb43bf7401fdbe43258d913a6284))
+
+
+### v0.11.4 (2017-09-28)
+
+
+#### Bug Fixes
+
+* **client:**  fix panic in Pool ([0fbc215f](https://github.com/hyperium/hyper/commit/0fbc215f), closes [#1339](https://github.com/hyperium/hyper/issues/1339))
+
+
+### v0.11.3 (2017-09-28)
+
+
+#### Features
+
+* **header:**  add ContentType::xml() constructor ([92595e84](https://github.com/hyperium/hyper/commit/92595e84))
+* **http:**  add Body::from(cow) for bytes and strings ([425ff71d](https://github.com/hyperium/hyper/commit/425ff71d))
+* **lib:**  implement compatibility with http crate ([0c7d375b](https://github.com/hyperium/hyper/commit/0c7d375b))
+* **server:**
+  *  add experimental pipeline flush aggregation option to Http ([dd54f20b](https://github.com/hyperium/hyper/commit/dd54f20b))
+  *  remove unneeded Send + Sync from Server ([16e834d3](https://github.com/hyperium/hyper/commit/16e834d3))
+
+#### Bug Fixes
+
+* **client:**
+  *  cleanup dropped pending Checkouts from Pool ([3b91fc65](https://github.com/hyperium/hyper/commit/3b91fc65), closes [#1315](https://github.com/hyperium/hyper/issues/1315))
+  *  return Version errors if unsupported ([41c47241](https://github.com/hyperium/hyper/commit/41c47241), closes [#1283](https://github.com/hyperium/hyper/issues/1283))
+* **http:**  log errors passed to tokio at debug level ([971864c4](https://github.com/hyperium/hyper/commit/971864c4), closes [#1278](https://github.com/hyperium/hyper/issues/1278))
+* **lib:**
+  *  Export hyper::RawStatus if the raw_status feature is enabled ([627c4e3d](https://github.com/hyperium/hyper/commit/627c4e3d))
+  *  remove logs that contain request and response data ([207fca63](https://github.com/hyperium/hyper/commit/207fca63), closes [#1281](https://github.com/hyperium/hyper/issues/1281))
+
+#### Performance
+
+* **server:**  try to read from socket at keep-alive ([1a9f2648](https://github.com/hyperium/hyper/commit/1a9f2648))
+
+
+### v0.11.2 (2017-07-27)
+
+
+#### Bug Fixes
+
+* **client:** don't assume bodies on 204 and 304 Responses ([81c0d185](https://github.com/hyperium/hyper/commit/81c0d185bdb2cb11e0fba231e3259097f492dd7d), closes [#1242](https://github.com/hyperium/hyper/issues/1242))
+* **header:** fix panic from headers.remove when typed doesn't match ([4bd9746a](https://github.com/hyperium/hyper/commit/4bd9746a0fa56ddc578ec5a8044e6c37390f3770))
+* **http:**
+  * allow zero-length chunks when no body is allowed ([9b47e186](https://github.com/hyperium/hyper/commit/9b47e1861a6bd766f21c88b95ecfc9b45fad874d))
+  * fix encoding when buffer is full ([fc5b9cce](https://github.com/hyperium/hyper/commit/fc5b9cce3176776e4c916cd1b907b1649a538f00))
+  * skip zero length chunks when encoding ([d6da3f7b](https://github.com/hyperium/hyper/commit/d6da3f7b40550b425f760d0d331807feff9114fd))
+* **server:**
+  * improve detection of when a Response can have a body ([673e5cb1](https://github.com/hyperium/hyper/commit/673e5cb1a3dadea178e51677fa660a1258610ae8), closes [#1257](https://github.com/hyperium/hyper/issues/1257))
+  * reject Requests with invalid body lengths ([14cbd400](https://github.com/hyperium/hyper/commit/14cbd40071816ec04dd1921e599c1d5cca883898))
+  * do not automatically set ContentLength for 204 and 304 Responses ([c4c89a22](https://github.com/hyperium/hyper/commit/c4c89a22f8f1ebc74a13a6ee75a8209081dcb535))
+* **uri:** fix Uri parsing of IPv6 and userinfo ([7081c449](https://github.com/hyperium/hyper/commit/7081c4498e707c1240c7e672d39ba4948fffb558), closes [#1269](https://github.com/hyperium/hyper/issues/1269))
+
+
+#### Features
+
+* **headers:** export missing header types ([c9f4ff33](https://github.com/hyperium/hyper/commit/c9f4ff33821df1bff557dfddac1ba3fc6255ee62))
+* **server:** Provide reference to Response body ([a79fc98e](https://github.com/hyperium/hyper/commit/a79fc98e36eac485803b1ab97f35c60198fd72cb), closes [#1216](https://github.com/hyperium/hyper/issues/1216))
+* **status:** add `as_u16()` method to `StatusCode` ([5f6f252c](https://github.com/hyperium/hyper/commit/5f6f252c603c642be8037682c1bf7e7ed2392a53))
+
+
+### v0.11.1 (2017-07-03)
+
+
+#### Features
+
+* **server:** Handle 100-continue ([6164e764](https://github.com/hyperium/hyper/commit/6164e76405935065aeb912f94ba94230e0bac60f))
+
+
+## v0.11.0 (2017-06-13)
+
+#### Bug Fixes
+
+* **header:**
+  * add length checks to `ETag` parsing ([643fac1e](https://github.com/hyperium/hyper/commit/643fac1e01102524e44ead188e865830ebdfb1f4))
+  * prevent 2 panics in `QualityItem` parsing ([d80aae55](https://github.com/hyperium/hyper/commit/d80aae55b1af0420bfcdecb2c8515b48e3e0e641))
+  * Allow IPv6 Addresses in `Host` header ([8541ac72](https://github.com/hyperium/hyper/commit/8541ac72d7ec80a36171115501e49dd47bcb1d0d))
+  * Remove raw part when getting mutable reference to typed header ([f38717e4](https://github.com/hyperium/hyper/commit/f38717e422a80e04ca95fcd5e5c5d54b7197bed2), closes [#821](https://github.com/hyperium/hyper/issues/821))
+  * only add chunked to `TransferEncoding` if not present ([1b4f8579](https://github.com/hyperium/hyper/commit/1b4f85799737a537d8ebfb6afd0423b97238ab8b))
+  * ignore invalid cookies ([310d98d5](https://github.com/hyperium/hyper/commit/310d98d50b929b8bde898cbb1137df95da5e0840))
+* **http:**
+  * Chunked decoder reads last `\r\n` ([bffde8c8](https://github.com/hyperium/hyper/commit/bffde8c841353e05e9aea267ca94848ccdeeb394))
+  * make Chunked decoder resilient in an async world ([8672ec5a](https://github.com/hyperium/hyper/commit/8672ec5a366e698bd32679d64dce925b3fa11fc6))
+* **server:**
+  * support HTTP/1.1 pipelining ([523b890a](https://github.com/hyperium/hyper/commit/523b890a19e9325938adf42456eea6191fcb8029))
+
+#### Features
+
+* **body:**
+  * implement Extend and IntoIterator for Chunk ([78512bdb](https://github.com/hyperium/hyper/commit/78512bdb184903061ea02f1101c99a097483cb69))
+  * add Default trait to Body ([f61708ba](https://github.com/hyperium/hyper/commit/f61708ba81fc03a4797688afd5bcec87e8f98eef))
+  * implement `Default` for `Body` ([6faa653f](https://github.com/hyperium/hyper/commit/6faa653f0dfaa5220e76a60fcd264511686dfd08))
+  * implement `Default` for `Chunk` ([f5567db4](https://github.com/hyperium/hyper/commit/f5567db4dcc04a769725d0b9ccb6a81bc3026acc))
+* **client:**
+  * add `HttpConnector.enforce_http` ([1c34a05a](https://github.com/hyperium/hyper/commit/1c34a05a85078421078f2cb266dccc5dfce8a9f0))
+  * add an accessor for the request body ([4e26646a](https://github.com/hyperium/hyper/commit/4e26646aa7b46d5739d3978126bb70e8c47cde1d))
+  * Response.status() now returns a `StatusCode` by value ([d63b7de4](https://github.com/hyperium/hyper/commit/d63b7de44f813696f8ec595d2f8f901526c1720e))
+  * add Client::handle ([9101817b](https://github.com/hyperium/hyper/commit/9101817b0fd61d7bcccfaa8933e64d6e3787395d))
+  * add Request.set_proxy for HTTP proxy requests ([e8714116](https://github.com/hyperium/hyper/commit/e871411627cab5caf00d8ee65328da9ff05fc53d), closes [#1056](https://github.com/hyperium/hyper/issues/1056))
+  * DNS worker count is configurable ([138e1643](https://github.com/hyperium/hyper/commit/138e1643e81669cae9dbe215197abd0e07f0c1e7))
+  * add keep_alive_timeout to Client ([976218ba](https://github.com/hyperium/hyper/commit/976218badc4a067e45a9d15af7e4eb5f2a4adc09))
+* **error:** Display for Error shows better info ([49e196db](https://github.com/hyperium/hyper/commit/49e196db1c91b2fb5f7ab05d99b9c7bc997195f2), closes [#694](https://github.com/hyperium/hyper/issues/694))
+* **header:**
+  * add ContentType::octet_stream() constructor ([1a353102](https://github.com/hyperium/hyper/commit/1a35310273732acbf8e8498ebb5dbad3d61386cb))
+  * change `Cookie` to be map-like ([dd03e723](https://github.com/hyperium/hyper/commit/dd03e7239238e6c0753cf2502a0534e2c9770d9e), closes [#1145](https://github.com/hyperium/hyper/issues/1145))
+  * add `Cookie::iter()` ([edc1c0dd](https://github.com/hyperium/hyper/commit/edc1c0dd01b24ee32250dff51268ad60fff9293d))
+  * implement fmt::Display for several headers ([e9e7381e](https://github.com/hyperium/hyper/commit/e9e7381ece21588076bb712d5c508f50cd740591))
+  * add `Headers::append_raw` ([b4b2fb78](https://github.com/hyperium/hyper/commit/b4b2fb782e51b2b932e52fab6add7c23a369f1fb))
+  * Add support for Retry-After header ([1037bc77](https://github.com/hyperium/hyper/commit/1037bc773256ca05c4311a781e96fbdcaac877fe))
+  * add `Encoding::Brotli` variant ([f0ab2b6a](https://github.com/hyperium/hyper/commit/f0ab2b6aedb909d37698365d1fcc34ce749304b5))
+  * introduce `header::Raw` (#869) ([50ccdaa7](https://github.com/hyperium/hyper/commit/50ccdaa7e7db574ec9890c220765ffd2da5e493b))
+  * add `TE` header struct (#1150) ([f1859dfd](https://github.com/hyperium/hyper/commit/f1859dfd7abfc124dd986edc413f754f76c76e8b), closes [#1109](https://github.com/hyperium/hyper/issues/1109))
+  * support Opaque origin headers (#1147) ([41485997](https://github.com/hyperium/hyper/commit/414859978b47dc8ebd0df264afc4e113b8a1909e), closes [#1065](https://github.com/hyperium/hyper/issues/1065))
+  * add `HeaderView.raw()` ([8143c33b](https://github.com/hyperium/hyper/commit/8143c33bad9146414f14197c39f6d5326d0f0212))
+  * `impl Eq for ContentType` ([bba761ac](https://github.com/hyperium/hyper/commit/bba761ac547b59c885aceea5b9e52bf52e8747b5))
+  * add `Link` header implementation ([592c1e21](https://github.com/hyperium/hyper/commit/592c1e21256d3ba2aeba6cdc2b62d8c1ebfa1dbf), closes [#650](https://github.com/hyperium/hyper/issues/650))
+  * add `star`, `json`, `text`, `image` constructors to `Accept` ([bdc19d52](https://github.com/hyperium/hyper/commit/bdc19d52bf5ec2e63b785de31bfe0ad3ba4d2550))
+  * Add strict-origin and strict-origin-when-cross-origin referer policy ([3593d798](https://github.com/hyperium/hyper/commit/3593d7987a92518736e130586499d97afa3e5b04))
+  * support multiple values for Referrer-Policy header ([7b558ae8](https://github.com/hyperium/hyper/commit/7b558ae87a826ca7383c0034d4ca95fc61aeac4c), closes [#882](https://github.com/hyperium/hyper/issues/882))
+  * add `Warning` header ([69894d19](https://github.com/hyperium/hyper/commit/69894d19947f01ad4ff54ce0283429758acba9ff), closes [#883](https://github.com/hyperium/hyper/issues/883))
+  * `Headers::remove` returns the Header ([9375addb](https://github.com/hyperium/hyper/commit/9375addba03505f2515d493364f9b1beb8b9b99a), closes [#891](https://github.com/hyperium/hyper/issues/891))
+  * add `ContentLocation` header ([13c5bf66](https://github.com/hyperium/hyper/commit/13c5bf66c305c08a2a1af26e48115b667d141b18), closes [#870](https://github.com/hyperium/hyper/issues/870))
+  * add `LastEventId` header ([e1542a60](https://github.com/hyperium/hyper/commit/e1542a609f99da770a65500333d922c58e39d179))
+  * add `Origin header ([01843f88](https://github.com/hyperium/hyper/commit/01843f882265a894c7051dc2ecf5cf09f2c2e8e7), closes [#651](https://github.com/hyperium/hyper/issues/651))
+  * Add `ReferrerPolicy` header ([3a86b3a2](https://github.com/hyperium/hyper/commit/3a86b3a2b25be1c088cf7d39bb431b2e624d4191))
+* **http:**
+  * add Into<Bytes> for Chunk ([fac3d70c](https://github.com/hyperium/hyper/commit/fac3d70c0b716157ba689ae2b8a0089b6afc9bdc))
+  * use the bytes crate for Chunk and internally ([65b3e08f](https://github.com/hyperium/hyper/commit/65b3e08f6904634294ff2d105f2551cafe7e754d))
+  * allow specifying custom body streams ([1b1311a7](https://github.com/hyperium/hyper/commit/1b1311a7d36b000c9c2c509971ee759da8765711))
+* **lib:**
+  * add `raw_status` feature in Cargo.toml ([acd62cda](https://github.com/hyperium/hyper/commit/acd62cda446e4c647716a2d595342360dc24a080))
+  * remove extern Url type usage ([4fb7e6eb](https://github.com/hyperium/hyper/commit/4fb7e6ebc6b1d429dcce4bc18139bd443fffa6ee))
+  * export Method::Put at top level ([5c890321](https://github.com/hyperium/hyper/commit/5c890321ee2da727a814c18d4ee2df5eddd6720e))
+  * redesign API to use Futures and Tokio ([2d2d5574](https://github.com/hyperium/hyper/commit/2d2d5574a698e74e5102d39b9a9ab750860d92d1))
+  * switch to non-blocking (asynchronous) IO ([d35992d0](https://github.com/hyperium/hyper/commit/d35992d0198d733c251e133ecc35f2bca8540d96))
+* **mime:** upgrade to mime v0.3 ([f273224f](https://github.com/hyperium/hyper/commit/f273224f21eedd2f466f12fe30fd24e83c35922c), closes [#738](https://github.com/hyperium/hyper/issues/738))
+* **server:**
+  * make Http default its body type to hyper::Chunk ([dc97dd77](https://github.com/hyperium/hyper/commit/dc97dd77f45486d9cb9a22a1859809c5af5579e2))
+  * make Http compatible with TcpServer ([e04bcc12](https://github.com/hyperium/hyper/commit/e04bcc12a7e081f75482cdca1e4f4c4f597ad2ce), closes [#1036](https://github.com/hyperium/hyper/issues/1036))
+  * add path() and query() to Request ([8b3c1206](https://github.com/hyperium/hyper/commit/8b3c1206846cb96be780923952eafe0dde7850bf), closes [#896](https://github.com/hyperium/hyper/issues/896), [#897](https://github.com/hyperium/hyper/issues/897))
+* **status:**
+  * add `StatusCode::try_from(u16)`. ([f953cafe](https://github.com/hyperium/hyper/commit/f953cafe27d1c5de0c8b859e485225cfc2c18629))
+  * remove deprecated `StatusClass` ([94ee6204](https://github.com/hyperium/hyper/commit/94ee6204ae32b8c431c00fdc03dc75eee573c69c))
+  * impl Into<u16> for StatusCode ([c42f18db](https://github.com/hyperium/hyper/commit/c42f18db05e47fc24e8a8ece76cbc782b7558e8b))
+* **uri:**
+  * redesign `RequestUri` type into `Uri` ([9036443e](https://github.com/hyperium/hyper/commit/9036443e6bd61b948ebe622588d2765e22e2b179), closes [#1000](https://github.com/hyperium/hyper/issues/1000))
+  * add `is_absolute` method to `Uri` ([154ab29c](https://github.com/hyperium/hyper/commit/154ab29c0d2b50d7bcac0f7918abf2f7a1628112))
+* **version:** impl `FromStr` for `HttpVersion` ([47f3aa62](https://github.com/hyperium/hyper/commit/47f3aa6247a3211ae499b30584dca6acb43d2204))
+
+
+#### Breaking Changes
+
+* The `Cookie` header is no longer a wrapper over a
+  `Vec<String>`. It must be accessed via its `get` and `set` methods.
+
+ ([dd03e723](https://github.com/hyperium/hyper/commit/dd03e7239238e6c0753cf2502a0534e2c9770d9e))
+* Any use of `Quality(num)` should change to `q(num)`.
+
+ ([a4644959](https://github.com/hyperium/hyper/commit/a4644959b0f980d94898d6c2e3cb1763aac73a5e))
+* `HttpDate` no longer has public fields. Convert between
+  `HttpDate` and `SystemTime` as needed.
+
+ ([316c6fad](https://github.com/hyperium/hyper/commit/316c6fad3026ba5ff5f6b9f31aca4d4f74b144e0))
+* The `link_extensions` methods of the `Link` header are
+  removed until fixed.
+
+ ([011f28cb](https://github.com/hyperium/hyper/commit/011f28cb18d285401bc8bea2b0f0dbdf80089d97))
+* The `fmt_header` method has changed to take a different
+  formatter. In most cases, if your header also implements
+  `fmt::Display`, you can just call `f.fmt_line(self)`.
+
+ ([6f02d43a](https://github.com/hyperium/hyper/commit/6f02d43ae0d80971a32617e316498b81acf38ca2))
+* The `Encoding` enum has an additional variant, `Trailers`.
+
+ ([f1859dfd](https://github.com/hyperium/hyper/commit/f1859dfd7abfc124dd986edc413f754f76c76e8b))
+* `Origin.scheme` and `Origin.host` now return `Option`s, since the `Origin` could be `null`.
+
+ ([41485997](https://github.com/hyperium/hyper/commit/414859978b47dc8ebd0df264afc4e113b8a1909e))
+* If you were explicitly checking the `StatusCode`, such as
+  with an equality comparison, you will need to use the value instead of a
+  reference.
+
+ ([d63b7de4](https://github.com/hyperium/hyper/commit/d63b7de44f813696f8ec595d2f8f901526c1720e))
+* This removes several deprecated methods for converting
+  Headers into strings. Use more specialized methods instead.
+
+ ([ec91bf41](https://github.com/hyperium/hyper/commit/ec91bf418b1f285bac9231d4bee0dd96742e565a))
+* The `Url` type is no longer used. Any instance in the
+  `Client` API has had it replaced with `hyper::Uri`.
+
+  This also means `Error::Uri` has changed types to
+  `hyper::error::UriError`.
+
+  The type `hyper::header::parsing::HTTP_VALUE` has been made private,
+  as an implementation detail. The function `http_percent_encoding`
+  should be used instead.
+
+ ([4fb7e6eb](https://github.com/hyperium/hyper/commit/4fb7e6ebc6b1d429dcce4bc18139bd443fffa6ee))
+* This makes `Request.remote_addr` an
+  `Option<SocketAddr>`, instead of `SocketAddr`.
+
+ ([e04bcc12](https://github.com/hyperium/hyper/commit/e04bcc12a7e081f75482cdca1e4f4c4f597ad2ce))
+* The `Preference` header had a typo in a variant and it's string representation,
+  change `Preference::HandlingLeniant` to `Preference::HandlingLenient`.
+ ([2fa414fb](https://github.com/hyperium/hyper/commit/2fa414fb5fe6dbc922da25cca9960652edf32591))
+* `Server` is no longer the primary entry point. Instead,
+  an `Http` type is created  and then either `bind` to receive a `Server`,
+  or it can be passed to other Tokio things.
+ ([f45e9c8e](https://github.com/hyperium/hyper/commit/f45e9c8e4fcacc2bd7fed84ef0df6d2fcf8c1134))
+* The name of `RequestUri` has changed to `Uri`. It is no
+  longer an `enum`, but an opaque struct with getter methods.
+
+ ([9036443e](https://github.com/hyperium/hyper/commit/9036443e6bd61b948ebe622588d2765e22e2b179))
+* This adds a new variant to the `Encoding` enum, which
+  can break exhaustive matches.
+
+ ([f0ab2b6a](https://github.com/hyperium/hyper/commit/f0ab2b6aedb909d37698365d1fcc34ce749304b5))
+* The fields of the `Host` header are no longer
+  available. Use the getter methods instead.
+
+ ([cd9fd522](https://github.com/hyperium/hyper/commit/cd9fd522074bfe530c30c878e49e6ac1bd881f1f))
+* A big sweeping set of breaking changes.
+
+ ([2d2d5574](https://github.com/hyperium/hyper/commit/2d2d5574a698e74e5102d39b9a9ab750860d92d1))
+* `Headers.remove()` used to return a `bool`,
+  it now returns `Option<H>`. To determine if a a header exists,
+  switch to `Headers.has()`.
+ ([9375addb](https://github.com/hyperium/hyper/commit/9375addba03505f2515d493364f9b1beb8b9b99a))
+* `Header::parse_header` now receives `&Raw`, instead of
+  a `&[Vec<u8>]`. `Raw` provides several methods to ease using it, but
+  may require some changes to existing code.
+ ([50ccdaa7](https://github.com/hyperium/hyper/commit/50ccdaa7e7db574ec9890c220765ffd2da5e493b))
+* LanguageTag used to be at the crate root, but it is now
+  in the `hyper::header` module.
+
+ ([40745c56](https://github.com/hyperium/hyper/commit/40745c5671daf8ac7eb342ff0e1e7c801a7171c4))
+* Removes the undocumented `from_u16` function. Use
+  `StatusCode::try_from` instead.
+
+  Also makes the `status` module private. All imports of
+  `hyper::status::StatusCode` should be `hyper::StatusCode`.
+
+ ([f953cafe](https://github.com/hyperium/hyper/commit/f953cafe27d1c5de0c8b859e485225cfc2c18629))
+* All usage of `status.class()` should change to
+  equivalent `status.is_*()` methods.
+
+ ([94ee6204](https://github.com/hyperium/hyper/commit/94ee6204ae32b8c431c00fdc03dc75eee573c69c))
+* Most uses of `mime` will likely break. There is no more
+  `mime!` macro, nor a `Mime` constructor, nor `TopLevel` and `SubLevel`
+  enums.
+
+  Instead, in most cases, a constant exists that can now be used.
+
+  For less common mime types, they can be created by parsing a string.
+
+ ([f273224f](https://github.com/hyperium/hyper/commit/f273224f21eedd2f466f12fe30fd24e83c35922c))
+* To use `RawStatus`, you must enable the `raw_status`
+  crate feature.
+
+ ([acd62cda](https://github.com/hyperium/hyper/commit/acd62cda446e4c647716a2d595342360dc24a080))
+* Some headers used `UniCase`, but now use
+  `unicase::Ascii`. Upgrade code to `Ascii::new(s)`.
+
+ ([c81edd41](https://github.com/hyperium/hyper/commit/c81edd41d783f67eca7a50d83b40c8a7cedf333c))
+* This breaks a lot of the Client and Server APIs.
+  Check the documentation for how Handlers can be used for asynchronous
+  events.
+
+ ([d35992d0](https://github.com/hyperium/hyper/commit/d35992d0198d733c251e133ecc35f2bca8540d96))
+
+
+### v0.10.9 (2017-04-19)
+
+
+#### Features
+
+* **server:** add local_addr to retrieve resolved address ([71f250ad](https://github.com/hyperium/hyper/commit/71f250ad46e9ae0cac108e1de6dc15289da26a56))
+
+
+### v0.10.8 (2017-04-11)
+
+
+#### Features
+
+* **client:**
+  * introduce `PooledStream::<S>::get_ref` ([a54ce30f](https://github.com/hyperium/hyper/commit/a54ce30f902772168bbd8dc90f26bb08cecde6ec))
+  * introduce Response::get_ref ([5ef0ec2c](https://github.com/hyperium/hyper/commit/5ef0ec2cd2841e78508a61949a207187be914265))
+
+
+### v0.10.7 (2017-04-08)
+
+
+#### Bug Fixes
+
+* **server:** don't dup the listener TCP socket. ([d2362331](https://github.com/hyperium/hyper/commit/d23623317820696c910ce43262d5276e8e24c066))
+
+
+### v0.10.6 (2017-04-05)
+
+
+#### Features
+
+* **buffer:** add from_parts and into_parts functions ([78551dd0](https://github.com/hyperium/hyper/commit/78551dd040e2ab46e833af355c92fe87aa026244))
+
+
+### v0.10.5 (2017-03-01)
+
+
+#### Bug Fixes
+
+* **http:**
+  * Consume entire chunked encoding message ([4147fcd0](https://github.com/hyperium/hyper/commit/4147fcd0d688b6d5b8d6b32f26c147819321a390))
+  * fix returning EarlyEof if supplied buffer is zero-len ([1e740fbc](https://github.com/hyperium/hyper/commit/1e740fbcc3fb60af2fe8d2227457fa29582151c3))
+
+
+### v0.10.4 (2017-01-31)
+
+
+#### Features
+
+* **header:** implement fmt::Display for several headers ([d5075770](https://github.com/hyperium/hyper/commit/d50757707b1c628f398fb0583aa3dd02111ae658))
+
+
+### v0.10.3 (2017-01-30)
+
+
+#### Bug Fixes
+
+* **header:**
+  * deprecate HeaderFormatter ([282466e1](https://github.com/hyperium/hyper/commit/282466e1c00879cf9dde1ed62c3d436e99bfba85))
+  * enable SetCookie.fmt_header when only 1 cookie ([7611c307](https://github.com/hyperium/hyper/commit/7611c3071475afa2b0b80bbba2a0a7223a3d5920))
+
+
+#### Features
+
+* **header:** add Headers::append_raw ([6babbc40](https://github.com/hyperium/hyper/commit/6babbc40fb86a29ad76083a2a386182c40c0f335))
+
+
+### v0.10.2 (2017-01-23)
+
+
+#### Bug Fixes
+
+* **header:** security fix for header values that include newlines ([2603d78f](https://github.com/hyperium/hyper/commit/2603d78f59d284953553b7ef48c3ea4baa085cd1))
+* **net:** set timeouts directly in `accept` ([f5d4d653](https://github.com/hyperium/hyper/commit/f5d4d653e35ed20bbbb0b13847b3b9f1cfe9575f))
+
+
+#### Breaking Changes
+
+* This technically will cause code that a calls
+  `SetCookie.fmt_header` to panic, as it is no longer to properly write
+  that method. Most people should not be doing this at all, and all
+  other ways of printing headers should work just fine.
+
+  The breaking change must occur in a patch version because of the
+  security nature of the fix.
+
+ ([2603d78f](https://github.com/hyperium/hyper/commit/2603d78f59d284953553b7ef48c3ea4baa085cd1))
+
+
+### v0.10.1 (2017-01-19)
+
+
+## v0.10.0 (2017-01-10)
+
+#### Features
+
+* **client:**
+  * change ProxyConfig to allow HTTPS proxies ([14a4f1c2](https://github.com/hyperium/hyper/commit/14a4f1c2f735efe7b638e9078710ca32dc1e360a))
+  * remove experimental HTTP2 support ([d301c6a1](https://github.com/hyperium/hyper/commit/d301c6a1708c7d408b7f03ac46674a5f0edd3253))
+* **header:** remove `cookie` dependency ([f22701f7](https://github.com/hyperium/hyper/commit/f22701f7e7258ad4a26645eba47a3d374e452e86))
+* **lib:**
+  * remove SSL dependencies ([2f48612c](https://github.com/hyperium/hyper/commit/2f48612c7e141a9d612d7cb9d524b2f460561f56))
+  * remove `serde-serialization` feature ([7b9817ed](https://github.com/hyperium/hyper/commit/7b9817edcf4451bd033e55467c75577031bfe740))
+
+
+#### Breaking Changes
+
+* There is no more `hyper::http::h2`.
+
+  ([d301c6a1](https://github.com/hyperium/hyper/commit/d301c6a1708c7d408b7f03ac46674a5f0edd3253))
+* The `Cookie` and `SetCookie` headers no longer use the
+  cookie crate. New headers can be written for any header, or the ones
+  provided in hyper can be accessed as strings.
+
+  ([f22701f7](https://github.com/hyperium/hyper/commit/f22701f7e7258ad4a26645eba47a3d374e452e86))
+* There is no longer a `serde-serialization` feature.
+  Look at external crates, like `hyper-serde`, to fulfill this feature.
+
+  ([7b9817ed](https://github.com/hyperium/hyper/commit/7b9817edcf4451bd033e55467c75577031bfe740))
+* hyper will no longer provide OpenSSL support out of the
+  box. The `hyper::net::Openssl` and related types are gone. The `Client`
+  now uses an `HttpConnector` by default, which will error trying to
+  access HTTPS URLs.
+
+  TLS support should be added in from other crates, such as
+  hyper-openssl, or similar using different TLS implementations.
+
+  ([2f48612c](https://github.com/hyperium/hyper/commit/2f48612c7e141a9d612d7cb9d524b2f460561f56))
+* Usage of `with_proxy_config` will need to change to
+  provide a network connector. For the same functionality, a
+  `hyper::net::HttpConnector` can be easily created and passed.
+
+  ([14a4f1c2](https://github.com/hyperium/hyper/commit/14a4f1c2f735efe7b638e9078710ca32dc1e360a))
+
+
+### v0.9.14 (2016-12-12)
+
+
+#### Features
+
+* **headers:** add star, json, text, image constructors to Accept ([a9fbbd7f](https://github.com/hyperium/hyper/commit/a9fbbd7fdbcbec51ef560e9882a8fefa64a93b54))
+* **server:** add 'take_buf' method to BufReader ([bbbce5fc](https://github.com/hyperium/hyper/commit/bbbce5fc8bca0bcc34df4a4a9223432085fba2ff))
+
+
+### v0.9.13 (2016-11-27)
+
+
+#### Bug Fixes
+
+* **client:** close Pooled streams on sockopt error ([d5ffee2e](https://github.com/hyperium/hyper/commit/d5ffee2ec801274ac271273289084b7251b4ce89))
+
+
+### v0.9.12 (2016-11-09)
+
+
+#### Features
+
+* **error:** re-export url::ParseError ([30e78ac2](https://github.com/hyperium/hyper/commit/30e78ac212ed3085a5217e8d7f641c2f161ddc87))
+
+
+### v0.9.11 (2016-10-31)
+
+
+#### Bug Fixes
+
+* **headers:** Allow IPv6 Addresses in Host header ([20f177ab](https://github.com/hyperium/hyper/commit/20f177abec12397f23adf43f6b726daee1a731cf))
+
+
+#### Features
+
+* **headers:**
+  * Add strict-origin and strict-origin-when-cross-origin referer policy ([1be4e769](https://github.com/hyperium/hyper/commit/1be4e7693f7d27c049f35fefb9fffead2581b1f4))
+  * support multiple values for Referrer-Policy header ([dc476657](https://github.com/hyperium/hyper/commit/dc4766573af9bd31d57fede5b9ef0ffa56fe44ab), closes [#882](https://github.com/hyperium/hyper/issues/882))
+  * add last-event-id header ([2277987f](https://github.com/hyperium/hyper/commit/2277987f3c25380353db606ca7baaf0c854095cd))
+* **server:** accept combined certificate files ([eeb1f48e](https://github.com/hyperium/hyper/commit/eeb1f48e17f4c71162ce90f88bda3dc37b489cc7))
+
+
+### v0.9.10 (2016-07-11)
+
+
+#### Features
+
+* **headers:**
+  * add origin header ([64881ae0](https://github.com/hyperium/hyper/commit/64881ae05458f06261b2e7d0f790184678cc42b9))
+  * Add Referrer-Policy header ([b76a02cc](https://github.com/hyperium/hyper/commit/b76a02cc446f2a3935006035fd73f5f7a47ec428))
+
+
+### v0.9.9 (2016-06-21)
+
+
+#### Bug Fixes
+
+* **headers:** Remove raw part when getting mutable reference to typed header ([63b61524](https://github.com/hyperium/hyper/commit/63b615249443b8f897018f21473c2f1f8e43663c), closes [#821](https://github.com/hyperium/hyper/issues/821))
+
+
+#### Features
+
+* **error:** Display for Error shows better info ([5620fbf9](https://github.com/hyperium/hyper/commit/5620fbf98f1fd43482a9ffa3c98f2f38b42fd4b0), closes [#694](https://github.com/hyperium/hyper/issues/694))
+
+
+### v0.9.8 (2016-06-14)
+
+
+#### Features
+
+* **client:** enable use of custom TLS wrapper for proxied connections ([0476196c](https://github.com/hyperium/hyper/commit/0476196c320765a66f730c56048998980b173caf), closes [#824](https://github.com/hyperium/hyper/issues/824))
+
+
+### v0.9.7 (2016-06-09)
+
+
+#### Bug Fixes
+
+* **proxy:** fix the 0.9.x build with `--no-default-features --features=security-framework` ([6caffe9f](https://github.com/hyperium/hyper/commit/6caffe9fb302da99ce8cf0c8027c06b8c6de782d), closes [#819](https://github.com/hyperium/hyper/issues/819))
+* **server:** Request.ssl() works ([ce0b62ea](https://github.com/hyperium/hyper/commit/ce0b62eae7688987b722599be8e8b2ff6764b224))
+
+
+### v0.9.6 (2016-05-23)
+
+
+#### Bug Fixes
+
+* **client:** Manually impl Debug for PooledStream ([aa692236](https://github.com/hyperium/hyper/commit/aa692236a851d29abec63b6a0d61d957cea5fd26))
+* **server:** Switch Ssl to SslServer in bounds ([470bc8ec](https://github.com/hyperium/hyper/commit/470bc8ec396bfc9ead6782f72e6de58268767a5a))
+
+
+### v0.9.5 (2016-05-18)
+
+
+#### Bug Fixes
+
+* **windows:** disable openssl cert validation for Windows ([c89aca81](https://github.com/hyperium/hyper/commit/c89aca812bf863aadb52326f534a65c1d3cf31d6), closes [#794](https://github.com/hyperium/hyper/issues/794))
+
+
+#### Features
+
+* **net:** Add OpensslClient constructor ([3c0e1050](https://github.com/hyperium/hyper/commit/3c0e105011fc8a4fc639370836aa6a2e576b6f0e))
+
+
+### v0.9.4 (2016-05-09)
+
+
+#### Bug Fixes
+
+* **warnings:** remove unused_code warnings from newest nightlies ([e7229480](https://github.com/hyperium/hyper/commit/e7229480ea669bbe62fe644e312ba06cdca45b1c))
+
+
+#### Features
+
+* **ssl:**
+  * enable hostname verification by default for OpenSSL ([01160abd](https://github.com/hyperium/hyper/commit/01160abd92956e5f995cc45790df7a2b86c8989f), closes [#472](https://github.com/hyperium/hyper/issues/472))
+  * use secure ciphers by default in openssl ([54bf6ade](https://github.com/hyperium/hyper/commit/54bf6adeee1c3a231925f3efa7e38f875bc2d4d5))
+
+### v0.9.3 (2016-05-09)
+
+
+#### Bug Fixes
+
+* **client:** fix panic in Pool::connect ([e51bafe2](https://github.com/hyperium/hyper/commit/e51bafe2e4f2a1efc36790232bef488c91131d0b), closes [#780](https://github.com/hyperium/hyper/issues/780))
+
+
+### v0.9.2 (2016-05-04)
+
+
+#### Features
+
+* **client:**
+  *  proper proxy and tunneling in Client ([f36c6b25](https://github.com/hyperium/hyper/commit/f36c6b25), closes [#774](https://github.com/hyperium/hyper/issues/774))
+  *  add Proxy support ([25010fc1](https://github.com/hyperium/hyper/commit/25010fc1), closes [#531](https://github.com/hyperium/hyper/issues/531))
+
+#### Performance
+
+* **client:**  don't keep Pool mutex locked during getaddrinfo ([5fcc04a6](https://github.com/hyperium/hyper/commit/5fcc04a6))
+
+
+### v0.9.1 (2016-04-21)
+
+
+#### Bug Fixes
+
+* **Cargo.toml:** update documentation link ([b783ddf4](https://github.com/hyperium/hyper/commit/b783ddf455ee93cc38510f3179ffe18733c797c1))
+
+
+## v0.9.0 (2016-04-21)
+
+
+#### Features
+
+* **net:** Add Ssl impls for security-framework ([f37315b2](https://github.com/hyperium/hyper/commit/f37315b2708e092eaf5177a6960df9f7bf11eb5c))
+
+
+#### Breaking Changes
+
+* The re-exported Url type has breaking changes.
+ ([8fa7a989](https://github.com/hyperium/hyper/commit/8fa7a9896809ef2a24994993b91981105a520f26))
+
+
+### v0.8.1 (2016-04-13)
+
+
+#### Bug Fixes
+
+* **headers:** correctly handle repeated headers ([70c69142](https://github.com/hyperium/hyper/commit/70c6914217a9b48880e61b7fb59acd15c6e1421e), closes [#683](https://github.com/hyperium/hyper/issues/683))
+
+
+#### Features
+
+* **header:** add prefer and preference applied headers ([6f649301](https://github.com/hyperium/hyper/commit/6f6493010a9c190b29aceb3c10c65785923a85f5), closes [#747](https://github.com/hyperium/hyper/issues/747))
+* **net:** Split Ssl into SslClient and SslServer ([2c86e807](https://github.com/hyperium/hyper/commit/2c86e8078ec01db2283e1fee1461db4c7bf76d3f), closes [#756](https://github.com/hyperium/hyper/issues/756))
+
+
+## v0.8.0 (2016-03-14)
+
+
+#### Bug Fixes
+
+* **headers:** remove charset from `ContentType::json()` convenience method ([ec568e9a](https://github.com/hyperium/hyper/commit/ec568e9a551018b3353b6754eb2fcd729c7ea3c6))
+* **net:** fix the typo in `set_write_timeout` ([7c76fff3](https://github.com/hyperium/hyper/commit/7c76fff3aaf0f0a300e76622acb56eaf1e2cb474))
+
+
+#### Features
+
+* **client:** Implement Debug for Client ([8c7ef7fd](https://github.com/hyperium/hyper/commit/8c7ef7fd937616798780d43f80a6b46507bc3433))
+* **status:** add HTTP statuses 421 and 451 ([93fd5a87](https://github.com/hyperium/hyper/commit/93fd5a87bddc5bfe29f35f86d44d3f46c81ff5fa))
+
+
+#### Breaking Changes
+
+* mime 0.2 depends on serde 0.7, so any instances of
+  using older versions of serde will need to upgrade.
+
+ ([146df53c](https://github.com/hyperium/hyper/commit/146df53caf2a70cd15f97710738ba8d350040c12))
+
+
+### v0.7.2 (2016-01-04)
+
+
+#### Bug Fixes
+
+* **buffer:** fix incorrect resizing of BufReader ([3a18e72b](https://github.com/hyperium/hyper/commit/3a18e72be67152834f6967c6d208f214288178ee), closes [#715](https://github.com/hyperium/hyper/issues/715))
+
+
+#### Features
+
+* **headers:** allow ExtendedValue structs to be formatted and used as struct members ([da0abe89](https://github.com/hyperium/hyper/commit/da0abe8988a61281b447a554b65ea8fd5d54f81b))
+
+
+### v0.7.1 (2015-12-19)
+
+
+#### Bug Fixes
+
+* **cargo:** remove * dependencies for serde and env_logger ([4a05bee9](https://github.com/hyperium/hyper/commit/4a05bee9abdc426bbd904fe356b771e492dc8f43))
+* **server:**
+  * Flush 100-continue messages ([92ff50f2](https://github.com/hyperium/hyper/commit/92ff50f2e57fa2cb8a55b3d6d9fa43ef9a1b5526), closes [#704](https://github.com/hyperium/hyper/issues/704))
+  * Removed check for GET/HEAD request when parsing body ([0b05c590](https://github.com/hyperium/hyper/commit/0b05c5903e86327cc9cb4cac39217e496851fce3), closes [#698](https://github.com/hyperium/hyper/issues/698))
+
+
+#### Features
+
+* **headers:** add extended parameter parser to the public API ([402fb76b](https://github.com/hyperium/hyper/commit/402fb76bb2f3dab101509e4703743ab075ae41be))
+
+
+## v0.7.0 (2015-11-24)
+
+
+#### Features
+
+* **all:** add socket timeouts ([fec6e3e8](https://github.com/hyperium/hyper/commit/fec6e3e873eb79bd17d1c072d2ca3c7b91624f9c))
+* **headers:**
+  * Add Content-Disposition header ([7623ecc2](https://github.com/hyperium/hyper/commit/7623ecc26466e2e072eb2b03afc5e6c16d8e9bc9), closes [#561](https://github.com/hyperium/hyper/issues/561))
+  * Add Access-Control-Allow-Credentials header ([19348b89](https://github.com/hyperium/hyper/commit/19348b892be4687e2c0e48b3d01562562340aa1f), closes [#655](https://github.com/hyperium/hyper/issues/655))
+  * re-export CookiePair and CookieJar ([799698ca](https://github.com/hyperium/hyper/commit/799698ca87bc8f2f5446e9cb1301e5976657db6b))
+
+
+#### Breaking Changes
+
+* This adds 2 required methods to the `NetworkStream`
+  trait, `set_read_timeout` and `set_write_timeout`. Any local
+  implementations will need to add them.
+
+ ([fec6e3e8](https://github.com/hyperium/hyper/commit/fec6e3e873eb79bd17d1c072d2ca3c7b91624f9c))
+* LanguageTags api is changed.
+
+ ([c747f99d](https://github.com/hyperium/hyper/commit/c747f99d2137e03b5f4393ee3731f6ebeab9ee6e))
+
+
+### v0.6.16 (2015-11-16)
+
+
+#### Bug Fixes
+
+* **response:** respond with a 500 if a handler panics ([63c6762c](https://github.com/hyperium/hyper/commit/63c6762c15ec790f54391a71794315599ae0ced8))
+
+
+#### Features
+
+* **headers:** Add Access-Control-Expose-Headers ([f783e991](https://github.com/hyperium/hyper/commit/f783e9913b988f3d5c28707e2291145999756dbe))
+* **server:** Add hooks for HttpListener and HttpsListener to be started from existing listener ([fa0848d4](https://github.com/hyperium/hyper/commit/fa0848d4216aa81e7b7619b7ce0a650356ee7ab7))
+
+
+#### Breaking Changes
+
+* `RequestBuilder<U>` should be replaced by `RequestBuilder`.
+
+ ([ff4a6070](https://github.com/hyperium/hyper/commit/ff4a6070573955d1623d51a3d5302a17eed8f8d6))
+
+
+### v0.6.15 (2015-10-09)
+
+
+#### Bug Fixes
+
+* **server:** use a timeout for Server keep-alive ([cdaa2547](https://github.com/hyperium/hyper/commit/cdaa2547ed18dfb0e3b8ed2ca15cfda1f98fa9fc), closes [#368](https://github.com/hyperium/hyper/issues/368))
+
+
+#### Features
+
+* **client:** add patch method to Client builder interface ([03827c31](https://github.com/hyperium/hyper/commit/03827c3156b5c0a7c865c5846aca2c1ce7a9f4ce))
+
+
+### v0.6.14 (2015-09-21)
+
+
+#### Bug Fixes
+
+* **http:**
+  * Add a stream enum that makes it impossible to lose a stream ([be4e7181](https://github.com/hyperium/hyper/commit/be4e7181456844180963d0e5234656c319ce92a6))
+  * Make sure not to lose the stream when CL is invalid ([a36e44af](https://github.com/hyperium/hyper/commit/a36e44af7d4e665a122c1498011ff10035f7376f))
+* **server:** use EmptyWriter for status codes that have no body ([9b2998bd](https://github.com/hyperium/hyper/commit/9b2998bddc3c033e4fc4e6a9b7d18504339ded3f))
+* **timeouts:** remove rust #![feature] for socket timeouts ([b8729698](https://github.com/hyperium/hyper/commit/b872969880be502b681def26d6b9780cc90ac74b))
+
+
+#### Features
+
+* **headers:** add PartialEq impl for Headers struct ([76cbf384](https://github.com/hyperium/hyper/commit/76cbf384231e602d888e49932bf9c4fafdd88051))
+
+
+### v0.6.13 (2015-09-02)
+
+
+#### Bug Fixes
+
+* **client:** EofReader by nature means the connection is closed ([32e09a04](https://github.com/hyperium/hyper/commit/32e09a04292b0247456a8fb9003a75a6abaa998e))
+
+
+### v0.6.12 (2015-09-01)
+
+
+#### Bug Fixes
+
+* **client:** be resilient to invalid response bodies ([75c71170](https://github.com/hyperium/hyper/commit/75c71170206db3119d9b298ea5cf3ee860803124), closes [#640](https://github.com/hyperium/hyper/issues/640))
+* **examples:** "cargo test --features serde-serialization" ([63608c49](https://github.com/hyperium/hyper/commit/63608c49c0168634238a119eb64ea1074df1b7e6))
+* **http:** fix several cases in HttpReader ([5c7195ab](https://github.com/hyperium/hyper/commit/5c7195ab4a213bf0016f2185a63a6341e4cef4de))
+
+
+#### Features
+
+* **server:** Add Handler per-connection hooks ([6b6182e8](https://github.com/hyperium/hyper/commit/6b6182e8c4c81f634becebe7b45dc21bff59a286))
+
+
+### v0.6.11 (2015-08-27)
+
+
+#### Bug Fixes
+
+* **client:** fix panics when some errors occurred inside HttpMessage ([ef15257b](https://github.com/hyperium/hyper/commit/ef15257b733d40bc3a7c598f61918f91385585f9))
+* **headers:** case insensitive values for Connection header ([341f8eae](https://github.com/hyperium/hyper/commit/341f8eae6eb33e2242be09541807cdad9afc732e), closes [#635](https://github.com/hyperium/hyper/issues/635))
+
+
+#### Breaking Changes
+
+* This changes the signature of HttpWriter.end(),
+  returning a `EndError` that is similar to std::io::IntoInnerError,
+  allowing HttpMessage to retrieve the broken connections and not panic.
+
+  The breaking change isn't exposed in any usage of the `Client` API,
+  but for anyone using `HttpWriter` directly, since this was technically
+  a public method, that change is breaking.
+
+ ([ef15257b](https://github.com/hyperium/hyper/commit/ef15257b733d40bc3a7c598f61918f91385585f9))
+
+
+### v0.6.10 (2015-08-19)
+
+
+#### Bug Fixes
+
+* **client:** close connection when there is an Error ([d32d35bb](https://github.com/hyperium/hyper/commit/d32d35bbea947172224082e1f9b711022ce75e30))
+
+
+#### Features
+
+* **uri:** implement fmt::Display for RequestUri () ([80931cf4](https://github.com/hyperium/hyper/commit/80931cf4c31d291125700ed3f9be5b3cb015d797), closes [#629](https://github.com/hyperium/hyper/issues/629))
+
+
+### v0.6.9 (2015-08-13)
+
+
+#### Bug Fixes
+
+* **client:**
+  * improve keep-alive of bodyless Responses ([67c284a9](https://github.com/hyperium/hyper/commit/67c284a96a006f888f43d8af929516465de76dea))
+  * improve HttpReader selection for client Responses ([31f117ea](https://github.com/hyperium/hyper/commit/31f117ea08c01889016fd45e7084e9a049c53f7a), closes [#436](https://github.com/hyperium/hyper/issues/436))
+* **nightly:** remove feature flag for duration ([0455663a](https://github.com/hyperium/hyper/commit/0455663a98d7969c23d64d0b775799342507ef8e))
+
+
+#### Features
+
+* **headers:** Content-Range header ([af062ac9](https://github.com/hyperium/hyper/commit/af062ac954d5b90275138880ce2f5013d6664b5a))
+* **net:** impl downcast methods for NetworkStream (without + Send) ([1a91835a](https://github.com/hyperium/hyper/commit/1a91835abaa804aabf2e9bb45e9ab087274b8a18), closes [#521](https://github.com/hyperium/hyper/issues/521))
+* **server:** add Request.ssl() to get underlying ssl stream ([7909829f](https://github.com/hyperium/hyper/commit/7909829f98bd9a2f454430f89b6143b977aedb35), closes [#627](https://github.com/hyperium/hyper/issues/627))
+
+
+### v0.6.8 (2015-08-03)
+
+
+#### Features
+
+* **raw-fd:** implement FromRawFd/FromRawSocket ([664bde58](https://github.com/hyperium/hyper/commit/664bde58d8a6b2d6ce5624ed96b8d6d68214a782))
+
+
+### v0.6.7 (2015-08-03)
+
+
+#### Bug Fixes
+
+* **headers:** fix broken deserialization of headers ([f5f5e1cb](https://github.com/hyperium/hyper/commit/f5f5e1cb2d01a22f170432e73b9c5757380cc18b))
+
+
+#### Features
+
+* **net:**
+  * Implement NetworkConnector for closure to be more flexible ([abdd4c5d](https://github.com/hyperium/hyper/commit/abdd4c5d632059ebef9bbee95032c9500620212e))
+  * add socket timeouts to Server and Client ([7d1f154c](https://github.com/hyperium/hyper/commit/7d1f154cb7b4db4a029b52857c377000a3f23419), closes [#315](https://github.com/hyperium/hyper/issues/315))
+
+
+#### Breaking Changes
+
+* Any custom implementation of NetworkStream must now
+  implement `set_read_timeout` and `set_write_timeout`, so those will
+  break. Most users who only use the provided streams should work with
+  no changes needed.
+
+Closes #315
+
+ ([7d1f154c](https://github.com/hyperium/hyper/commit/7d1f154cb7b4db4a029b52857c377000a3f23419))
+
+
+### v0.6.5 (2015-07-23)
+
+
+#### Bug Fixes
+
+* **tests:** iter.connect() is now iter.join() ([d2e8b5dc](https://github.com/hyperium/hyper/commit/d2e8b5dc3d2e6f0386656f4a5926acb848d4a61d))
+
+
+#### Features
+
+* **status:**
+  * implement `Hash` for `StatusCode` ([d84f291a](https://github.com/hyperium/hyper/commit/d84f291abc0a64e270143eee943a76a7aebec029))
+  * implement `Hash` for `StatusCode` ([aa85f609](https://github.com/hyperium/hyper/commit/aa85f609b5136cb2a9b23408a2b125c6a8a20f37))
+
+
+### v0.6.4 (2015-07-23)
+
+
+#### Features
+
+* **http:** add optional serialization of common types via `serde` ([87de1b77](https://github.com/hyperium/hyper/commit/87de1b77bcd5533c70a6ab9379121001acc5d366))
+
+
+### v0.6.3 (2015-07-08)
+
+
+#### Bug Fixes
+
+* **lint:** change deny(missing_docs) to only apply for tests ([5994a6f8](https://github.com/hyperium/hyper/commit/5994a6f8b4e48c9ab766e425dba210bdac59b00b), closes [#600](https://github.com/hyperium/hyper/issues/600))
+
+
+### v0.6.2 (2015-07-06)
+
+
+#### Bug Fixes
+
+* **http:** no longer keep alive for Http1.0 if no Connection header ([ddecb262](https://github.com/hyperium/hyper/commit/ddecb262b39b90e594a95ba16c4dc8085930677e), closes [#596](https://github.com/hyperium/hyper/issues/596))
+
+
+#### Features
+
+* **client:** add url property Response ([82ed9092](https://github.com/hyperium/hyper/commit/82ed9092e30385de004912582a7838e037497c82))
+* **headers:** add strict-transport-security header ([7c2e5124](https://github.com/hyperium/hyper/commit/7c2e5124e6678a5806f980902031e6f01652d218), closes [#589](https://github.com/hyperium/hyper/issues/589))
+
+
+#### Breaking Changes
+
+* Access-Control-Allow-Origin does no longer use Url
+
+ ([ed458628](https://github.com/hyperium/hyper/commit/ed458628e54bd241b45f50fb0cf55a84ffb12205))
+* Technically a break, since `Response::new()` takes an
+  additional argument. In practice, the only place that should have been
+  creating Responses directly is inside the Client, so it shouldn't
+  break anyone. If you were creating Responses manually, you'll need to
+  pass a Url argument.
+
+ ([82ed9092](https://github.com/hyperium/hyper/commit/82ed9092e30385de004912582a7838e037497c82))
+
+
+### v0.6.1 (2015-06-26)
+
+
+#### Bug Fixes
+
+* **benches:** adjust to missing `set_ssl_verifier` ([eb38a11b](https://github.com/hyperium/hyper/commit/eb38a11b9ab401d6b909077f92507fa872349d13))
+* **cargo:** fix linking on OSX 10.10 ([9af2b66f](https://github.com/hyperium/hyper/commit/9af2b66fe4003706517d95ed94013af9cd365b24))
+* **client:** use Ssl instance in creation of SslStream ([1a490e25](https://github.com/hyperium/hyper/commit/1a490e25c321bdd173d47ed7a7a704039746fb29))
+
+
+## v0.6.0 (2015-06-24)
+
+
+#### Bug Fixes
+
+* **client:** check for drained stream in Response::drop ([e689f203](https://github.com/hyperium/hyper/commit/e689f20376d3e078f5d380902d39f8ae9c043486))
+
+
+#### Features
+
+* **client:**
+  * impl Sync for Client ([64e47b4b](https://github.com/hyperium/hyper/commit/64e47b4bbd0433065a059804adeb2b4a2d72f327), closes [#254](https://github.com/hyperium/hyper/issues/254))
+  * implement Protocol trait for HTTP/1.1 ([dccdf8d6](https://github.com/hyperium/hyper/commit/dccdf8d65a9b900daec34555d3b97c2c3c678067))
+  * add `Protocol` trait ([3417303a](https://github.com/hyperium/hyper/commit/3417303a4a9aa4809729d53f0d018338e876da51))
+  * implement HttpMessage for HTTP/1.1 ([ecb713f8](https://github.com/hyperium/hyper/commit/ecb713f8494b13bdba91258b1507e8f7ce62b8d9))
+  * add `HttpMessage` trait ([289fd02b](https://github.com/hyperium/hyper/commit/289fd02b55a42748cbce8de428939208713a765d))
+* **error:** add private `__Nonexhaustive` variant to Error ([7c0421e3](https://github.com/hyperium/hyper/commit/7c0421e3fc1d5a8b4868b57acca87abd685f3430))
+* **headers:**
+  * add bearer token support ([edf6ac20](https://github.com/hyperium/hyper/commit/edf6ac2074d11694ded275807a66df3a8a8e33a6))
+  * add `Range` header ([05c31998](https://github.com/hyperium/hyper/commit/05c319984630b31d18dfbfa9b7567f6c7613d7f8))
+* **http2:**
+  * implement message API for HTTP/2 ([f0fe2c5a](https://github.com/hyperium/hyper/commit/f0fe2c5a83bd4e654a4ff684f75a1b602f8f38fc))
+  * add new error variant for HTTP/2 ([48e9ca2f](https://github.com/hyperium/hyper/commit/48e9ca2f70f6c6475f1579ae9212af7b4ca87e88))
+  * add dependency on `solicit` ([3122ffef](https://github.com/hyperium/hyper/commit/3122ffefc2d56ffc03a6fcc264086df0c9d74083))
+* **langtags:** use true language tags in headers ([99ff7e62](https://github.com/hyperium/hyper/commit/99ff7e62573865a1fc431db26b6a18c43b9127de))
+* **ssl:** redesign SSL usage ([53bba6eb](https://github.com/hyperium/hyper/commit/53bba6eb7f34e61e5c8a835281d625436532de8f))
+
+
+#### Breaking Changes
+
+* AcceptLanguage and ContentLanguage use LanguageTag now,
+Language removed from Hyper.
+
+ ([99ff7e62](https://github.com/hyperium/hyper/commit/99ff7e62573865a1fc431db26b6a18c43b9127de))
+* Server::https was changed to allow any implementation
+  of Ssl. Server in general was also changed. HttpConnector no longer
+  uses SSL; using HttpsConnector instead.
+
+ ([53bba6eb](https://github.com/hyperium/hyper/commit/53bba6eb7f34e61e5c8a835281d625436532de8f))
+* Connectors and Protocols passed to the `Client` must
+  now also have a `Sync` bounds, but this shouldn't break default usage.
+
+ ([64e47b4b](https://github.com/hyperium/hyper/commit/64e47b4bbd0433065a059804adeb2b4a2d72f327))
+* parse_header returns Result instead of Option, related
+code did also change
+
+ ([195a89fa](https://github.com/hyperium/hyper/commit/195a89fa918a83c9dcab47a4b09edb464d4e8006))
+* Adds a new variant to public Error enum. The proper fix
+  is to stop matching exhaustively on `hyper::Error`.
+
+ ([7c0421e3](https://github.com/hyperium/hyper/commit/7c0421e3fc1d5a8b4868b57acca87abd685f3430))
+* A new variant `Http2` added to a public enum
+`hyper::Error`.
+
+ ([48e9ca2f](https://github.com/hyperium/hyper/commit/48e9ca2f70f6c6475f1579ae9212af7b4ca87e88))
+* `hyper::client::request::Response` is no longer generic
+over `NetworkStream` types. It no longer requires a generic type
+parameter at all.
+
+ ([aa297f45](https://github.com/hyperium/hyper/commit/aa297f45322d66980bb2b51c413b15dfd51533ea))
+
+
+### v0.5.2 (2015-06-01)
+
+
+#### Bug Fixes
+
+* **buffer:** check capacity before resizing ([b1686d1b](https://github.com/hyperium/hyper/commit/b1686d1b22aa95a17088f99054d577bbb2aef9dc))
+
+
+### v0.5.1 (2015-05-25)
+
+
+#### Bug Fixes
+
+* **client:** don't close stream until EOF ([a5e6174e](https://github.com/hyperium/hyper/commit/a5e6174efd57afb1df7113c64f4e7718a3a94187), closes [#543](https://github.com/hyperium/hyper/issues/543))
+
+
+#### Features
+
+* **client:** implement Default trait for client ([be041d91](https://github.com/hyperium/hyper/commit/be041d915a55fa1b5088e112b81727b864949976))
+* **header:** add ContentType::form_url_encoded() constructor ([2c99d4e9](https://github.com/hyperium/hyper/commit/2c99d4e9068b30ecb6d4eac4d364924fb253fdcd))
+* **headers:** return hyper::Error instead of () from header components ([5d669399](https://github.com/hyperium/hyper/commit/5d669399b6ca5ec7d0f01b9d30513cd1cc4cc47b))
+* **http:** add get_mut method to HttpReader ([e64ce8c0](https://github.com/hyperium/hyper/commit/e64ce8c05e847b2396e4b7e2bb656240e9806ed8))
+
+
+#### Breaking Changes
+
+* Error enum extended. Return type of header/shared/
+types changed.
+
+ ([5d669399](https://github.com/hyperium/hyper/commit/5d669399b6ca5ec7d0f01b9d30513cd1cc4cc47b))
+
+
+## v0.5.0 (2015-05-12)
+
+
+#### Bug Fixes
+
+* **client:**
+  * don't call close() inside Request ([3334fca2](https://github.com/hyperium/hyper/commit/3334fca278e662b2755e41045ce641238514bea9), closes [#519](https://github.com/hyperium/hyper/issues/519))
+  * keep the underlying connector when setting an SSL verifier ([f4556d55](https://github.com/hyperium/hyper/commit/f4556d554faa2a1170fec0af5b4076c31e7c3600), closes [#495](https://github.com/hyperium/hyper/issues/495))
+* **mock:** adjust ChannelMockConnector connect method to compile ([085d7b07](https://github.com/hyperium/hyper/commit/085d7b0752d7fc0134e99e9eec2a67cc66b319b3))
+
+
+#### Features
+
+* **header:**
+  * add ContentType::json(), plaintext(), html(), jpeg(), and png() constructors ([b6114ecd](https://github.com/hyperium/hyper/commit/b6114ecd2e65bd59e79a67a45913adaf0f1552f0))
+  * add Connection::close() and ::keep_alive() constructors ([c2938fb4](https://github.com/hyperium/hyper/commit/c2938fb45f9c1fff2a1235d82b7741531de21445))
+  * export __hyper__tm! macro so test modules work with header! ([f64fb10b](https://github.com/hyperium/hyper/commit/f64fb10bc87bb4b5a5291d09364ad6c725a842d8))
+* **net:**
+  * remove mut requirement for NetworkConnector.connect() ([1b318724](https://github.com/hyperium/hyper/commit/1b318724a5fd425366daddf15c5964d7c3cbc240))
+  * add `set_ssl_verifier` method to `NetworkConnector` trait ([a5d632b6](https://github.com/hyperium/hyper/commit/a5d632b6ea53d0988d6383dd734d0b5e6245ba2b))
+* **server:** check Response headers for Connection: close in keep_alive loop ([49b5b8fd](https://github.com/hyperium/hyper/commit/49b5b8fdfe256ead8f3aa3d489bc4b299c190a9a))
+
+
+#### Breaking Changes
+
+* Usage of Response.deconstruct() and construct() now use
+  a &mut Headers, instead of the struct proper.
+
+ ([49b5b8fd](https://github.com/hyperium/hyper/commit/49b5b8fdfe256ead8f3aa3d489bc4b299c190a9a))
+* If you use deref! from the header module, you'll need
+  to switch to using __hyper__deref!.
+
+ ([62d96adc](https://github.com/hyperium/hyper/commit/62d96adc6b852b3836b47fc2e154bbdbab9ad7f6))
+* Any custom Connectors will need to change to &self in
+  the connect method. Any Connectors that needed the mutability need to
+  figure out a synchronization strategy.
+
+  Request::with_connector() takes a &NetworkConnector instead of &mut.
+  Any uses of with_connector will need to change to passing &C.
+
+ ([1b318724](https://github.com/hyperium/hyper/commit/1b318724a5fd425366daddf15c5964d7c3cbc240))
+* Adding a new required method to a public trait is a
+breaking change.
+
+ ([a5d632b6](https://github.com/hyperium/hyper/commit/a5d632b6ea53d0988d6383dd734d0b5e6245ba2b))
+
+
+## v0.4.0 (2015-05-07)
+
+
+#### Bug Fixes
+
+* **net:** ignore NotConnected error in NetworkStream.close ([6be60052](https://github.com/hyperium/hyper/commit/6be60052c627b7e498d973465b4a3ee7efc40665), closes [#508](https://github.com/hyperium/hyper/issues/508))
+
+
+#### Features
+
+* **error:** add Ssl variant to hyper::Error ([972b3a38](https://github.com/hyperium/hyper/commit/972b3a388ac3af98ba038927c551b92be3a68d62), closes [#483](https://github.com/hyperium/hyper/issues/483))
+* **headers:**
+  * Allow `null` value in Access-Control-Allow-Origin ([5e341714](https://github.com/hyperium/hyper/commit/5e3417145ced116147ef1e890b4f1e7c775ad173))
+  * Parse Upgrade header protocols further ([f47d11b9](https://github.com/hyperium/hyper/commit/f47d11b97bb4a4bf67c3f9aa47c203babf4a9c72), closes [#480](https://github.com/hyperium/hyper/issues/480))
+  * Add From header field ([ce9c4af1](https://github.com/hyperium/hyper/commit/ce9c4af1e0a46abc9f7908c2cb0659a2ecab137c))
+  * Add Accept-Ranges header field ([2dbe3f9b](https://github.com/hyperium/hyper/commit/2dbe3f9b9a3fc9f04346712e55f40dabaf72d9a8))
+* **method:** implement `AsRef<str>` for `Method` ([c29af729](https://github.com/hyperium/hyper/commit/c29af729726ae782bece5e790bce02b0d3ab9ef9))
+* **server:**
+  * add Response.send to write a sized body ([d5558b68](https://github.com/hyperium/hyper/commit/d5558b687d32d0affb9aaa7185227a4e294f5454), closes [#446](https://github.com/hyperium/hyper/issues/446))
+  * dropping a Response will write out to the underlying stream ([a9dcc59c](https://github.com/hyperium/hyper/commit/a9dcc59cd9846609a5733678f66353655c075279))
+
+
+#### Breaking Changes
+
+* Adds a variant to `hyper::Error`, which may break any
+exhaustive matches.
+
+ ([972b3a38](https://github.com/hyperium/hyper/commit/972b3a388ac3af98ba038927c551b92be3a68d62))
+* The terms `Http` and `Error` have been removed from the Error
+  type and its variants. `HttpError` should now be accessed as `hyper::Error`,
+  and variants like `HttpIoError` should be accessed as `Error::Io`.
+
+ ([9ba074d1](https://github.com/hyperium/hyper/commit/9ba074d150a55a749161317405fe8b28253c5a9d))
+* Add variant to Access-Control-Allow-Origin enum
+
+ ([5e341714](https://github.com/hyperium/hyper/commit/5e3417145ced116147ef1e890b4f1e7c775ad173))
+* Upgrade header Protocol changed.
+
+ ([f47d11b9](https://github.com/hyperium/hyper/commit/f47d11b97bb4a4bf67c3f9aa47c203babf4a9c72))
+* `from_one_raw_str()` returns `None` on empty values.
+
+ ([a6974c99](https://github.com/hyperium/hyper/commit/a6974c99d39fcbaf3fb9ed38428b21e0301f3602))
+
+
+### v0.3.16 (2015-05-01)
+
+
+#### Bug Fixes
+
+* **header:**
+  * make test_module of header! optional ([a5ce9c59](https://github.com/hyperium/hyper/commit/a5ce9c59fa61410551b07252364564a2bb13bb86), closes [#490](https://github.com/hyperium/hyper/issues/490))
+  * exporting test_header! macro ([2bc5a779](https://github.com/hyperium/hyper/commit/2bc5a779bdc3fce67e06c398ac8702fcbea93dab))
+* **http:** keep raw reason phrase in RawStatus ([8cdb9d5d](https://github.com/hyperium/hyper/commit/8cdb9d5d3b0972629e8843d3c1db58dbbbaf49cf), closes [#497](https://github.com/hyperium/hyper/issues/497))
+
+
+#### Features
+
+* **client:** add a Connection Pool ([1e72a8ab](https://github.com/hyperium/hyper/commit/1e72a8ab3a0092bb863686ad2e65646710706c1b), closes [#363](https://github.com/hyperium/hyper/issues/363), [#41](https://github.com/hyperium/hyper/issues/41))
+* **headers:** Add If-Range header ([a39735f1](https://github.com/hyperium/hyper/commit/a39735f1d3d1a314969b5b0085e8f77f0c10c863), closes [#388](https://github.com/hyperium/hyper/issues/388))
+
+
+### v0.3.15 (2015-04-29)
+
+
+#### Bug Fixes
+
+* **headers:**
+  * Do not parse empty values in list headers. ([093a29ba](https://github.com/hyperium/hyper/commit/093a29bab7eb27e78bb10506478ac486e8d61671))
+  * Fix formatting of 0 qualites and formatting of empty list header fields. ([621ef521](https://github.com/hyperium/hyper/commit/621ef521f6723ba2d59beff05ff39ae8fd6df2c3))
+
+
+#### Features
+
+* **client:**
+  * remove Clone requirement for NetworkStream in Client ([60d92c29](https://github.com/hyperium/hyper/commit/60d92c296a445b352679919c03c5ed2a2a297e16))
+  * accept &String as Body in RequestBuilder ([a2aefd9a](https://github.com/hyperium/hyper/commit/a2aefd9a5689d4816f7c054bd6c32aa5c6fe3087))
+  * accept &String for a Url in RequestBuilder ([8bc179fb](https://github.com/hyperium/hyper/commit/8bc179fb517735a7c1d5cd1d7f5598bb82914dc6))
+* **headers:** Implement Content-Language header field ([308880b4](https://github.com/hyperium/hyper/commit/308880b455df4dbb5d32817b5c0320c2a88139e3), closes [#475](https://github.com/hyperium/hyper/issues/475))
+* **net:** add https_using_context for user-supplied SslContext ([1a076d1b](https://github.com/hyperium/hyper/commit/1a076d1bc7e8fb9c58904b0cec879dcf0fbce97b))
+* **server:** allow consumer to supply an SslContext ([3a1a2427](https://github.com/hyperium/hyper/commit/3a1a24270dd13e22ef59120d66d327528949d5e0), closes [#471](https://github.com/hyperium/hyper/issues/471))
+
+
+#### Breaking Changes
+
+* This removes the trait `IntoBody`, and instead using
+  `Into<Body>`, as it's more idiomatic. This will only have broken code
+  that had custom implementations of `IntoBody`, and can be fixed by
+  changing them to `Into<Body>`.
+
+ ([a2aefd9a](https://github.com/hyperium/hyper/commit/a2aefd9a5689d4816f7c054bd6c32aa5c6fe3087))
+
+
+### v0.3.14 (2015-04-18)
+
+
+#### Bug Fixes
+
+* **http:** Adjust httparse Request and Response lifetimes. ([76550fdb](https://github.com/hyperium/hyper/commit/76550fdb20bb812e92a1fc3f3a7eaaf4a689348b))
+
+
+### v0.3.13 (2015-04-17)
+
+
+#### Bug Fixes
+
+* **server:** JoinHandle type parameter ([c694b138](https://github.com/hyperium/hyper/commit/c694b1385bd294e7c8e0398ee75e3a054ced5006))
+
+
+#### Features
+
+* **debug:** add Debug impls for StatusClass, Server, and Listening ([0fb92ee7](https://github.com/hyperium/hyper/commit/0fb92ee735136a07c832124df521b96a6779bd39))
+
+
+### v0.3.12 (2015-04-15)
+
+
+#### Bug Fixes
+
+* **server:**
+  * handle keep-alive closing ([d9187713](https://github.com/hyperium/hyper/commit/d9187713b2eaa628eb34f68c8a7201a6cf8e010d), closes [#437](https://github.com/hyperium/hyper/issues/437))
+  * join on thread when Listening drops ([68d4d63c](https://github.com/hyperium/hyper/commit/68d4d63c2a0289b72ec1442d13e1212a0479c50b), closes [#447](https://github.com/hyperium/hyper/issues/447))
+  * Use thread::spawn instead of thread::scoped. ([e8649567](https://github.com/hyperium/hyper/commit/e864956734af72bab07a3e01c9665bc1b7c96e5e))
+
+
+#### Features
+
+* **http:** Implement Debug for HttpReader/Writer. ([2f606c88](https://github.com/hyperium/hyper/commit/2f606c88bd91e5e36dee4c6db00c3117b1adf067))
+* **log:** clean up logging ([4f09b002](https://github.com/hyperium/hyper/commit/4f09b002ffb2d076fc8fb01d9b9e0464216b2b41))
+* **net:** make HttpStream implement Debug ([7b7f9c25](https://github.com/hyperium/hyper/commit/7b7f9c257d0e2d515bf336c567f12a625471e477))
+
+
+### v0.3.11 (2015-04-15)
+
+
+#### Bug Fixes
+
+* **headers:** Content-Encoding needs a hyphen. ([ca2815ef](https://github.com/hyperium/hyper/commit/ca2815effda2a5b27f781b7bc35105aa81121bae))
+
+
+#### Features
+
+* **client:** remove generic parameter for Connector ([139a51f1](https://github.com/hyperium/hyper/commit/139a51f1c31b80cdddf643e984bbbfbb3d3e8c96), closes [#379](https://github.com/hyperium/hyper/issues/379))
+
+
+#### Breaking Changes
+
+* `AccessControlAllowHeaders` and `AccessControlRequestHeaders` values
+are case insensitive now. `AccessControlAllowOrigin` variants are now `Any` and
+`Value` to match the other headers.
+
+ ([94f38950](https://github.com/hyperium/hyper/commit/94f38950ddf9a97fdc4f44e42aada4ed8f4d9b43))
+* `If-Match`, `If-None-Match` and `Vary` item variant name changed to `Items`
+
+ ([38d297b1](https://github.com/hyperium/hyper/commit/38d297b16e5d14d533947988f770f03b49d47a17))
+* `Etag` header field is now `ETag` header field
+
+ ([4434ea6a](https://github.com/hyperium/hyper/commit/4434ea6a7d57d367c0a541c82f6289ffbda5fb6c))
+* For people using the default HttpConnector and Client,
+    everything should continue to just work. If the Client has been
+    used with a generic parameter, it should be removed.
+
+    However, there were some breaking changes to the internals of
+    NetworkConnectors. Specifically, they no longer return a
+    NetworkStream, but instead a Into<Box<NetworkStream + Send>>. All
+    implementations of NetworkStream should continue to just work,
+    however.
+
+    Possible breakages could come from the stricter usage of Send
+    throughout the Client API.
+
+ ([139a51f1](https://github.com/hyperium/hyper/commit/139a51f1c31b80cdddf643e984bbbfbb3d3e8c96))
+
+
+### v0.3.10 (2015-04-06)
+
+
+#### Bug Fixes
+
+* **README:** Update to compile example against Rust beta ([341f19d3](https://github.com/hyperium/hyper/commit/341f19d3266c6de9a9a90c94f718124792766630))
+
+
+### v0.3.9 (2015-04-03)
+
+
+#### Bug Fixes
+
+* **headers:** Add CowStr as a temporary hack to build on beta. ([8e065563](https://github.com/hyperium/hyper/commit/8e0655637e80c5377c01da4dbca6fb627e6d4225))
+
+
+### v0.3.8 (2015-04-02)
+
+
+#### Bug Fixes
+
+* **rustup:** update to rust beta ([0f5858f3](https://github.com/hyperium/hyper/commit/0f5858f37974731243d47710364776fdd73376fe))
+
+
+#### Breaking Changes
+
+* Removed impl_header!() and impl_list_header!() macros,
+use new header!() macro.
+
+ ([262c450f](https://github.com/hyperium/hyper/commit/262c450f908dbf27754daff0784f0f20145036dd))
+
+
+### v0.3.7 (2015-03-31)
+
+
+#### Bug Fixes
+
+* **buffer:** zero out new capacity when buffer grows ([cfdabd70](https://github.com/hyperium/hyper/commit/cfdabd70ecc3f5290ae1e6f7e5dfd50310d8658d))
+
+
+#### Features
+
+* **entitytag:** Add EntityTag comparison, make EntityTag safe to use ([9c21f7f9](https://github.com/hyperium/hyper/commit/9c21f7f953a5163792e71fb186cab391c45d1bb4))
+
+
+### v0.3.6 (2015-03-30)
+
+
+#### Bug Fixes
+
+* **buffer:** get_buf to not return consumed part of buffer ([04e3b565](https://github.com/hyperium/hyper/commit/04e3b5651561f087fee7c0345fe77d217d3ad35a), closes [#406](https://github.com/hyperium/hyper/issues/406))
+* **rustup:** get rid of slice pattern, add `Reflect` bounds ([c9f2c841](https://github.com/hyperium/hyper/commit/c9f2c841ff0e68dead38e762ed5f8c0f42255bc4))
+
+
+### v0.3.5 (2015-03-28)
+
+
+#### Bug Fixes
+
+* **http:** read more before triggering TooLargeError ([cb59f609](https://github.com/hyperium/hyper/commit/cb59f609c61a097d5d9fa728b9df33d79922573b), closes [#389](https://github.com/hyperium/hyper/issues/389))
+
+
+### v0.3.4 (2015-03-26)
+
+
+#### Bug Fixes
+
+* **rustup:** static bounds required on Type definition, trivial_casts ([eee7a85d](https://github.com/hyperium/hyper/commit/eee7a85d3c3a3f51a1c3c12496c0e45ea312524e))
+
+
+### v0.3.3 (2015-03-25)
+
+
+#### Bug Fixes
+
+* **rustup:**
+  * rustc 1.0.0-nightly (123a754cb 2015-03-24) ([3e456f00](https://github.com/hyperium/hyper/commit/3e456f00f9991b1c723a232fc9c76fe8c0539858))
+  * 1.0.0-nightly (e2fa53e59 2015-03-20) ([f547080d](https://github.com/hyperium/hyper/commit/f547080df53076711b52a016b990c5be56f42ede))
+
+
+#### Features
+
+* **headers:** Implementing content-encoding header ([2983e8de](https://github.com/hyperium/hyper/commit/2983e8dea21f02a31012a25b0a302a128768030a), closes [#391](https://github.com/hyperium/hyper/issues/391))
+
+
+### v0.3.2 (2015-03-20)
+
+
+#### Bug Fixes
+
+* **benches:** removed unused features ([104d4903](https://github.com/hyperium/hyper/commit/104d49036ff40c730ec8bef8012f19ccbee4aaae))
+* **rustup:**
+  * rustc 1.0.0-nightly (ea8b82e90) ([8181de25](https://github.com/hyperium/hyper/commit/8181de253aecfe81123e166a141ebfc8430ec4a4))
+  * adapt to current rustc ([1f0bc951](https://github.com/hyperium/hyper/commit/1f0bc951c9ee40cab622a72d614d4c45d889ccd3), closes [#381](https://github.com/hyperium/hyper/issues/381))
+
+
+#### Features
+
+* **server:** use SocketAddrs instead of Ipv4Addrs ([5d7be77e](https://github.com/hyperium/hyper/commit/5d7be77e4ac0d5c1d852c1208abc77a913c4f4d1))
+
+
+### v0.3.1 (2015-03-18)
+
+
+#### Bug Fixes
+
+* **header:** Fix charset parsing bug. ([5a6e176f](https://github.com/hyperium/hyper/commit/5a6e176f50fe667fbdc4c933c81d2db5ba5c571d))
+* **headers:** Fix overflow with empty cookies ([99baaa10](https://github.com/hyperium/hyper/commit/99baaa10157f6c69ef1795a97e0db8bd794011f6))
+* **rustup:** update to latest rustc ([4fd8a6a9](https://github.com/hyperium/hyper/commit/4fd8a6a9dc0dc969b36f3d3ad51cee177545f883))
+
+
+#### Features
+
+* **server:** add Expect 100-continue support ([0b716943](https://github.com/hyperium/hyper/commit/0b7169432b5f51efe5c167be418c2c50220e46a5), closes [#369](https://github.com/hyperium/hyper/issues/369))
+
+
+#### Breaking Changes
+
+* Several public functions and types in the `http` module
+  have been removed. They have been replaced with 2 methods that handle
+  all of the http1 parsing.
+
+ ([b87bb20f](https://github.com/hyperium/hyper/commit/b87bb20f0c25891c30ef2399da2721596fbc1fcf))
+
+
+## v0.3.0 (2015-03-03)
+
+
+#### Features
+
+* **headers:**
+  * add enum for Charset ([180d9a92](https://github.com/hyperium/hyper/commit/180d9a92d92541aa415c918a2265bd6b33d39655))
+  * add AcceptCharset header ([235089a1](https://github.com/hyperium/hyper/commit/235089a1034dc93ca62f47dcab0a93f1d49c72dd))
+  * add q function to ease creating Quality values ([d68773c7](https://github.com/hyperium/hyper/commit/d68773c79f998813bbd1bf50a0dbc2bc01ee0470))
+  * adds re-parsing ability when getting typed headers ([df756871](https://github.com/hyperium/hyper/commit/df756871edf4143135644c211106c5a8f8f5adb0))
+* **hyper:** switch to std::io, std::net, and std::path. ([0fd6fcd7](https://github.com/hyperium/hyper/commit/0fd6fcd7c7f30c4317678a3b0968cc08ae9c0a71), closes [#347](https://github.com/hyperium/hyper/issues/347))
+
+
+#### Breaking Changes
+
+* added requirement that all HeaderFormat implementations
+  must also be fmt::Debug. This likely as easy as slapping
+  #[derive(Debug)] on to any custom headers.
+
+ ([df756871](https://github.com/hyperium/hyper/commit/df756871edf4143135644c211106c5a8f8f5adb0))
+* Check the docs. Everything was touched.
+
+ ([0fd6fcd7](https://github.com/hyperium/hyper/commit/0fd6fcd7c7f30c4317678a3b0968cc08ae9c0a71))
+
+
+### v0.2.1 (2015-02-27)
+
+
+#### Bug Fixes
+
+* **rustup:** str.split and associated type changes ([1b6e6a04](https://github.com/hyperium/hyper/commit/1b6e6a040fa26a8b3855ac46ccbcd5ee78065c71))
+
+
+#### Features
+
+* **headers:** add remove_raw method and corresponding test ([4f576780](https://github.com/hyperium/hyper/commit/4f576780c24ff3f943d5f821730ba65f4cdf8d4a), closes [#326](https://github.com/hyperium/hyper/issues/326))
+
+
+## v0.2.0 (2015-02-21)
+
+
+#### Bug Fixes
+
+* **headers:** use $crate when referring to hyper modules on macros ([e246c3ac](https://github.com/hyperium/hyper/commit/e246c3ace8395cb5d281b841a416c503db1054ee), closes [#323](https://github.com/hyperium/hyper/issues/323))
+* **rustup:**
+  * Send changes ([4f5b97fe](https://github.com/hyperium/hyper/commit/4f5b97fefcea650214ca26c1aa197cd73683742f))
+  * CowString is gone ([98b8c4b1](https://github.com/hyperium/hyper/commit/98b8c4b13723d8fa1b4f1ba42a06bb533bf13694))
+  * Extend now takes an IntoIterator ([598d8f93](https://github.com/hyperium/hyper/commit/598d8f93e4a79dcc5ff58fbdc27e6b1a859786d1))
+  * Add PhantomData markers to phantom type users ([1904c456](https://github.com/hyperium/hyper/commit/1904c4561f00a345714beadfa077016306b2c05d))
+  * Remove uses of the obsolete &a[] syntax ([039e984f](https://github.com/hyperium/hyper/commit/039e984f6878d724d47f7e9fe7db765495ae2f10))
+  * Fix signature of IntoCow ([234fcdc3](https://github.com/hyperium/hyper/commit/234fcdc3a25deb06240848d601be9e68930a73e6))
+  * update feature flags ([b47f9365](https://github.com/hyperium/hyper/commit/b47f936525dde91b3456078ecf8d0c11917cc6b7))
+  * use module-level thread functions ([fc2076cd](https://github.com/hyperium/hyper/commit/fc2076cd53c37ea244a0b89d7dd4b1eb8aeeb1d3))
+  * update lifetime bounds ([f4a66b38](https://github.com/hyperium/hyper/commit/f4a66b38cb9e35bfec0bbc3c97e5298fc8ad8409))
+
+
+#### Features
+
+* **server:** make AcceptorPool::accept() block and allow non'-static data ([b0a72d80](https://github.com/hyperium/hyper/commit/b0a72d80d0e894220da6aa5ea29d71b278df596d))
+
+
+### v0.1.13 (2015-02-17)
+
+
+#### Bug Fixes
+
+* **server:** Drain requests on drop. ([3d0f423e](https://github.com/hyperium/hyper/commit/3d0f423eb26c4f14aaf9f8a909b307f661a3c5d6), closes [#197](https://github.com/hyperium/hyper/issues/197), [#309](https://github.com/hyperium/hyper/issues/309))
+
+
+#### Features
+
+* **header:** Support arbitrary status codes ([73978531](https://github.com/hyperium/hyper/commit/7397853148b8221c0eb8315ae2e5f195ad2e642c))
+* **headers:**
+  * Implement PartialOrd for QualityItem ([2859d7ef](https://github.com/hyperium/hyper/commit/2859d7ef4ecadc3927fa46292ebbb225da597690), closes [#314](https://github.com/hyperium/hyper/issues/314))
+  * add AcceptLanguage header ([20a585e3](https://github.com/hyperium/hyper/commit/20a585e30bbb060a91839de7e95fd75a95d03d93))
+  * add IfMatch header ([5df06d44](https://github.com/hyperium/hyper/commit/5df06d4465fae01ef08b926f1f3be9f32a0f5c80))
+* **server:** Rewrite the accept loop into a custom thread pool. ([3528fb9b](https://github.com/hyperium/hyper/commit/3528fb9b015a0959268452d5b42d5544c7b98a6a))
+
+
+#### Breaking Changes
+
+* This removes unregistered status codes from the enum. Use
+`FromPrimitive` methods to create them now. StatusCode and StatusClass can no
+longer be casted to `u16`, use `ToPrimitive` methods now.
+For example `status.to_u16().unwrap()` to get the status code number.
+
+ ([73978531](https://github.com/hyperium/hyper/commit/7397853148b8221c0eb8315ae2e5f195ad2e642c))
+
+
+### v0.1.12 (2015-02-13)
+
+
+#### Bug Fixes
+
+* **net:** don't stop the server when an SSL handshake fails with EOF ([55f12660](https://github.com/hyperium/hyper/commit/55f12660891812d13a59e799b0ab5b185926479a))
+
+
+#### Features
+
+* **headers:** Add `If-None-Match` header field ([318b067a](https://github.com/hyperium/hyper/commit/318b067a06ecb42f0fba51928675d3b4291c7643), closes [#238](https://github.com/hyperium/hyper/issues/238))
+
+
+### v0.1.11 (2015-02-06)
+
+
+#### Bug Fixes
+
+* **readme:** Make the README client example work ([9b5d6aab](https://github.com/hyperium/hyper/commit/9b5d6aab7e68cf776618151e9e69e34fd66aba6c))
+
+
+#### Features
+
+* **headers:** add IfUnmodifiedSince header ([b5543b67](https://github.com/hyperium/hyper/commit/b5543b67525e3d6ebc655d7e1736c8ade5b6dbb0))
+
+
+#### Breaking Changes
+
+* for any consumers of the Etag header, since the entity
+tag is now in a tuple.
+
+ ([28fd5c81](https://github.com/hyperium/hyper/commit/28fd5c81f54bb0ea3eda43a4014c736d00b4b07d))
+
+
+### v0.1.10 (2015-02-03)
+
+
+#### Bug Fixes
+
+* **headers:** add limit to maximum header size that should be parsed ([f18a8fb7](https://github.com/hyperium/hyper/commit/f18a8fb76f15f36dec329683abb66be203ab2e7e), closes [#256](https://github.com/hyperium/hyper/issues/256))
+* **rustup:**
+  * update FromStr ([742081c8](https://github.com/hyperium/hyper/commit/742081c8cfeeb59908a653316a6377d05ffaa55c))
+  * fix unused_feature warning in example server ([05a3a6b7](https://github.com/hyperium/hyper/commit/05a3a6b70badc28da33ff65e8c15003f87738e07))
+  * switch to unstable features ([3af8b687](https://github.com/hyperium/hyper/commit/3af8b687d4a6ef462eb74b1f5a1cbb8f191902fd))
+
+
+### v0.1.9 (2015-01-28)
+
+
+#### Bug Fixes
+
+* **headers:** Don't display q if q=1 in quality item. ([91df2441](https://github.com/hyperium/hyper/commit/91df2441a0bb8c032b6fc5ccff50ed0eb98f2194), closes [#281](https://github.com/hyperium/hyper/issues/281))
+* **rustup:** update io import, Writer::write ([f606b603](https://github.com/hyperium/hyper/commit/f606b6039d15a0b6e46f5154a9c5482866497a0c))
+
+
+#### Features
+
+* **status:** add is_<status_class>() methods to StatusCodes ([2d55a22e](https://github.com/hyperium/hyper/commit/2d55a22e738fb7f37a271be4fc3cf2ebdb9b5345))
+
+
+### v0.1.8 (2015-01-27)
+
+
+#### Bug Fixes
+
+* **headers:**
+  * make ConnectionHeader unicase ([e06e7d9a](https://github.com/hyperium/hyper/commit/e06e7d9a7ece9588b673b06df6aec4663595df30))
+  * make Protocol search websocket unicase ([65c70180](https://github.com/hyperium/hyper/commit/65c7018046eb556085ca47a28c980ec901980643))
+* **log:** update to new logging levels ([b002b6c3](https://github.com/hyperium/hyper/commit/b002b6c3f09775e5d6759bbd07dacdee318c2915))
+
+
+#### Features
+
+* **headers:** Add `Pragma` header field ([767c95d2](https://github.com/hyperium/hyper/commit/767c95d2b9709b496b35d0d691ff7a1f6d35cbed), closes [#237](https://github.com/hyperium/hyper/issues/237))
+
+
+#### Breaking Changes
+
+* Change header `Cookie` to `Cookie`
+
+ ([92f43cf8](https://github.com/hyperium/hyper/commit/92f43cf873ddceca9518195af6dad1ff6ac79e11))
+
+
+### v0.1.7 (2015-01-27)
+
+
+#### Bug Fixes
+
+* **rustup:** update to newest fmt trait names and slice syntax ([9e3c94d7](https://github.com/hyperium/hyper/commit/9e3c94d764522f900731fdbdee857639901037fe))
+
+
+#### Breaking Changes
+
+* Implementations of Header will need to adjust the
+    header_name method. It no longer takes any arguments.
+
+ ([8215889e](https://github.com/hyperium/hyper/commit/8215889eda537d09da82a7ed12a1766bf4fd3bfe))
+
+
+### v0.1.6 (2015-01-27)
+
+
+#### Bug Fixes
+
+* **headers:** make Schemes, Basic, Protocol public ([e43c35c1](https://github.com/hyperium/hyper/commit/e43c35c1ca86c0ff1278ccfe3d2cff43222627b2))
+
+
+### v0.1.5 (2015-01-27)
+
+
+### v0.1.4 (2015-01-27)
+
+
+#### Bug Fixes
+
+* **imports:** Update TypeID import location to "any" ([dd2534a6](https://github.com/hyperium/hyper/commit/dd2534a6863f8b3940d2776e6b6a8e48988b9b88))
+
+
+### v0.1.3 (2015-01-27)
+
+
+#### Features
+
+* **server:** add a deconstruct method to Request. ([1014855f](https://github.com/hyperium/hyper/commit/1014855faec62ba00acdff6263c86e7dfa5fb047))
+
+
+### v0.1.2 (2015-01-27)
+
+
+#### Bug Fixes
+
+* **server:** Increase MAX_HEADER_FIELD_LENGTH to 4k ([54238b28](https://github.com/hyperium/hyper/commit/54238b28e4899e76bb3d7c2dfd8d9bc6fd489b6c))
+
+
+#### Features
+
+* **net:**
+  * Move SSL verification to unboxed closures ([bca9a53c](https://github.com/hyperium/hyper/commit/bca9a53c66c967affb8e245f26507494db39c35e))
+  * Allow more generic SSL verification () ([af577851](https://github.com/hyperium/hyper/commit/af5778510d1d8422fcb04873f7c726a67f15f5eb), closes [#244](https://github.com/hyperium/hyper/issues/244))
+
+
+### 0.1.1 (2015-01-13)
+
+#### Features
+
+* **server:**: Add TLS/SSL support serverside ([c6eef681](c6eef6812458e10de582530d7f2c5bce5156b73c), closes [#1](https://github.com/hyperium/hyper/issues/1))
+
+
+#### Bug Fixes
+
+* **headers:**
+    * fix fmt_header outputs of several headers ([aa266653](https://github.com/hyperium/hyper/commit/aa26665367bde895ce02ad2a8e1a372f00719852), closes [#246](https://github.com/hyperium/hyper/issues/246))
+    * don't use Show to write UserAgent header ([c8e334aa](https://github.com/hyperium/hyper/commit/c8e334aaebb5522a86d47f7e3c33836d2061cb65))
diff --git a/hyper/CONTRIBUTING.md b/hyper/CONTRIBUTING.md
new file mode 100644
index 0000000..56e31dd
--- /dev/null
+++ b/hyper/CONTRIBUTING.md
@@ -0,0 +1,11 @@
+# Contributing to Hyper
+
+You want to contribute? You're awesome! Don't know where to start? Check the [list of easy issues](https://github.com/hyperium/hyper/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy).
+
+[easy tag]: https://github.com/hyperium/hyper/issues?q=label%3AE-easy+is%3Aopen
+
+
+## [Pull Requests](./docs/PULL_REQUESTS.md)
+
+- [Submitting a Pull Request](./docs/PULL_REQUESTS.md#submitting-a-pull-request)
+- [Commit Guidelines](./docs/COMMITS.md)
diff --git a/hyper/Cargo.toml b/hyper/Cargo.toml
new file mode 100644
index 0000000..a76b210
--- /dev/null
+++ b/hyper/Cargo.toml
@@ -0,0 +1,252 @@
+[package]
+name = "hyper"
+version = "0.14.24"
+description = "A fast and correct HTTP library."
+readme = "README.md"
+homepage = "https://hyper.rs"
+documentation = "https://docs.rs/hyper"
+repository = "https://github.com/hyperium/hyper"
+license = "MIT"
+authors = ["Sean McArthur <sean@seanmonstar.com>"]
+keywords = ["http", "hyper", "hyperium"]
+categories = ["network-programming", "web-programming::http-client", "web-programming::http-server"]
+edition = "2018"
+
+include = [
+  "Cargo.toml",
+  "LICENSE",
+  "src/**/*",
+  #"build.rs",
+]
+
+[dependencies]
+bytes = "1"
+futures-core = { version = "0.3", default-features = false }
+futures-channel = "0.3"
+futures-util = { version = "0.3", default-features = false }
+http = "0.2"
+http-body = "0.4"
+httpdate = "1.0"
+httparse = "1.8"
+h2 = { version = "0.3.9", optional = true }
+itoa = "1"
+tracing = { version = "0.1", default-features = false, features = ["std"] }
+pin-project-lite = "0.2.4"
+tower-service = "0.3"
+tokio = { version = "1", features = ["sync"] }
+want = "0.3"
+
+# Optional
+
+libc = { version = "0.2", optional = true }
+socket2 = { version = "0.4.7", optional = true, features = ["all"] }
+
+[dev-dependencies]
+futures-util = { version = "0.3", default-features = false, features = ["alloc"] }
+matches = "0.1"
+num_cpus = "1.0"
+pretty_env_logger = "0.4"
+spmc = "0.3"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+tokio = { version = "1", features = [
+    "fs",
+    "macros",
+    "io-std",
+    "io-util",
+    "rt",
+    "rt-multi-thread", # so examples can use #[tokio::main]
+    "sync",
+    "time",
+    "test-util",
+] }
+tokio-test = "0.4"
+tokio-util = { version = "0.7", features = ["codec"] }
+tower = { version = "0.4", features = ["make", "util"] }
+url = "2.2"
+
+[target.'cfg(any(target_os = "linux", target_os = "macos"))'.dev-dependencies]
+pnet_datalink = "0.27.2"
+
+[features]
+# Nothing by default
+default = []
+
+# Easily turn it all on
+full = [
+    "client",
+    "http1",
+    "http2",
+    "server",
+    "stream",
+    "runtime",
+]
+
+# HTTP versions
+http1 = []
+http2 = ["h2"]
+
+# Client/Server
+client = []
+server = []
+
+# `impl Stream` for things
+stream = []
+
+# Tokio support
+runtime = [
+    "tcp",
+    "tokio/rt",
+    "tokio/time",
+]
+tcp = [
+    "socket2",
+    "tokio/net",
+    "tokio/rt",
+    "tokio/time",
+]
+
+# C-API support (currently unstable (no semver))
+ffi = ["libc"]
+
+# internal features used in CI
+nightly = []
+__internal_happy_eyeballs_tests = []
+
+[package.metadata.docs.rs]
+features = ["ffi", "full"]
+rustdoc-args = ["--cfg", "docsrs", "--cfg", "hyper_unstable_ffi"]
+
+[package.metadata.playground]
+features = ["full"]
+
+[profile.release]
+codegen-units = 1
+incremental = false
+
+[profile.bench]
+codegen-units = 1
+incremental = false
+
+[[example]]
+name = "client"
+path = "examples/client.rs"
+required-features = ["full"]
+
+[[example]]
+name = "client_json"
+path = "examples/client_json.rs"
+required-features = ["full"]
+
+[[example]]
+name = "echo"
+path = "examples/echo.rs"
+required-features = ["full"]
+
+[[example]]
+name = "gateway"
+path = "examples/gateway.rs"
+required-features = ["full"]
+
+[[example]]
+name = "hello"
+path = "examples/hello.rs"
+required-features = ["full"]
+
+[[example]]
+name = "http_proxy"
+path = "examples/http_proxy.rs"
+required-features = ["full"]
+
+[[example]]
+name = "multi_server"
+path = "examples/multi_server.rs"
+required-features = ["full"]
+
+[[example]]
+name = "params"
+path = "examples/params.rs"
+required-features = ["full"]
+
+[[example]]
+name = "send_file"
+path = "examples/send_file.rs"
+required-features = ["full"]
+
+[[example]]
+name = "service_struct_impl"
+path = "examples/service_struct_impl.rs"
+required-features = ["full"]
+
+[[example]]
+name = "single_threaded"
+path = "examples/single_threaded.rs"
+required-features = ["full"]
+
+[[example]]
+name = "state"
+path = "examples/state.rs"
+required-features = ["full"]
+
+[[example]]
+name = "tower_client"
+path = "examples/tower_client.rs"
+required-features = ["full"]
+
+[[example]]
+name = "tower_server"
+path = "examples/tower_server.rs"
+required-features = ["full"]
+
+[[example]]
+name = "upgrades"
+path = "examples/upgrades.rs"
+required-features = ["full"]
+
+
+[[example]]
+name = "web_api"
+path = "examples/web_api.rs"
+required-features = ["full"]
+
+
+[[bench]]
+name = "body"
+path = "benches/body.rs"
+required-features = ["full"]
+
+[[bench]]
+name = "connect"
+path = "benches/connect.rs"
+required-features = ["full"]
+
+[[bench]]
+name = "end_to_end"
+path = "benches/end_to_end.rs"
+required-features = ["full"]
+
+[[bench]]
+name = "pipeline"
+path = "benches/pipeline.rs"
+required-features = ["full"]
+
+[[bench]]
+name = "server"
+path = "benches/server.rs"
+required-features = ["full"]
+
+
+[[test]]
+name = "client"
+path = "tests/client.rs"
+required-features = ["full"]
+
+[[test]]
+name = "integration"
+path = "tests/integration.rs"
+required-features = ["full"]
+
+[[test]]
+name = "server"
+path = "tests/server.rs"
+required-features = ["full"]
diff --git a/hyper/LICENSE b/hyper/LICENSE
new file mode 100644
index 0000000..bc1e966
--- /dev/null
+++ b/hyper/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014-2021 Sean McArthur
+
+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.
diff --git a/hyper/README.md b/hyper/README.md
new file mode 100644
index 0000000..c3c73d7
--- /dev/null
+++ b/hyper/README.md
@@ -0,0 +1,41 @@
+# [hyper](https://hyper.rs)
+
+[![crates.io](https://img.shields.io/crates/v/hyper.svg)](https://crates.io/crates/hyper)
+[![Released API docs](https://docs.rs/hyper/badge.svg)](https://docs.rs/hyper)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![CI](https://github.com/hyperium/hyper/workflows/CI/badge.svg)](https://github.com/hyperium/hyper/actions?query=workflow%3ACI)
+[![Discord chat][discord-badge]][discord-url]
+
+A **fast** and **correct** HTTP implementation for Rust.
+
+- HTTP/1 and HTTP/2
+- Asynchronous design
+- Leading in performance
+- Tested and **correct**
+- Extensive production use
+- Client and Server APIs
+
+**Get started** by looking over the [guides](https://hyper.rs/guides).
+
+## "Low-level"
+
+hyper is a relatively low-level library, meant to be a building block for
+libraries and applications.
+
+If you are looking for a convenient HTTP client, then you may wish to consider
+[reqwest](https://github.com/seanmonstar/reqwest). If you are looking for a
+convenient HTTP server, then you may wish to consider [warp](https://github.com/seanmonstar/warp).
+Both are built on top of this library.
+
+## Contributing
+
+To get involved, take a look at [CONTRIBUTING](CONTRIBUTING.md).
+
+If you prefer chatting, there is an active community in the [Discord server][discord-url].
+
+## License
+
+hyper is provided under the MIT license. See [LICENSE](LICENSE).
+
+[discord-badge]: https://img.shields.io/discord/500028886025895936.svg?logo=discord
+[discord-url]: https://discord.gg/kkwpueZ
diff --git a/hyper/SECURITY.md b/hyper/SECURITY.md
new file mode 100644
index 0000000..b074a57
--- /dev/null
+++ b/hyper/SECURITY.md
@@ -0,0 +1,9 @@
+# Security Policy
+
+hyper (and related projects in hyperium) use the same security policy as the [Tokio project][tokio-security].
+
+## Report a security issue
+
+The process for reporting an issue is the same as the [Tokio project][tokio-security]. This includes private reporting via security@tokio.rs.
+
+[tokio-security]: https://github.com/tokio-rs/tokio/security/policy
diff --git a/hyper/benches/body.rs b/hyper/benches/body.rs
new file mode 100644
index 0000000..255914d
--- /dev/null
+++ b/hyper/benches/body.rs
@@ -0,0 +1,88 @@
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate test;
+
+use bytes::Buf;
+use futures_util::stream;
+use futures_util::StreamExt;
+use hyper::body::Body;
+
+macro_rules! bench_stream {
+    ($bencher:ident, bytes: $bytes:expr, count: $count:expr, $total_ident:ident, $body_pat:pat, $block:expr) => {{
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .build()
+            .expect("rt build");
+
+        let $total_ident: usize = $bytes * $count;
+        $bencher.bytes = $total_ident as u64;
+        let __s: &'static [&'static [u8]] = &[&[b'x'; $bytes] as &[u8]; $count] as _;
+
+        $bencher.iter(|| {
+            rt.block_on(async {
+                let $body_pat = Body::wrap_stream(
+                    stream::iter(__s.iter()).map(|&s| Ok::<_, std::convert::Infallible>(s)),
+                );
+                $block;
+            });
+        });
+    }};
+}
+
+macro_rules! benches {
+    ($($name:ident, $bytes:expr, $count:expr;)+) => (
+        mod aggregate {
+            use super::*;
+
+            $(
+            #[bench]
+            fn $name(b: &mut test::Bencher) {
+                bench_stream!(b, bytes: $bytes, count: $count, total, body, {
+                    let buf = hyper::body::aggregate(body).await.unwrap();
+                    assert_eq!(buf.remaining(), total);
+                });
+            }
+            )+
+        }
+
+        mod manual_into_vec {
+            use super::*;
+
+            $(
+            #[bench]
+            fn $name(b: &mut test::Bencher) {
+                bench_stream!(b, bytes: $bytes, count: $count, total, mut body, {
+                    let mut vec = Vec::new();
+                    while let Some(chunk) = body.next().await {
+                        vec.extend_from_slice(&chunk.unwrap());
+                    }
+                    assert_eq!(vec.len(), total);
+                });
+            }
+            )+
+        }
+
+        mod to_bytes {
+            use super::*;
+
+            $(
+            #[bench]
+            fn $name(b: &mut test::Bencher) {
+                bench_stream!(b, bytes: $bytes, count: $count, total, body, {
+                    let bytes = hyper::body::to_bytes(body).await.unwrap();
+                    assert_eq!(bytes.len(), total);
+                });
+            }
+            )+
+        }
+    )
+}
+
+// ===== Actual Benchmarks =====
+
+benches! {
+    bytes_1_000_count_2, 1_000, 2;
+    bytes_1_000_count_10, 1_000, 10;
+    bytes_10_000_count_1, 10_000, 1;
+    bytes_10_000_count_10, 10_000, 10;
+}
diff --git a/hyper/benches/connect.rs b/hyper/benches/connect.rs
new file mode 100644
index 0000000..eafb8fd
--- /dev/null
+++ b/hyper/benches/connect.rs
@@ -0,0 +1,37 @@
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate test;
+
+use http::Uri;
+use hyper::client::connect::HttpConnector;
+use hyper::service::Service;
+use std::net::SocketAddr;
+use tokio::net::TcpListener;
+
+#[bench]
+fn http_connector(b: &mut test::Bencher) {
+    let _ = pretty_env_logger::try_init();
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .expect("rt build");
+    let listener = rt
+        .block_on(TcpListener::bind(&SocketAddr::from(([127, 0, 0, 1], 0))))
+        .expect("bind");
+    let addr = listener.local_addr().expect("local_addr");
+    let dst: Uri = format!("http://{}/", addr).parse().expect("uri parse");
+    let mut connector = HttpConnector::new();
+
+    rt.spawn(async move {
+        loop {
+            let _ = listener.accept().await;
+        }
+    });
+
+    b.iter(|| {
+        rt.block_on(async {
+            connector.call(dst.clone()).await.expect("connect");
+        });
+    });
+}
diff --git a/hyper/benches/end_to_end.rs b/hyper/benches/end_to_end.rs
new file mode 100644
index 0000000..64efb92
--- /dev/null
+++ b/hyper/benches/end_to_end.rs
@@ -0,0 +1,382 @@
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate test;
+
+use std::net::SocketAddr;
+
+use futures_util::future::join_all;
+
+use hyper::client::HttpConnector;
+use hyper::{body::HttpBody as _, Body, Method, Request, Response, Server};
+
+// HTTP1
+
+#[bench]
+fn http1_consecutive_x1_empty(b: &mut test::Bencher) {
+    opts().bench(b)
+}
+
+#[bench]
+fn http1_consecutive_x1_req_10b(b: &mut test::Bencher) {
+    opts()
+        .method(Method::POST)
+        .request_body(&[b's'; 10])
+        .bench(b)
+}
+
+#[bench]
+fn http1_consecutive_x1_both_100kb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 100];
+    opts()
+        .method(Method::POST)
+        .request_body(body)
+        .response_body(body)
+        .bench(b)
+}
+
+#[bench]
+fn http1_consecutive_x1_both_10mb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 1024 * 10];
+    opts()
+        .method(Method::POST)
+        .request_body(body)
+        .response_body(body)
+        .bench(b)
+}
+
+#[bench]
+fn http1_parallel_x10_empty(b: &mut test::Bencher) {
+    opts().parallel(10).bench(b)
+}
+
+#[bench]
+fn http1_parallel_x10_req_10mb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 1024 * 10];
+    opts()
+        .parallel(10)
+        .method(Method::POST)
+        .request_body(body)
+        .bench(b)
+}
+
+#[bench]
+fn http1_parallel_x10_req_10kb_100_chunks(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 10];
+    opts()
+        .parallel(10)
+        .method(Method::POST)
+        .request_chunks(body, 100)
+        .bench(b)
+}
+
+#[bench]
+fn http1_parallel_x10_res_1mb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 1024 * 1];
+    opts().parallel(10).response_body(body).bench(b)
+}
+
+#[bench]
+fn http1_parallel_x10_res_10mb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 1024 * 10];
+    opts().parallel(10).response_body(body).bench(b)
+}
+
+// HTTP2
+
+const HTTP2_MAX_WINDOW: u32 = std::u32::MAX >> 1;
+
+#[bench]
+fn http2_consecutive_x1_empty(b: &mut test::Bencher) {
+    opts().http2().bench(b)
+}
+
+#[bench]
+fn http2_consecutive_x1_req_10b(b: &mut test::Bencher) {
+    opts()
+        .http2()
+        .method(Method::POST)
+        .request_body(&[b's'; 10])
+        .bench(b)
+}
+
+#[bench]
+fn http2_consecutive_x1_req_100kb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 100];
+    opts()
+        .http2()
+        .method(Method::POST)
+        .request_body(body)
+        .bench(b)
+}
+
+#[bench]
+fn http2_parallel_x10_empty(b: &mut test::Bencher) {
+    opts().http2().parallel(10).bench(b)
+}
+
+#[bench]
+fn http2_parallel_x10_req_10mb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 1024 * 10];
+    opts()
+        .http2()
+        .parallel(10)
+        .method(Method::POST)
+        .request_body(body)
+        .http2_stream_window(HTTP2_MAX_WINDOW)
+        .http2_conn_window(HTTP2_MAX_WINDOW)
+        .bench(b)
+}
+
+#[bench]
+fn http2_parallel_x10_req_10kb_100_chunks(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 10];
+    opts()
+        .http2()
+        .parallel(10)
+        .method(Method::POST)
+        .request_chunks(body, 100)
+        .bench(b)
+}
+
+#[bench]
+fn http2_parallel_x10_req_10kb_100_chunks_adaptive_window(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 10];
+    opts()
+        .http2()
+        .parallel(10)
+        .method(Method::POST)
+        .request_chunks(body, 100)
+        .http2_adaptive_window()
+        .bench(b)
+}
+
+#[bench]
+fn http2_parallel_x10_req_10kb_100_chunks_max_window(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 10];
+    opts()
+        .http2()
+        .parallel(10)
+        .method(Method::POST)
+        .request_chunks(body, 100)
+        .http2_stream_window(HTTP2_MAX_WINDOW)
+        .http2_conn_window(HTTP2_MAX_WINDOW)
+        .bench(b)
+}
+
+#[bench]
+fn http2_parallel_x10_res_1mb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 1024 * 1];
+    opts()
+        .http2()
+        .parallel(10)
+        .response_body(body)
+        .http2_stream_window(HTTP2_MAX_WINDOW)
+        .http2_conn_window(HTTP2_MAX_WINDOW)
+        .bench(b)
+}
+
+#[bench]
+fn http2_parallel_x10_res_10mb(b: &mut test::Bencher) {
+    let body = &[b'x'; 1024 * 1024 * 10];
+    opts()
+        .http2()
+        .parallel(10)
+        .response_body(body)
+        .http2_stream_window(HTTP2_MAX_WINDOW)
+        .http2_conn_window(HTTP2_MAX_WINDOW)
+        .bench(b)
+}
+
+// ==== Benchmark Options =====
+
+struct Opts {
+    http2: bool,
+    http2_stream_window: Option<u32>,
+    http2_conn_window: Option<u32>,
+    http2_adaptive_window: bool,
+    parallel_cnt: u32,
+    request_method: Method,
+    request_body: Option<&'static [u8]>,
+    request_chunks: usize,
+    response_body: &'static [u8],
+}
+
+fn opts() -> Opts {
+    Opts {
+        http2: false,
+        http2_stream_window: None,
+        http2_conn_window: None,
+        http2_adaptive_window: false,
+        parallel_cnt: 1,
+        request_method: Method::GET,
+        request_body: None,
+        request_chunks: 0,
+        response_body: b"",
+    }
+}
+
+impl Opts {
+    fn http2(mut self) -> Self {
+        self.http2 = true;
+        self
+    }
+
+    fn http2_stream_window(mut self, sz: impl Into<Option<u32>>) -> Self {
+        assert!(!self.http2_adaptive_window);
+        self.http2_stream_window = sz.into();
+        self
+    }
+
+    fn http2_conn_window(mut self, sz: impl Into<Option<u32>>) -> Self {
+        assert!(!self.http2_adaptive_window);
+        self.http2_conn_window = sz.into();
+        self
+    }
+
+    fn http2_adaptive_window(mut self) -> Self {
+        assert!(self.http2_stream_window.is_none());
+        assert!(self.http2_conn_window.is_none());
+        self.http2_adaptive_window = true;
+        self
+    }
+
+    fn method(mut self, m: Method) -> Self {
+        self.request_method = m;
+        self
+    }
+
+    fn request_body(mut self, body: &'static [u8]) -> Self {
+        self.request_body = Some(body);
+        self
+    }
+
+    fn request_chunks(mut self, chunk: &'static [u8], cnt: usize) -> Self {
+        assert!(cnt > 0);
+        self.request_body = Some(chunk);
+        self.request_chunks = cnt;
+        self
+    }
+
+    fn response_body(mut self, body: &'static [u8]) -> Self {
+        self.response_body = body;
+        self
+    }
+
+    fn parallel(mut self, cnt: u32) -> Self {
+        assert!(cnt > 0, "parallel count must be larger than 0");
+        self.parallel_cnt = cnt;
+        self
+    }
+
+    fn bench(self, b: &mut test::Bencher) {
+        use std::sync::Arc;
+        let _ = pretty_env_logger::try_init();
+        // Create a runtime of current thread.
+        let rt = Arc::new(
+            tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .expect("rt build"),
+        );
+        let exec = rt.clone();
+
+        let req_len = self.request_body.map(|b| b.len()).unwrap_or(0) as u64;
+        let req_len = if self.request_chunks > 0 {
+            req_len * self.request_chunks as u64
+        } else {
+            req_len
+        };
+        let bytes_per_iter = (req_len + self.response_body.len() as u64) * self.parallel_cnt as u64;
+        b.bytes = bytes_per_iter;
+
+        let addr = spawn_server(&rt, &self);
+
+        let connector = HttpConnector::new();
+        let client = hyper::Client::builder()
+            .http2_only(self.http2)
+            .http2_initial_stream_window_size(self.http2_stream_window)
+            .http2_initial_connection_window_size(self.http2_conn_window)
+            .http2_adaptive_window(self.http2_adaptive_window)
+            .build::<_, Body>(connector);
+
+        let url: hyper::Uri = format!("http://{}/hello", addr).parse().unwrap();
+
+        let make_request = || {
+            let chunk_cnt = self.request_chunks;
+            let body = if chunk_cnt > 0 {
+                let (mut tx, body) = Body::channel();
+                let chunk = self
+                    .request_body
+                    .expect("request_chunks means request_body");
+                exec.spawn(async move {
+                    for _ in 0..chunk_cnt {
+                        tx.send_data(chunk.into()).await.expect("send_data");
+                    }
+                });
+                body
+            } else {
+                self.request_body
+                    .map(Body::from)
+                    .unwrap_or_else(Body::empty)
+            };
+            let mut req = Request::new(body);
+            *req.method_mut() = self.request_method.clone();
+            *req.uri_mut() = url.clone();
+            req
+        };
+
+        let send_request = |req: Request<Body>| {
+            let fut = client.request(req);
+            async {
+                let res = fut.await.expect("client wait");
+                let mut body = res.into_body();
+                while let Some(_chunk) = body.data().await {}
+            }
+        };
+
+        if self.parallel_cnt == 1 {
+            b.iter(|| {
+                let req = make_request();
+                rt.block_on(send_request(req));
+            });
+        } else {
+            b.iter(|| {
+                let futs = (0..self.parallel_cnt).map(|_| {
+                    let req = make_request();
+                    send_request(req)
+                });
+                // Await all spawned futures becoming completed.
+                rt.block_on(join_all(futs));
+            });
+        }
+    }
+}
+
+fn spawn_server(rt: &tokio::runtime::Runtime, opts: &Opts) -> SocketAddr {
+    use hyper::service::{make_service_fn, service_fn};
+    let addr = "127.0.0.1:0".parse().unwrap();
+
+    let body = opts.response_body;
+    let srv = rt.block_on(async move {
+        Server::bind(&addr)
+            .http2_only(opts.http2)
+            .http2_initial_stream_window_size(opts.http2_stream_window)
+            .http2_initial_connection_window_size(opts.http2_conn_window)
+            .http2_adaptive_window(opts.http2_adaptive_window)
+            .serve(make_service_fn(move |_| async move {
+                Ok::<_, hyper::Error>(service_fn(move |req: Request<Body>| async move {
+                    let mut req_body = req.into_body();
+                    while let Some(_chunk) = req_body.data().await {}
+                    Ok::<_, hyper::Error>(Response::new(Body::from(body)))
+                }))
+            }))
+    });
+    let addr = srv.local_addr();
+    rt.spawn(async {
+        if let Err(err) = srv.await {
+            panic!("server error: {}", err);
+        }
+    });
+    addr
+}
diff --git a/hyper/benches/pipeline.rs b/hyper/benches/pipeline.rs
new file mode 100644
index 0000000..d5cc67b
--- /dev/null
+++ b/hyper/benches/pipeline.rs
@@ -0,0 +1,86 @@
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate test;
+
+use std::io::{Read, Write};
+use std::net::TcpStream;
+use std::sync::mpsc;
+use std::time::Duration;
+
+use tokio::sync::oneshot;
+
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Body, Response, Server};
+
+const PIPELINED_REQUESTS: usize = 16;
+
+#[bench]
+fn hello_world_16(b: &mut test::Bencher) {
+    let _ = pretty_env_logger::try_init();
+    let (_until_tx, until_rx) = oneshot::channel::<()>();
+
+    let addr = {
+        let (addr_tx, addr_rx) = mpsc::channel();
+        std::thread::spawn(move || {
+            let addr = "127.0.0.1:0".parse().unwrap();
+
+            let make_svc = make_service_fn(|_| async {
+                Ok::<_, hyper::Error>(service_fn(|_| async {
+                    Ok::<_, hyper::Error>(Response::new(Body::from("Hello, World!")))
+                }))
+            });
+
+            let rt = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .expect("rt build");
+            let srv = rt.block_on(async move {
+                Server::bind(&addr)
+                    .http1_pipeline_flush(true)
+                    .serve(make_svc)
+            });
+
+            addr_tx.send(srv.local_addr()).unwrap();
+
+            let graceful = srv.with_graceful_shutdown(async {
+                until_rx.await.ok();
+            });
+
+            rt.block_on(async {
+                if let Err(e) = graceful.await {
+                    panic!("server error: {}", e);
+                }
+            });
+        });
+
+        addr_rx.recv().unwrap()
+    };
+
+    let mut pipelined_reqs = Vec::new();
+    for _ in 0..PIPELINED_REQUESTS {
+        pipelined_reqs.extend_from_slice(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n");
+    }
+
+    let total_bytes = {
+        let mut tcp = TcpStream::connect(addr).unwrap();
+        tcp.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
+            .unwrap();
+        let mut buf = Vec::new();
+        tcp.read_to_end(&mut buf).unwrap()
+    } * PIPELINED_REQUESTS;
+
+    let mut tcp = TcpStream::connect(addr).unwrap();
+    tcp.set_read_timeout(Some(Duration::from_secs(3))).unwrap();
+    let mut buf = [0u8; 8192];
+
+    b.bytes = (pipelined_reqs.len() + total_bytes) as u64;
+    b.iter(|| {
+        tcp.write_all(&pipelined_reqs).unwrap();
+        let mut sum = 0;
+        while sum < total_bytes {
+            sum += tcp.read(&mut buf).unwrap();
+        }
+        assert_eq!(sum, total_bytes);
+    });
+}
diff --git a/hyper/benches/server.rs b/hyper/benches/server.rs
new file mode 100644
index 0000000..7ca0d08
--- /dev/null
+++ b/hyper/benches/server.rs
@@ -0,0 +1,212 @@
+#![feature(test)]
+#![deny(warnings)]
+
+extern crate test;
+
+use std::io::{Read, Write};
+use std::net::{TcpListener, TcpStream};
+use std::sync::mpsc;
+use std::time::Duration;
+
+use futures_util::{stream, StreamExt};
+use tokio::sync::oneshot;
+
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Body, Response, Server};
+
+macro_rules! bench_server {
+    ($b:ident, $header:expr, $body:expr) => {{
+        let _ = pretty_env_logger::try_init();
+        let (_until_tx, until_rx) = oneshot::channel::<()>();
+        let addr = {
+            let (addr_tx, addr_rx) = mpsc::channel();
+            std::thread::spawn(move || {
+                let addr = "127.0.0.1:0".parse().unwrap();
+                let make_svc = make_service_fn(|_| async {
+                    Ok::<_, hyper::Error>(service_fn(|_| async {
+                        Ok::<_, hyper::Error>(
+                            Response::builder()
+                                .header($header.0, $header.1)
+                                .header("content-type", "text/plain")
+                                .body($body())
+                                .unwrap(),
+                        )
+                    }))
+                });
+
+                let rt = tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build()
+                    .expect("rt build");
+
+                let srv = rt.block_on(async move { Server::bind(&addr).serve(make_svc) });
+
+                addr_tx.send(srv.local_addr()).unwrap();
+
+                let graceful = srv.with_graceful_shutdown(async {
+                    until_rx.await.ok();
+                });
+                rt.block_on(async move {
+                    if let Err(e) = graceful.await {
+                        panic!("server error: {}", e);
+                    }
+                });
+            });
+
+            addr_rx.recv().unwrap()
+        };
+
+        let total_bytes = {
+            let mut tcp = TcpStream::connect(addr).unwrap();
+            tcp.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
+                .unwrap();
+            let mut buf = Vec::new();
+            tcp.read_to_end(&mut buf).unwrap()
+        };
+
+        let mut tcp = TcpStream::connect(addr).unwrap();
+        tcp.set_read_timeout(Some(Duration::from_secs(3))).unwrap();
+        let mut buf = [0u8; 8192];
+
+        $b.bytes = 35 + total_bytes as u64;
+        $b.iter(|| {
+            tcp.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
+                .unwrap();
+            let mut sum = 0;
+            while sum < total_bytes {
+                sum += tcp.read(&mut buf).unwrap();
+            }
+            assert_eq!(sum, total_bytes);
+        });
+    }};
+}
+
+fn body(b: &'static [u8]) -> hyper::Body {
+    b.into()
+}
+
+#[bench]
+fn throughput_fixedsize_small_payload(b: &mut test::Bencher) {
+    bench_server!(b, ("content-length", "13"), || body(b"Hello, World!"))
+}
+
+#[bench]
+fn throughput_fixedsize_large_payload(b: &mut test::Bencher) {
+    bench_server!(b, ("content-length", "1000000"), || body(
+        &[b'x'; 1_000_000]
+    ))
+}
+
+#[bench]
+fn throughput_fixedsize_many_chunks(b: &mut test::Bencher) {
+    bench_server!(b, ("content-length", "1000000"), || {
+        static S: &[&[u8]] = &[&[b'x'; 1_000] as &[u8]; 1_000] as _;
+        Body::wrap_stream(stream::iter(S.iter()).map(|&s| Ok::<_, String>(s)))
+    })
+}
+
+#[bench]
+fn throughput_chunked_small_payload(b: &mut test::Bencher) {
+    bench_server!(b, ("transfer-encoding", "chunked"), || body(
+        b"Hello, World!"
+    ))
+}
+
+#[bench]
+fn throughput_chunked_large_payload(b: &mut test::Bencher) {
+    bench_server!(b, ("transfer-encoding", "chunked"), || body(
+        &[b'x'; 1_000_000]
+    ))
+}
+
+#[bench]
+fn throughput_chunked_many_chunks(b: &mut test::Bencher) {
+    bench_server!(b, ("transfer-encoding", "chunked"), || {
+        static S: &[&[u8]] = &[&[b'x'; 1_000] as &[u8]; 1_000] as _;
+        Body::wrap_stream(stream::iter(S.iter()).map(|&s| Ok::<_, String>(s)))
+    })
+}
+
+#[bench]
+fn raw_tcp_throughput_small_payload(b: &mut test::Bencher) {
+    let (tx, rx) = mpsc::channel();
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = listener.local_addr().unwrap();
+    std::thread::spawn(move || {
+        let mut sock = listener.accept().unwrap().0;
+
+        let mut buf = [0u8; 8192];
+        while rx.try_recv().is_err() {
+            sock.read(&mut buf).unwrap();
+            sock.write_all(
+                b"\
+                HTTP/1.1 200 OK\r\n\
+                Content-Length: 13\r\n\
+                Content-Type: text/plain; charset=utf-8\r\n\
+                Date: Fri, 12 May 2017 18:21:45 GMT\r\n\
+                \r\n\
+                Hello, World!\
+            ",
+            )
+            .unwrap();
+        }
+    });
+
+    let mut tcp = TcpStream::connect(addr).unwrap();
+    let mut buf = [0u8; 4096];
+
+    b.bytes = 130 + 35;
+    b.iter(|| {
+        tcp.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
+            .unwrap();
+        let n = tcp.read(&mut buf).unwrap();
+        assert_eq!(n, 130);
+    });
+    tx.send(()).unwrap();
+}
+
+#[bench]
+fn raw_tcp_throughput_large_payload(b: &mut test::Bencher) {
+    let (tx, rx) = mpsc::channel();
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = listener.local_addr().unwrap();
+
+    let srv_head = b"\
+        HTTP/1.1 200 OK\r\n\
+        Content-Length: 1000000\r\n\
+        Content-Type: text/plain; charset=utf-8\r\n\
+        Date: Fri, 12 May 2017 18:21:45 GMT\r\n\
+        \r\n\
+    ";
+    std::thread::spawn(move || {
+        let mut sock = listener.accept().unwrap().0;
+
+        let mut buf = [0u8; 8192];
+        while rx.try_recv().is_err() {
+            let r = sock.read(&mut buf).unwrap();
+            extern crate test;
+            if r == 0 {
+                break;
+            }
+            sock.write_all(srv_head).unwrap();
+            sock.write_all(&[b'x'; 1_000_000]).unwrap();
+        }
+    });
+
+    let mut tcp = TcpStream::connect(addr).unwrap();
+    let mut buf = [0u8; 8192];
+
+    let expect_read = srv_head.len() + 1_000_000;
+    b.bytes = expect_read as u64 + 35;
+
+    b.iter(|| {
+        tcp.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\n\r\n")
+            .unwrap();
+        let mut sum = 0;
+        while sum < expect_read {
+            sum += tcp.read(&mut buf).unwrap();
+        }
+        assert_eq!(sum, expect_read);
+    });
+    tx.send(()).unwrap();
+}
diff --git a/hyper/capi/README.md b/hyper/capi/README.md
new file mode 100644
index 0000000..c4e8813
--- /dev/null
+++ b/hyper/capi/README.md
@@ -0,0 +1,17 @@
+# C API for hyper
+
+This provides auxiliary pieces for a C API to use the hyper library.
+
+## Unstable
+
+The C API of hyper is currently **unstable**, which means it's not part of the semver contract as the rest of the Rust API is.
+
+Because of that, it's only accessible if `--cfg hyper_unstable_ffi` is passed to `rustc` when compiling. The easiest way to do that is setting the `RUSTFLAGS` environment variable.
+
+## Building
+
+The C API is part of the Rust library, but isn't compiled by default. Using a nightly release of `cargo`, starting with `nightly-2022-03-02`, it can be compiled with the following command:
+
+```
+RUSTFLAGS="--cfg hyper_unstable_ffi" cargo +nightly rustc --features client,http1,http2,ffi -Z unstable-options --crate-type cdylib
+```
diff --git a/hyper/capi/cbindgen.toml b/hyper/capi/cbindgen.toml
new file mode 100644
index 0000000..d1a5823
--- /dev/null
+++ b/hyper/capi/cbindgen.toml
@@ -0,0 +1,15 @@
+# See https://github.com/eqrion/cbindgen/blob/master/docs.md#cbindgentoml for
+# a list of possible configuration values.
+language = "C"
+header = """/*
+ * Copyright 2021 Sean McArthur. MIT License.
+ * Generated by gen_header.sh. Do not edit directly.
+ */"""
+include_guard = "_HYPER_H"
+no_includes = true
+sys_includes = ["stdint.h", "stddef.h"]
+cpp_compat = true
+documentation_style = "c"
+
+[parse.expand]
+crates = ["hyper-capi"]
diff --git a/hyper/capi/examples/Makefile b/hyper/capi/examples/Makefile
new file mode 100644
index 0000000..951c99f
--- /dev/null
+++ b/hyper/capi/examples/Makefile
@@ -0,0 +1,25 @@
+#
+# Build the example client
+#
+
+TARGET = client
+TARGET2 = upload
+
+OBJS = client.o
+OBJS2 = upload.o
+
+RPATH=$(PWD)/../../target/debug
+CFLAGS = -I../include
+LDFLAGS = -L$(RPATH) -Wl,-rpath,$(RPATH)
+LIBS = -lhyper
+
+all: $(TARGET) $(TARGET2)
+
+$(TARGET): $(OBJS)
+	$(CC) -o $(TARGET) $(OBJS) $(LDFLAGS) $(LIBS)
+
+$(TARGET2): $(OBJS2)
+	$(CC) -o $(TARGET2) $(OBJS2) $(LDFLAGS) $(LIBS)
+
+clean:
+	rm -f $(OBJS) $(TARGET) $(OBJS2) $(TARGET2)
diff --git a/hyper/capi/examples/client.c b/hyper/capi/examples/client.c
new file mode 100644
index 0000000..57a3e7b
--- /dev/null
+++ b/hyper/capi/examples/client.c
@@ -0,0 +1,343 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/select.h>
+#include <assert.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <string.h>
+
+#include "hyper.h"
+
+
+struct conn_data {
+    int fd;
+    hyper_waker *read_waker;
+    hyper_waker *write_waker;
+};
+
+static size_t read_cb(void *userdata, hyper_context *ctx, uint8_t *buf, size_t buf_len) {
+    struct conn_data *conn = (struct conn_data *)userdata;
+    ssize_t ret = read(conn->fd, buf, buf_len);
+
+    if (ret >= 0) {
+        return ret;
+    }
+
+    if (errno != EAGAIN) {
+        // kaboom
+        return HYPER_IO_ERROR;
+    }
+
+    // would block, register interest
+    if (conn->read_waker != NULL) {
+        hyper_waker_free(conn->read_waker);
+    }
+    conn->read_waker = hyper_context_waker(ctx);
+    return HYPER_IO_PENDING;
+}
+
+static size_t write_cb(void *userdata, hyper_context *ctx, const uint8_t *buf, size_t buf_len) {
+    struct conn_data *conn = (struct conn_data *)userdata;
+    ssize_t ret = write(conn->fd, buf, buf_len);
+
+    if (ret >= 0) {
+        return ret;
+    }
+
+    if (errno != EAGAIN) {
+        // kaboom
+        return HYPER_IO_ERROR;
+    }
+
+    // would block, register interest
+    if (conn->write_waker != NULL) {
+        hyper_waker_free(conn->write_waker);
+    }
+    conn->write_waker = hyper_context_waker(ctx);
+    return HYPER_IO_PENDING;
+}
+
+static void free_conn_data(struct conn_data *conn) {
+    if (conn->read_waker) {
+        hyper_waker_free(conn->read_waker);
+        conn->read_waker = NULL;
+    }
+    if (conn->write_waker) {
+        hyper_waker_free(conn->write_waker);
+        conn->write_waker = NULL;
+    }
+
+    free(conn);
+}
+
+static int connect_to(const char *host, const char *port) {
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(struct addrinfo));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    struct addrinfo *result, *rp;
+    if (getaddrinfo(host, port, &hints, &result) != 0) {
+        printf("dns failed for %s\n", host);
+        return -1;
+    }
+
+    int sfd;
+    for (rp = result; rp != NULL; rp = rp->ai_next) {
+        sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+        if (sfd == -1) {
+            continue;
+        }
+
+        if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) {
+            break;
+        }
+
+        close(sfd);
+    }
+
+    freeaddrinfo(result);
+
+    // no address succeeded
+    if (rp == NULL) {
+        printf("connect failed for %s\n", host);
+        return -1;
+    }
+
+    return sfd;
+}
+
+static int print_each_header(void *userdata,
+                                         const uint8_t *name,
+                                         size_t name_len,
+                                         const uint8_t *value,
+                                         size_t value_len) {
+    printf("%.*s: %.*s\n", (int) name_len, name, (int) value_len, value);
+    return HYPER_ITER_CONTINUE;
+}
+
+static int print_each_chunk(void *userdata, const hyper_buf *chunk) {
+    const uint8_t *buf = hyper_buf_bytes(chunk);
+    size_t len = hyper_buf_len(chunk);
+
+    write(1, buf, len);
+
+    return HYPER_ITER_CONTINUE;
+}
+
+typedef enum {
+    EXAMPLE_NOT_SET = 0, // tasks we don't know about won't have a userdata set
+    EXAMPLE_HANDSHAKE,
+    EXAMPLE_SEND,
+    EXAMPLE_RESP_BODY
+} example_id;
+
+#define STR_ARG(XX) (uint8_t *)XX, strlen(XX)
+
+int main(int argc, char *argv[]) {
+    const char *host = argc > 1 ? argv[1] : "httpbin.org";
+    const char *port = argc > 2 ? argv[2] : "80";
+    const char *path = argc > 3 ? argv[3] : "/";
+    printf("connecting to port %s on %s...\n", port, host);
+
+    int fd = connect_to(host, port);
+    if (fd < 0) {
+        return 1;
+    }
+
+    printf("connected to %s, now get %s\n", host, path);
+    if (fcntl(fd, F_SETFL, O_NONBLOCK) != 0) {
+        printf("failed to set socket to non-blocking\n");
+        return 1;
+    }
+
+    fd_set fds_read;
+    fd_set fds_write;
+    fd_set fds_excep;
+
+    struct conn_data *conn = malloc(sizeof(struct conn_data));
+
+    conn->fd = fd;
+    conn->read_waker = NULL;
+    conn->write_waker = NULL;
+
+    // Hookup the IO
+    hyper_io *io = hyper_io_new();
+    hyper_io_set_userdata(io, (void *)conn);
+    hyper_io_set_read(io, read_cb);
+    hyper_io_set_write(io, write_cb);
+
+    printf("http handshake (hyper v%s) ...\n", hyper_version());
+
+    // We need an executor generally to poll futures
+    const hyper_executor *exec = hyper_executor_new();
+
+    // Prepare client options
+    hyper_clientconn_options *opts = hyper_clientconn_options_new();
+    hyper_clientconn_options_exec(opts, exec);
+
+    hyper_task *handshake = hyper_clientconn_handshake(io, opts);
+    hyper_task_set_userdata(handshake, (void *)EXAMPLE_HANDSHAKE);
+
+    // Let's wait for the handshake to finish...
+    hyper_executor_push(exec, handshake);
+
+    // In case a task errors...
+    hyper_error *err;
+
+    // The polling state machine!
+    while (1) {
+        // Poll all ready tasks and act on them...
+        while (1) {
+            hyper_task *task = hyper_executor_poll(exec);
+            if (!task) {
+                break;
+            }
+            switch ((example_id) hyper_task_userdata(task)) {
+            case EXAMPLE_HANDSHAKE:
+                ;
+                if (hyper_task_type(task) == HYPER_TASK_ERROR) {
+                    printf("handshake error!\n");
+                    err = hyper_task_value(task);
+                    goto fail;
+                }
+                assert(hyper_task_type(task) == HYPER_TASK_CLIENTCONN);
+
+                printf("preparing http request ...\n");
+
+                hyper_clientconn *client = hyper_task_value(task);
+                hyper_task_free(task);
+
+                // Prepare the request
+                hyper_request *req = hyper_request_new();
+                if (hyper_request_set_method(req, STR_ARG("GET"))) {
+                    printf("error setting method\n");
+                    return 1;
+                }
+                if (hyper_request_set_uri(req, STR_ARG(path))) {
+                    printf("error setting uri\n");
+                    return 1;
+                }
+
+                hyper_headers *req_headers = hyper_request_headers(req);
+                hyper_headers_set(req_headers,  STR_ARG("Host"), STR_ARG(host));
+
+                // Send it!
+                hyper_task *send = hyper_clientconn_send(client, req);
+                hyper_task_set_userdata(send, (void *)EXAMPLE_SEND);
+                printf("sending ...\n");
+                hyper_executor_push(exec, send);
+
+                // For this example, no longer need the client
+                hyper_clientconn_free(client);
+
+                break;
+            case EXAMPLE_SEND:
+                ;
+                if (hyper_task_type(task) == HYPER_TASK_ERROR) {
+                    printf("send error!\n");
+                    err = hyper_task_value(task);
+                    goto fail;
+                }
+                assert(hyper_task_type(task) == HYPER_TASK_RESPONSE);
+
+                // Take the results
+                hyper_response *resp = hyper_task_value(task);
+                hyper_task_free(task);
+
+                uint16_t http_status = hyper_response_status(resp);
+                const uint8_t *rp = hyper_response_reason_phrase(resp);
+                size_t rp_len = hyper_response_reason_phrase_len(resp);
+
+                printf("\nResponse Status: %d %.*s\n", http_status, (int) rp_len, rp);
+
+                hyper_headers *headers = hyper_response_headers(resp);
+                hyper_headers_foreach(headers, print_each_header, NULL);
+                printf("\n");
+
+                hyper_body *resp_body = hyper_response_body(resp);
+                hyper_task *foreach = hyper_body_foreach(resp_body, print_each_chunk, NULL);
+                hyper_task_set_userdata(foreach, (void *)EXAMPLE_RESP_BODY);
+                hyper_executor_push(exec, foreach);
+
+                // No longer need the response
+                hyper_response_free(resp);
+
+                break;
+            case EXAMPLE_RESP_BODY:
+                ;
+                if (hyper_task_type(task) == HYPER_TASK_ERROR) {
+                    printf("body error!\n");
+                    err = hyper_task_value(task);
+                    goto fail;
+                }
+
+                assert(hyper_task_type(task) == HYPER_TASK_EMPTY);
+
+                printf("\n -- Done! -- \n");
+
+                // Cleaning up before exiting
+                hyper_task_free(task);
+                hyper_executor_free(exec);
+                free_conn_data(conn);
+
+                return 0;
+            case EXAMPLE_NOT_SET:
+                // A background task for hyper completed...
+                hyper_task_free(task);
+                break;
+            }
+        }
+
+        // All futures are pending on IO work, so select on the fds.
+
+        FD_ZERO(&fds_read);
+        FD_ZERO(&fds_write);
+        FD_ZERO(&fds_excep);
+
+        if (conn->read_waker) {
+            FD_SET(conn->fd, &fds_read);
+        }
+        if (conn->write_waker) {
+            FD_SET(conn->fd, &fds_write);
+        }
+
+        int sel_ret = select(conn->fd + 1, &fds_read, &fds_write, &fds_excep, NULL);
+
+        if (sel_ret < 0) {
+            printf("select() error\n");
+            return 1;
+        }
+
+        if (FD_ISSET(conn->fd, &fds_read)) {
+            hyper_waker_wake(conn->read_waker);
+            conn->read_waker = NULL;
+        }
+
+        if (FD_ISSET(conn->fd, &fds_write)) {
+            hyper_waker_wake(conn->write_waker);
+            conn->write_waker = NULL;
+        }
+
+    }
+
+    return 0;
+
+fail:
+    if (err) {
+        printf("error code: %d\n", hyper_error_code(err));
+        // grab the error details
+        char errbuf [256];
+        size_t errlen = hyper_error_print(err, errbuf, sizeof(errbuf));
+        printf("details: %.*s\n", (int) errlen, errbuf);
+
+        // clean up the error
+        hyper_error_free(err);
+    }
+    return 1;
+}
diff --git a/hyper/capi/examples/upload.c b/hyper/capi/examples/upload.c
new file mode 100644
index 0000000..9b791ee
--- /dev/null
+++ b/hyper/capi/examples/upload.c
@@ -0,0 +1,406 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/select.h>
+#include <assert.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <string.h>
+
+#include "hyper.h"
+
+
+struct conn_data {
+    int fd;
+    hyper_waker *read_waker;
+    hyper_waker *write_waker;
+};
+
+static size_t read_cb(void *userdata, hyper_context *ctx, uint8_t *buf, size_t buf_len) {
+    struct conn_data *conn = (struct conn_data *)userdata;
+    ssize_t ret = read(conn->fd, buf, buf_len);
+
+    if (ret >= 0) {
+        return ret;
+    }
+
+    if (errno != EAGAIN) {
+        // kaboom
+        return HYPER_IO_ERROR;
+    }
+
+    // would block, register interest
+    if (conn->read_waker != NULL) {
+        hyper_waker_free(conn->read_waker);
+    }
+    conn->read_waker = hyper_context_waker(ctx);
+    return HYPER_IO_PENDING;
+}
+
+static size_t write_cb(void *userdata, hyper_context *ctx, const uint8_t *buf, size_t buf_len) {
+    struct conn_data *conn = (struct conn_data *)userdata;
+    ssize_t ret = write(conn->fd, buf, buf_len);
+
+    if (ret >= 0) {
+        return ret;
+    }
+
+    if (errno != EAGAIN) {
+        // kaboom
+        return HYPER_IO_ERROR;
+    }
+
+    // would block, register interest
+    if (conn->write_waker != NULL) {
+        hyper_waker_free(conn->write_waker);
+    }
+    conn->write_waker = hyper_context_waker(ctx);
+    return HYPER_IO_PENDING;
+}
+
+static void free_conn_data(struct conn_data *conn) {
+    if (conn->read_waker) {
+        hyper_waker_free(conn->read_waker);
+        conn->read_waker = NULL;
+    }
+    if (conn->write_waker) {
+        hyper_waker_free(conn->write_waker);
+        conn->write_waker = NULL;
+    }
+
+    free(conn);
+}
+
+static int connect_to(const char *host, const char *port) {
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(struct addrinfo));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    struct addrinfo *result, *rp;
+    if (getaddrinfo(host, port, &hints, &result) != 0) {
+        printf("dns failed for %s\n", host);
+        return -1;
+    }
+
+    int sfd;
+    for (rp = result; rp != NULL; rp = rp->ai_next) {
+        sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+        if (sfd == -1) {
+            continue;
+        }
+
+        if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) {
+            break;
+        }
+
+        close(sfd);
+    }
+
+    freeaddrinfo(result);
+
+    // no address succeeded
+    if (rp == NULL) {
+        printf("connect failed for %s\n", host);
+        return -1;
+    }
+
+    return sfd;
+}
+
+struct upload_body {
+    int fd;
+    char *buf;
+    size_t len;
+};
+
+static int poll_req_upload(void *userdata,
+                           hyper_context *ctx,
+                           hyper_buf **chunk) {
+    struct upload_body* upload = userdata;
+
+    ssize_t res = read(upload->fd, upload->buf, upload->len);
+    if (res > 0) {
+        *chunk = hyper_buf_copy(upload->buf, res);
+        return HYPER_POLL_READY;
+    }
+
+    if (res == 0) {
+        // All done!
+        *chunk = NULL;
+        return HYPER_POLL_READY;
+    }
+
+    // Oh no!
+    printf("error reading upload file: %d", errno);
+    return HYPER_POLL_ERROR;
+}
+
+static int print_each_header(void *userdata,
+                                         const uint8_t *name,
+                                         size_t name_len,
+                                         const uint8_t *value,
+                                         size_t value_len) {
+    printf("%.*s: %.*s\n", (int) name_len, name, (int) value_len, value);
+    return HYPER_ITER_CONTINUE;
+}
+
+static void print_informational(void *userdata, hyper_response *resp) {
+    uint16_t http_status = hyper_response_status(resp);
+
+    printf("\nInformational (1xx): %d\n", http_status);
+
+    const hyper_buf *headers = hyper_response_headers_raw(resp);
+    if (headers) {
+        write(1, hyper_buf_bytes(headers), hyper_buf_len(headers));
+    }
+}
+
+typedef enum {
+    EXAMPLE_NOT_SET = 0, // tasks we don't know about won't have a userdata set
+    EXAMPLE_HANDSHAKE,
+    EXAMPLE_SEND,
+    EXAMPLE_RESP_BODY
+} example_id;
+
+#define STR_ARG(XX) (uint8_t *)XX, strlen(XX)
+
+int main(int argc, char *argv[]) {
+    const char *file = argc > 1 ? argv[1] : NULL;
+    const char *host = argc > 2 ? argv[2] : "httpbin.org";
+    const char *port = argc > 3 ? argv[3] : "80";
+    const char *path = argc > 4 ? argv[4] : "/post";
+
+    if (!file) {
+        printf("Pass a file path as the first argument.\n");
+        return 1;
+    }
+
+    struct upload_body upload;
+    upload.fd = open(file, O_RDONLY);
+
+    if (upload.fd < 0) {
+        printf("error opening file to upload: %s\n", strerror(errno));
+        return 1;
+    }
+    printf("connecting to port %s on %s...\n", port, host);
+
+    int fd = connect_to(host, port);
+    if (fd < 0) {
+        return 1;
+    }
+    printf("connected to %s, now upload to %s\n", host, path);
+
+    if (fcntl(fd, F_SETFL, O_NONBLOCK) != 0) {
+        printf("failed to set socket to non-blocking\n");
+        return 1;
+    }
+
+    upload.len = 8192;
+    upload.buf = malloc(upload.len);
+
+    fd_set fds_read;
+    fd_set fds_write;
+    fd_set fds_excep;
+
+    struct conn_data *conn = malloc(sizeof(struct conn_data));
+
+    conn->fd = fd;
+    conn->read_waker = NULL;
+    conn->write_waker = NULL;
+
+
+    // Hookup the IO
+    hyper_io *io = hyper_io_new();
+    hyper_io_set_userdata(io, (void *)conn);
+    hyper_io_set_read(io, read_cb);
+    hyper_io_set_write(io, write_cb);
+
+    printf("http handshake (hyper v%s) ...\n", hyper_version());
+
+    // We need an executor generally to poll futures
+    const hyper_executor *exec = hyper_executor_new();
+
+    // Prepare client options
+    hyper_clientconn_options *opts = hyper_clientconn_options_new();
+    hyper_clientconn_options_exec(opts, exec);
+    hyper_clientconn_options_headers_raw(opts, 1);
+
+    hyper_task *handshake = hyper_clientconn_handshake(io, opts);
+    hyper_task_set_userdata(handshake, (void *)EXAMPLE_HANDSHAKE);
+
+    // Let's wait for the handshake to finish...
+    hyper_executor_push(exec, handshake);
+
+    // This body will get filled in eventually...
+    hyper_body *resp_body = NULL;
+
+    // The polling state machine!
+    while (1) {
+        // Poll all ready tasks and act on them...
+        while (1) {
+            hyper_task *task = hyper_executor_poll(exec);
+            if (!task) {
+                break;
+            }
+            hyper_task_return_type task_type = hyper_task_type(task);
+
+            switch ((example_id) hyper_task_userdata(task)) {
+            case EXAMPLE_HANDSHAKE:
+                ;
+                if (task_type == HYPER_TASK_ERROR) {
+                    printf("handshake error!\n");
+                    return 1;
+                }
+                assert(task_type == HYPER_TASK_CLIENTCONN);
+
+                printf("preparing http request ...\n");
+
+                hyper_clientconn *client = hyper_task_value(task);
+                hyper_task_free(task);
+
+                // Prepare the request
+                hyper_request *req = hyper_request_new();
+                if (hyper_request_set_method(req, STR_ARG("POST"))) {
+                    printf("error setting method\n");
+                    return 1;
+                }
+                if (hyper_request_set_uri(req, STR_ARG(path))) {
+                    printf("error setting uri\n");
+                    return 1;
+                }
+
+                hyper_headers *req_headers = hyper_request_headers(req);
+                hyper_headers_set(req_headers, STR_ARG("host"), STR_ARG(host));
+                hyper_headers_set(req_headers, STR_ARG("expect"), STR_ARG("100-continue"));
+
+                // NOTE: We aren't handling *waiting* for the 100 Continue,
+                // the body is sent immediately. This will just print if any
+                // informational headers are received.
+                printf("    with expect-continue ...\n");
+                hyper_request_on_informational(req, print_informational, NULL);
+
+                // Prepare the req body
+                hyper_body *body = hyper_body_new();
+                hyper_body_set_userdata(body, &upload);
+                hyper_body_set_data_func(body, poll_req_upload);
+                hyper_request_set_body(req, body);
+
+                // Send it!
+                hyper_task *send = hyper_clientconn_send(client, req);
+                hyper_task_set_userdata(send, (void *)EXAMPLE_SEND);
+                printf("sending ...\n");
+                hyper_executor_push(exec, send);
+
+                // For this example, no longer need the client
+                hyper_clientconn_free(client);
+
+                break;
+            case EXAMPLE_SEND:
+                ;
+                if (task_type == HYPER_TASK_ERROR) {
+                    printf("send error!\n");
+                    return 1;
+                }
+                assert(task_type == HYPER_TASK_RESPONSE);
+
+                // Take the results
+                hyper_response *resp = hyper_task_value(task);
+                hyper_task_free(task);
+
+                uint16_t http_status = hyper_response_status(resp);
+
+                printf("\nResponse Status: %d\n", http_status);
+
+                hyper_headers *headers = hyper_response_headers(resp);
+                hyper_headers_foreach(headers, print_each_header, NULL);
+                printf("\n");
+
+                resp_body = hyper_response_body(resp);
+
+                // Set us up to peel data from the body a chunk at a time
+                hyper_task *body_data = hyper_body_data(resp_body);
+                hyper_task_set_userdata(body_data, (void *)EXAMPLE_RESP_BODY);
+                hyper_executor_push(exec, body_data);
+
+                // No longer need the response
+                hyper_response_free(resp);
+
+                break;
+            case EXAMPLE_RESP_BODY:
+                ;
+                if (task_type == HYPER_TASK_ERROR) {
+                    printf("body error!\n");
+                    return 1;
+                }
+
+                if (task_type == HYPER_TASK_BUF) {
+                    hyper_buf *chunk = hyper_task_value(task);
+                    write(1, hyper_buf_bytes(chunk), hyper_buf_len(chunk));
+                    hyper_buf_free(chunk);
+                    hyper_task_free(task);
+
+                    hyper_task *body_data = hyper_body_data(resp_body);
+                    hyper_task_set_userdata(body_data, (void *)EXAMPLE_RESP_BODY);
+                    hyper_executor_push(exec, body_data);
+
+                    break;
+                }
+
+                assert(task_type == HYPER_TASK_EMPTY);
+                hyper_task_free(task);
+                hyper_body_free(resp_body);
+
+                printf("\n -- Done! -- \n");
+
+                // Cleaning up before exiting
+                hyper_executor_free(exec);
+                free_conn_data(conn);
+                free(upload.buf);
+
+                return 0;
+            case EXAMPLE_NOT_SET:
+                // A background task for hyper completed...
+                hyper_task_free(task);
+                break;
+            }
+        }
+
+        // All futures are pending on IO work, so select on the fds.
+
+        FD_ZERO(&fds_read);
+        FD_ZERO(&fds_write);
+        FD_ZERO(&fds_excep);
+
+        if (conn->read_waker) {
+            FD_SET(conn->fd, &fds_read);
+        }
+        if (conn->write_waker) {
+            FD_SET(conn->fd, &fds_write);
+        }
+
+        int sel_ret = select(conn->fd + 1, &fds_read, &fds_write, &fds_excep, NULL);
+
+        if (sel_ret < 0) {
+            printf("select() error\n");
+            return 1;
+        }
+
+        if (FD_ISSET(conn->fd, &fds_read)) {
+            hyper_waker_wake(conn->read_waker);
+            conn->read_waker = NULL;
+        }
+
+        if (FD_ISSET(conn->fd, &fds_write)) {
+            hyper_waker_wake(conn->write_waker);
+            conn->write_waker = NULL;
+        }
+    }
+
+
+    return 0;
+}
diff --git a/hyper/capi/gen_header.sh b/hyper/capi/gen_header.sh
new file mode 100755
index 0000000..d0b9c13
--- /dev/null
+++ b/hyper/capi/gen_header.sh
@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+
+# This script regenerates hyper.h. As of April 2021, it only works with the
+# nightly build of Rust.
+
+set -e
+
+CAPI_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+WORK_DIR=$(mktemp -d)
+
+# check if tmp dir was created
+if [[ ! "$WORK_DIR" || ! -d "$WORK_DIR" ]]; then
+    echo "Could not create temp dir"
+    exit 1
+fi
+
+header_file_backup="$CAPI_DIR/include/hyper.h.backup"
+
+function cleanup {
+    rm -rf "$WORK_DIR"
+    rm "$header_file_backup" || true
+}
+
+trap cleanup EXIT
+
+mkdir "$WORK_DIR/src"
+
+# Fake a library
+cat > "$WORK_DIR/src/lib.rs" << EOF
+#[path = "$CAPI_DIR/../src/ffi/mod.rs"]
+pub mod ffi;
+EOF
+
+# And its Cargo.toml
+cat > "$WORK_DIR/Cargo.toml" << EOF
+[package]
+name = "hyper"
+version = "0.0.0"
+edition = "2018"
+publish = false
+
+[dependencies]
+# Determined which dependencies we need by running the "cargo rustc" command
+# below and watching the compile error output for references to unknown imports,
+# until we didn't get any errors.
+bytes = "1"
+futures-channel = "0.3"
+futures-util = { version = "0.3", default-features = false, features = ["alloc"] }
+libc = { version = "0.2", optional = true }
+http = "0.2"
+http-body = "0.4"
+tokio = { version = "1", features = ["rt"] }
+
+[features]
+default = [
+    "client",
+    "ffi",
+    "http1",
+]
+
+http1 = []
+client = []
+ffi = ["libc", "tokio/rt"]
+EOF
+
+cp "$CAPI_DIR/include/hyper.h" "$header_file_backup"
+
+#cargo metadata --no-default-features --features ffi --format-version 1 > "$WORK_DIR/metadata.json"
+
+cd "${WORK_DIR}" || exit 2
+
+# Expand just the ffi module
+if ! output=$(RUSTFLAGS='--cfg hyper_unstable_ffi' cargo rustc -- -Z unpretty=expanded 2>&1 > expanded.rs); then
+    # As of April 2021 the script above prints a lot of warnings/errors, and
+    # exits with a nonzero return code, but hyper.h still gets generated.
+    #
+    # However, on Github Actions, this will result in automatic "annotations"
+    # being added to files not related to a PR, so if this is `--verify` mode,
+    # then don't show it.
+    #
+    # But yes show it when using it locally.
+    if [[ "--verify" != "$1" ]]; then
+        echo "$output"
+    fi
+fi
+
+# Replace the previous copy with the single expanded file
+rm -rf ./src
+mkdir src
+mv expanded.rs src/lib.rs
+
+
+# Bindgen!
+if ! cbindgen \
+    --config "$CAPI_DIR/cbindgen.toml" \
+    --lockfile "$CAPI_DIR/../Cargo.lock" \
+    --output "$CAPI_DIR/include/hyper.h" \
+    "${@}"; then
+    bindgen_exit_code=$?
+    if [[ "--verify" == "$1" ]]; then
+        echo "diff generated (<) vs backup (>)"
+        diff "$CAPI_DIR/include/hyper.h" "$header_file_backup"
+    fi
+    exit $bindgen_exit_code
+fi
+
+exit 0
diff --git a/hyper/capi/include/hyper.h b/hyper/capi/include/hyper.h
new file mode 100644
index 0000000..1f938b8
--- /dev/null
+++ b/hyper/capi/include/hyper.h
@@ -0,0 +1,779 @@
+/*
+ * Copyright 2021 Sean McArthur. MIT License.
+ * Generated by gen_header.sh. Do not edit directly.
+ */
+
+#ifndef _HYPER_H
+#define _HYPER_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ Return in iter functions to continue iterating.
+ */
+#define HYPER_ITER_CONTINUE 0
+
+/*
+ Return in iter functions to stop iterating.
+ */
+#define HYPER_ITER_BREAK 1
+
+/*
+ An HTTP Version that is unspecified.
+ */
+#define HYPER_HTTP_VERSION_NONE 0
+
+/*
+ The HTTP/1.0 version.
+ */
+#define HYPER_HTTP_VERSION_1_0 10
+
+/*
+ The HTTP/1.1 version.
+ */
+#define HYPER_HTTP_VERSION_1_1 11
+
+/*
+ The HTTP/2 version.
+ */
+#define HYPER_HTTP_VERSION_2 20
+
+/*
+ Sentinel value to return from a read or write callback that the operation
+ is pending.
+ */
+#define HYPER_IO_PENDING 4294967295
+
+/*
+ Sentinel value to return from a read or write callback that the operation
+ has errored.
+ */
+#define HYPER_IO_ERROR 4294967294
+
+/*
+ Return in a poll function to indicate it was ready.
+ */
+#define HYPER_POLL_READY 0
+
+/*
+ Return in a poll function to indicate it is still pending.
+
+ The passed in `hyper_waker` should be registered to wake up the task at
+ some later point.
+ */
+#define HYPER_POLL_PENDING 1
+
+/*
+ Return in a poll function indicate an error.
+ */
+#define HYPER_POLL_ERROR 3
+
+/*
+ A return code for many of hyper's methods.
+ */
+typedef enum hyper_code {
+  /*
+   All is well.
+   */
+  HYPERE_OK,
+  /*
+   General error, details in the `hyper_error *`.
+   */
+  HYPERE_ERROR,
+  /*
+   A function argument was invalid.
+   */
+  HYPERE_INVALID_ARG,
+  /*
+   The IO transport returned an EOF when one wasn't expected.
+
+   This typically means an HTTP request or response was expected, but the
+   connection closed cleanly without sending (all of) it.
+   */
+  HYPERE_UNEXPECTED_EOF,
+  /*
+   Aborted by a user supplied callback.
+   */
+  HYPERE_ABORTED_BY_CALLBACK,
+  /*
+   An optional hyper feature was not enabled.
+   */
+  HYPERE_FEATURE_NOT_ENABLED,
+  /*
+   The peer sent an HTTP message that could not be parsed.
+   */
+  HYPERE_INVALID_PEER_MESSAGE,
+} hyper_code;
+
+/*
+ A descriptor for what type a `hyper_task` value is.
+ */
+typedef enum hyper_task_return_type {
+  /*
+   The value of this task is null (does not imply an error).
+   */
+  HYPER_TASK_EMPTY,
+  /*
+   The value of this task is `hyper_error *`.
+   */
+  HYPER_TASK_ERROR,
+  /*
+   The value of this task is `hyper_clientconn *`.
+   */
+  HYPER_TASK_CLIENTCONN,
+  /*
+   The value of this task is `hyper_response *`.
+   */
+  HYPER_TASK_RESPONSE,
+  /*
+   The value of this task is `hyper_buf *`.
+   */
+  HYPER_TASK_BUF,
+} hyper_task_return_type;
+
+/*
+ A streaming HTTP body.
+ */
+typedef struct hyper_body hyper_body;
+
+/*
+ A buffer of bytes that is sent or received on a `hyper_body`.
+ */
+typedef struct hyper_buf hyper_buf;
+
+/*
+ An HTTP client connection handle.
+
+ These are used to send a request on a single connection. It's possible to
+ send multiple requests on a single connection, such as when HTTP/1
+ keep-alive or HTTP/2 is used.
+ */
+typedef struct hyper_clientconn hyper_clientconn;
+
+/*
+ An options builder to configure an HTTP client connection.
+ */
+typedef struct hyper_clientconn_options hyper_clientconn_options;
+
+/*
+ An async context for a task that contains the related waker.
+ */
+typedef struct hyper_context hyper_context;
+
+/*
+ A more detailed error object returned by some hyper functions.
+ */
+typedef struct hyper_error hyper_error;
+
+/*
+ A task executor for `hyper_task`s.
+ */
+typedef struct hyper_executor hyper_executor;
+
+/*
+ An HTTP header map.
+
+ These can be part of a request or response.
+ */
+typedef struct hyper_headers hyper_headers;
+
+/*
+ An IO object used to represent a socket or similar concept.
+ */
+typedef struct hyper_io hyper_io;
+
+/*
+ An HTTP request.
+ */
+typedef struct hyper_request hyper_request;
+
+/*
+ An HTTP response.
+ */
+typedef struct hyper_response hyper_response;
+
+/*
+ An async task.
+ */
+typedef struct hyper_task hyper_task;
+
+/*
+ A waker that is saved and used to waken a pending task.
+ */
+typedef struct hyper_waker hyper_waker;
+
+typedef int (*hyper_body_foreach_callback)(void*, const struct hyper_buf*);
+
+typedef int (*hyper_body_data_callback)(void*, struct hyper_context*, struct hyper_buf**);
+
+typedef void (*hyper_request_on_informational_callback)(void*, struct hyper_response*);
+
+typedef int (*hyper_headers_foreach_callback)(void*, const uint8_t*, size_t, const uint8_t*, size_t);
+
+typedef size_t (*hyper_io_read_callback)(void*, struct hyper_context*, uint8_t*, size_t);
+
+typedef size_t (*hyper_io_write_callback)(void*, struct hyper_context*, const uint8_t*, size_t);
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/*
+ Returns a static ASCII (null terminated) string of the hyper version.
+ */
+const char *hyper_version(void);
+
+/*
+ Create a new "empty" body.
+
+ If not configured, this body acts as an empty payload.
+ */
+struct hyper_body *hyper_body_new(void);
+
+/*
+ Free a `hyper_body *`.
+ */
+void hyper_body_free(struct hyper_body *body);
+
+/*
+ Return a task that will poll the body for the next buffer of data.
+
+ The task value may have different types depending on the outcome:
+
+ - `HYPER_TASK_BUF`: Success, and more data was received.
+ - `HYPER_TASK_ERROR`: An error retrieving the data.
+ - `HYPER_TASK_EMPTY`: The body has finished streaming data.
+
+ This does not consume the `hyper_body *`, so it may be used to again.
+ However, it MUST NOT be used or freed until the related task completes.
+ */
+struct hyper_task *hyper_body_data(struct hyper_body *body);
+
+/*
+ Return a task that will poll the body and execute the callback with each
+ body chunk that is received.
+
+ The `hyper_buf` pointer is only a borrowed reference, it cannot live outside
+ the execution of the callback. You must make a copy to retain it.
+
+ The callback should return `HYPER_ITER_CONTINUE` to continue iterating
+ chunks as they are received, or `HYPER_ITER_BREAK` to cancel.
+
+ This will consume the `hyper_body *`, you shouldn't use it anymore or free it.
+ */
+struct hyper_task *hyper_body_foreach(struct hyper_body *body,
+                                      hyper_body_foreach_callback func,
+                                      void *userdata);
+
+/*
+ Set userdata on this body, which will be passed to callback functions.
+ */
+void hyper_body_set_userdata(struct hyper_body *body, void *userdata);
+
+/*
+ Set the data callback for this body.
+
+ The callback is called each time hyper needs to send more data for the
+ body. It is passed the value from `hyper_body_set_userdata`.
+
+ If there is data available, the `hyper_buf **` argument should be set
+ to a `hyper_buf *` containing the data, and `HYPER_POLL_READY` should
+ be returned.
+
+ Returning `HYPER_POLL_READY` while the `hyper_buf **` argument points
+ to `NULL` will indicate the body has completed all data.
+
+ If there is more data to send, but it isn't yet available, a
+ `hyper_waker` should be saved from the `hyper_context *` argument, and
+ `HYPER_POLL_PENDING` should be returned. You must wake the saved waker
+ to signal the task when data is available.
+
+ If some error has occurred, you can return `HYPER_POLL_ERROR` to abort
+ the body.
+ */
+void hyper_body_set_data_func(struct hyper_body *body, hyper_body_data_callback func);
+
+/*
+ Create a new `hyper_buf *` by copying the provided bytes.
+
+ This makes an owned copy of the bytes, so the `buf` argument can be
+ freed or changed afterwards.
+
+ This returns `NULL` if allocating a new buffer fails.
+ */
+struct hyper_buf *hyper_buf_copy(const uint8_t *buf, size_t len);
+
+/*
+ Get a pointer to the bytes in this buffer.
+
+ This should be used in conjunction with `hyper_buf_len` to get the length
+ of the bytes data.
+
+ This pointer is borrowed data, and not valid once the `hyper_buf` is
+ consumed/freed.
+ */
+const uint8_t *hyper_buf_bytes(const struct hyper_buf *buf);
+
+/*
+ Get the length of the bytes this buffer contains.
+ */
+size_t hyper_buf_len(const struct hyper_buf *buf);
+
+/*
+ Free this buffer.
+ */
+void hyper_buf_free(struct hyper_buf *buf);
+
+/*
+ Starts an HTTP client connection handshake using the provided IO transport
+ and options.
+
+ Both the `io` and the `options` are consumed in this function call.
+
+ The returned `hyper_task *` must be polled with an executor until the
+ handshake completes, at which point the value can be taken.
+ */
+struct hyper_task *hyper_clientconn_handshake(struct hyper_io *io,
+                                              struct hyper_clientconn_options *options);
+
+/*
+ Send a request on the client connection.
+
+ Returns a task that needs to be polled until it is ready. When ready, the
+ task yields a `hyper_response *`.
+ */
+struct hyper_task *hyper_clientconn_send(struct hyper_clientconn *conn, struct hyper_request *req);
+
+/*
+ Free a `hyper_clientconn *`.
+ */
+void hyper_clientconn_free(struct hyper_clientconn *conn);
+
+/*
+ Creates a new set of HTTP clientconn options to be used in a handshake.
+ */
+struct hyper_clientconn_options *hyper_clientconn_options_new(void);
+
+/*
+ Set the whether or not header case is preserved.
+
+ Pass `0` to allow lowercase normalization (default), `1` to retain original case.
+ */
+void hyper_clientconn_options_set_preserve_header_case(struct hyper_clientconn_options *opts,
+                                                       int enabled);
+
+/*
+ Set the whether or not header order is preserved.
+
+ Pass `0` to allow reordering (default), `1` to retain original ordering.
+ */
+void hyper_clientconn_options_set_preserve_header_order(struct hyper_clientconn_options *opts,
+                                                        int enabled);
+
+/*
+ Free a `hyper_clientconn_options *`.
+ */
+void hyper_clientconn_options_free(struct hyper_clientconn_options *opts);
+
+/*
+ Set the client background task executor.
+
+ This does not consume the `options` or the `exec`.
+ */
+void hyper_clientconn_options_exec(struct hyper_clientconn_options *opts,
+                                   const struct hyper_executor *exec);
+
+/*
+ Set the whether to use HTTP2.
+
+ Pass `0` to disable, `1` to enable.
+ */
+enum hyper_code hyper_clientconn_options_http2(struct hyper_clientconn_options *opts, int enabled);
+
+/*
+ Set the whether to include a copy of the raw headers in responses
+ received on this connection.
+
+ Pass `0` to disable, `1` to enable.
+
+ If enabled, see `hyper_response_headers_raw()` for usage.
+ */
+enum hyper_code hyper_clientconn_options_headers_raw(struct hyper_clientconn_options *opts,
+                                                     int enabled);
+
+/*
+ Frees a `hyper_error`.
+ */
+void hyper_error_free(struct hyper_error *err);
+
+/*
+ Get an equivalent `hyper_code` from this error.
+ */
+enum hyper_code hyper_error_code(const struct hyper_error *err);
+
+/*
+ Print the details of this error to a buffer.
+
+ The `dst_len` value must be the maximum length that the buffer can
+ store.
+
+ The return value is number of bytes that were written to `dst`.
+ */
+size_t hyper_error_print(const struct hyper_error *err, uint8_t *dst, size_t dst_len);
+
+/*
+ Construct a new HTTP request.
+ */
+struct hyper_request *hyper_request_new(void);
+
+/*
+ Free an HTTP request if not going to send it on a client.
+ */
+void hyper_request_free(struct hyper_request *req);
+
+/*
+ Set the HTTP Method of the request.
+ */
+enum hyper_code hyper_request_set_method(struct hyper_request *req,
+                                         const uint8_t *method,
+                                         size_t method_len);
+
+/*
+ Set the URI of the request.
+
+ The request's URI is best described as the `request-target` from the RFCs. So in HTTP/1,
+ whatever is set will get sent as-is in the first line (GET $uri HTTP/1.1). It
+ supports the 4 defined variants, origin-form, absolute-form, authority-form, and
+ asterisk-form.
+
+ The underlying type was built to efficiently support HTTP/2 where the request-target is
+ split over :scheme, :authority, and :path. As such, each part can be set explicitly, or the
+ type can parse a single contiguous string and if a scheme is found, that slot is "set". If
+ the string just starts with a path, only the path portion is set. All pseudo headers that
+ have been parsed/set are sent when the connection type is HTTP/2.
+
+ To set each slot explicitly, use `hyper_request_set_uri_parts`.
+ */
+enum hyper_code hyper_request_set_uri(struct hyper_request *req,
+                                      const uint8_t *uri,
+                                      size_t uri_len);
+
+/*
+ Set the URI of the request with separate scheme, authority, and
+ path/query strings.
+
+ Each of `scheme`, `authority`, and `path_and_query` should either be
+ null, to skip providing a component, or point to a UTF-8 encoded
+ string. If any string pointer argument is non-null, its corresponding
+ `len` parameter must be set to the string's length.
+ */
+enum hyper_code hyper_request_set_uri_parts(struct hyper_request *req,
+                                            const uint8_t *scheme,
+                                            size_t scheme_len,
+                                            const uint8_t *authority,
+                                            size_t authority_len,
+                                            const uint8_t *path_and_query,
+                                            size_t path_and_query_len);
+
+/*
+ Set the preferred HTTP version of the request.
+
+ The version value should be one of the `HYPER_HTTP_VERSION_` constants.
+
+ Note that this won't change the major HTTP version of the connection,
+ since that is determined at the handshake step.
+ */
+enum hyper_code hyper_request_set_version(struct hyper_request *req, int version);
+
+/*
+ Gets a reference to the HTTP headers of this request
+
+ This is not an owned reference, so it should not be accessed after the
+ `hyper_request` has been consumed.
+ */
+struct hyper_headers *hyper_request_headers(struct hyper_request *req);
+
+/*
+ Set the body of the request.
+
+ The default is an empty body.
+
+ This takes ownership of the `hyper_body *`, you must not use it or
+ free it after setting it on the request.
+ */
+enum hyper_code hyper_request_set_body(struct hyper_request *req, struct hyper_body *body);
+
+/*
+ Set an informational (1xx) response callback.
+
+ The callback is called each time hyper receives an informational (1xx)
+ response for this request.
+
+ The third argument is an opaque user data pointer, which is passed to
+ the callback each time.
+
+ The callback is passed the `void *` data pointer, and a
+ `hyper_response *` which can be inspected as any other response. The
+ body of the response will always be empty.
+
+ NOTE: The `hyper_response *` is just borrowed data, and will not
+ be valid after the callback finishes. You must copy any data you wish
+ to persist.
+ */
+enum hyper_code hyper_request_on_informational(struct hyper_request *req,
+                                               hyper_request_on_informational_callback callback,
+                                               void *data);
+
+/*
+ Free an HTTP response after using it.
+ */
+void hyper_response_free(struct hyper_response *resp);
+
+/*
+ Get the HTTP-Status code of this response.
+
+ It will always be within the range of 100-599.
+ */
+uint16_t hyper_response_status(const struct hyper_response *resp);
+
+/*
+ Get a pointer to the reason-phrase of this response.
+
+ This buffer is not null-terminated.
+
+ This buffer is owned by the response, and should not be used after
+ the response has been freed.
+
+ Use `hyper_response_reason_phrase_len()` to get the length of this
+ buffer.
+ */
+const uint8_t *hyper_response_reason_phrase(const struct hyper_response *resp);
+
+/*
+ Get the length of the reason-phrase of this response.
+
+ Use `hyper_response_reason_phrase()` to get the buffer pointer.
+ */
+size_t hyper_response_reason_phrase_len(const struct hyper_response *resp);
+
+/*
+ Get a reference to the full raw headers of this response.
+
+ You must have enabled `hyper_clientconn_options_headers_raw()`, or this
+ will return NULL.
+
+ The returned `hyper_buf *` is just a reference, owned by the response.
+ You need to make a copy if you wish to use it after freeing the
+ response.
+
+ The buffer is not null-terminated, see the `hyper_buf` functions for
+ getting the bytes and length.
+ */
+const struct hyper_buf *hyper_response_headers_raw(const struct hyper_response *resp);
+
+/*
+ Get the HTTP version used by this response.
+
+ The returned value could be:
+
+ - `HYPER_HTTP_VERSION_1_0`
+ - `HYPER_HTTP_VERSION_1_1`
+ - `HYPER_HTTP_VERSION_2`
+ - `HYPER_HTTP_VERSION_NONE` if newer (or older).
+ */
+int hyper_response_version(const struct hyper_response *resp);
+
+/*
+ Gets a reference to the HTTP headers of this response.
+
+ This is not an owned reference, so it should not be accessed after the
+ `hyper_response` has been freed.
+ */
+struct hyper_headers *hyper_response_headers(struct hyper_response *resp);
+
+/*
+ Take ownership of the body of this response.
+
+ It is safe to free the response even after taking ownership of its body.
+ */
+struct hyper_body *hyper_response_body(struct hyper_response *resp);
+
+/*
+ Iterates the headers passing each name and value pair to the callback.
+
+ The `userdata` pointer is also passed to the callback.
+
+ The callback should return `HYPER_ITER_CONTINUE` to keep iterating, or
+ `HYPER_ITER_BREAK` to stop.
+ */
+void hyper_headers_foreach(const struct hyper_headers *headers,
+                           hyper_headers_foreach_callback func,
+                           void *userdata);
+
+/*
+ Sets the header with the provided name to the provided value.
+
+ This overwrites any previous value set for the header.
+ */
+enum hyper_code hyper_headers_set(struct hyper_headers *headers,
+                                  const uint8_t *name,
+                                  size_t name_len,
+                                  const uint8_t *value,
+                                  size_t value_len);
+
+/*
+ Adds the provided value to the list of the provided name.
+
+ If there were already existing values for the name, this will append the
+ new value to the internal list.
+ */
+enum hyper_code hyper_headers_add(struct hyper_headers *headers,
+                                  const uint8_t *name,
+                                  size_t name_len,
+                                  const uint8_t *value,
+                                  size_t value_len);
+
+/*
+ Create a new IO type used to represent a transport.
+
+ The read and write functions of this transport should be set with
+ `hyper_io_set_read` and `hyper_io_set_write`.
+ */
+struct hyper_io *hyper_io_new(void);
+
+/*
+ Free an unused `hyper_io *`.
+
+ This is typically only useful if you aren't going to pass ownership
+ of the IO handle to hyper, such as with `hyper_clientconn_handshake()`.
+ */
+void hyper_io_free(struct hyper_io *io);
+
+/*
+ Set the user data pointer for this IO to some value.
+
+ This value is passed as an argument to the read and write callbacks.
+ */
+void hyper_io_set_userdata(struct hyper_io *io, void *data);
+
+/*
+ Set the read function for this IO transport.
+
+ Data that is read from the transport should be put in the `buf` pointer,
+ up to `buf_len` bytes. The number of bytes read should be the return value.
+
+ It is undefined behavior to try to access the bytes in the `buf` pointer,
+ unless you have already written them yourself. It is also undefined behavior
+ to return that more bytes have been written than actually set on the `buf`.
+
+ If there is no data currently available, a waker should be claimed from
+ the `ctx` and registered with whatever polling mechanism is used to signal
+ when data is available later on. The return value should be
+ `HYPER_IO_PENDING`.
+
+ If there is an irrecoverable error reading data, then `HYPER_IO_ERROR`
+ should be the return value.
+ */
+void hyper_io_set_read(struct hyper_io *io, hyper_io_read_callback func);
+
+/*
+ Set the write function for this IO transport.
+
+ Data from the `buf` pointer should be written to the transport, up to
+ `buf_len` bytes. The number of bytes written should be the return value.
+
+ If no data can currently be written, the `waker` should be cloned and
+ registered with whatever polling mechanism is used to signal when data
+ is available later on. The return value should be `HYPER_IO_PENDING`.
+
+ Yeet.
+
+ If there is an irrecoverable error reading data, then `HYPER_IO_ERROR`
+ should be the return value.
+ */
+void hyper_io_set_write(struct hyper_io *io, hyper_io_write_callback func);
+
+/*
+ Creates a new task executor.
+ */
+const struct hyper_executor *hyper_executor_new(void);
+
+/*
+ Frees an executor and any incomplete tasks still part of it.
+ */
+void hyper_executor_free(const struct hyper_executor *exec);
+
+/*
+ Push a task onto the executor.
+
+ The executor takes ownership of the task, it should not be accessed
+ again unless returned back to the user with `hyper_executor_poll`.
+ */
+enum hyper_code hyper_executor_push(const struct hyper_executor *exec, struct hyper_task *task);
+
+/*
+ Polls the executor, trying to make progress on any tasks that have notified
+ that they are ready again.
+
+ If ready, returns a task from the executor that has completed.
+
+ If there are no ready tasks, this returns `NULL`.
+ */
+struct hyper_task *hyper_executor_poll(const struct hyper_executor *exec);
+
+/*
+ Free a task.
+ */
+void hyper_task_free(struct hyper_task *task);
+
+/*
+ Takes the output value of this task.
+
+ This must only be called once polling the task on an executor has finished
+ this task.
+
+ Use `hyper_task_type` to determine the type of the `void *` return value.
+ */
+void *hyper_task_value(struct hyper_task *task);
+
+/*
+ Query the return type of this task.
+ */
+enum hyper_task_return_type hyper_task_type(struct hyper_task *task);
+
+/*
+ Set a user data pointer to be associated with this task.
+
+ This value will be passed to task callbacks, and can be checked later
+ with `hyper_task_userdata`.
+ */
+void hyper_task_set_userdata(struct hyper_task *task, void *userdata);
+
+/*
+ Retrieve the userdata that has been set via `hyper_task_set_userdata`.
+ */
+void *hyper_task_userdata(struct hyper_task *task);
+
+/*
+ Copies a waker out of the task context.
+ */
+struct hyper_waker *hyper_context_waker(struct hyper_context *cx);
+
+/*
+ Free a waker that hasn't been woken.
+ */
+void hyper_waker_free(struct hyper_waker *waker);
+
+/*
+ Wake up the task associated with a waker.
+
+ NOTE: This consumes the waker. You should not use or free the waker afterwards.
+ */
+void hyper_waker_wake(struct hyper_waker *waker);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+#endif /* _HYPER_H */
diff --git a/hyper/docs/CODE_OF_CONDUCT.md b/hyper/docs/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..32b8d28
--- /dev/null
+++ b/hyper/docs/CODE_OF_CONDUCT.md
@@ -0,0 +1,21 @@
+# Code of Conduct
+
+## Be Kind
+
+- Don't be mean.
+- Insulting anyone is prohibited.
+- Harassment of any kind is prohibited.
+- If another person feels uncomfortable with your remarks, stop it.
+- If a moderator deems your comment or conduct as inappropriate, stop it.
+- Disagreeing is fine, but keep it to technical arguments. Never attack the person.
+- Give the benefit of the doubt. Assume good intentions.
+- Show empathy. There are 3 interpretations to any message: what we thought, what we said, and what they understand.
+- This does mean we exclude people who are not kind. We are happy to make that sacrifice.
+
+## Or Else
+
+- Violations of the Code of Conduct will result in 1 warning.
+- If the violation is major, a moderator may just ban immediately.
+- If a warning has already been given, a moderator will ban the offender.
+- There is no process for appealing a ban.
+- Any violations can be reported to sean@seanmonstar.com.
diff --git a/hyper/docs/COMMITS.md b/hyper/docs/COMMITS.md
new file mode 100644
index 0000000..bf4c1db
--- /dev/null
+++ b/hyper/docs/COMMITS.md
@@ -0,0 +1,65 @@
+# Git Commit Guidelines
+
+We have very precise rules over how our git commit messages can be formatted.  This leads to **more
+readable messages** that are easy to follow when looking through the **project history**.  But also,
+we use the git commit messages to **generate the change log**.
+
+## Commit Message Format
+Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
+format that includes a **type**, a **scope** and a **subject**:
+
+```
+<type>(<scope>): <subject>
+<BLANK LINE>
+<body>
+<BLANK LINE>
+<footer>
+```
+
+Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
+to read on github as well as in various git tools.
+
+## Type
+Must be one of the following:
+
+* **feat**: A new feature
+* **fix**: A bug fix
+* **docs**: Documentation only changes
+* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
+  semi-colons, etc)
+* **refactor**: A code change that neither fixes a bug or adds a feature
+* **perf**: A code change that improves performance
+* **test**: Adding missing tests
+* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
+    generation
+
+## Scope
+The scope should refer to a module in hyper that is being touched. Examples:
+
+* client
+* server
+* http1
+* http2
+* ffi
+* upgrade
+* examples
+
+## Subject
+
+The subject contains succinct description of the change:
+
+* use the imperative, present tense: "change" not "changed" nor "changes"
+* don't capitalize first letter
+* no dot (.) at the end
+
+## Body
+
+Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes"
+The body should include the motivation for the change and contrast this with previous behavior.
+
+## Footer
+
+The footer should contain any information about **Breaking Changes** and is also the place to
+reference GitHub issues that this commit **Closes**.
+
+The last line of commits introducing breaking changes should be in the form `BREAKING CHANGE: <desc>`
diff --git a/hyper/docs/ISSUES.md b/hyper/docs/ISSUES.md
new file mode 100644
index 0000000..31a9027
--- /dev/null
+++ b/hyper/docs/ISSUES.md
@@ -0,0 +1,113 @@
+# Issues
+
+The [issue tracker][issues] for hyper is where we track all features, bugs, and discuss proposals.
+
+## Triaging
+
+Once an issue has been opened, it is normal for there to be discussion
+around it. Some contributors may have differing opinions about the issue,
+including whether the behavior being seen is a bug or a feature. This
+discussion is part of the process and should be kept focused, helpful, and
+professional.
+
+The objective of helping with triaging issues is to help reduce the issue
+backlog and keep the issue tracker healthy, while enabling newcomers another
+meaningful way to get engaged and contribute.
+
+### Acknowledge
+
+Acknowledge the human. This is meant actively, such as giving a welcome, or
+thanks for a detailed report, or any other greeting that makes the person feel
+that their contribution (issues are contributions!) is valued. It also is meant
+to be internalized, and be sure to always [treat the person kindly][COC]
+throughout the rest of the steps of triaging.
+
+### Ask for more info
+
+Frequently, we need more information than was originally provided to fully
+evaluate an issue.
+
+If it is a bug report, ask follow up questions that help us get a [minimum
+reproducible example][MRE]. This may take several round-trip questions. Once
+all the details are gathered, it may be helpful to edit the original issue text
+to include them all.
+
+### Categorize
+
+Once enough information has been gathered, the issue should be categorized
+with [labels][#labels]. Ideally, most issues should be labelled with an area,
+effort, and severity. An issue _can_ have multiple areas, pick what fits. There
+should be only one severity, and the descriptions of each should help to pick
+the right one. The hardest label to select is "effort". If after reading the
+descriptions of each effort level, you're still unsure, you can ping a
+maintainer to pick one.
+
+### Adjust the title
+
+An optional step when triaging is to adjust the title once more information is
+known. Sometimes an issue starts as a question, and through discussion, it
+turns out to be a feature request, or a bug report. In those cases, the title
+should be changed from a question, and the title should be a succinct action to
+be taken. For example, a question about an non-existent configuration option
+may be reworded to "Add option to Client to do Zed".
+
+### Mentoring
+
+The last part of triaging is to try to make the issue a learning experience.
+After a discussion with the reporter, it would be good to ask if they are now
+interested in submitting the change described in the issue.
+
+Otherwise, it would be best to leave the issue with a series of steps for
+anyone else to try to write the change. That could be pointing out that a
+design proposal is needed, addressing certain points. Or, if the required
+changes are mostly know, a list of links to modules and functions where code
+needs to be changed, and to what. That way we mentor newcomers to become
+successful contributors of new [pull requests][PRs].
+
+## Labels
+
+Issues are organized with a set of labels. Most labels follow a system of being prefixed by a "type".
+
+### Area
+
+The area labels describe what part of hyper is relevant.
+
+- **A-body**: streaming request and response bodies.
+- **A-client**: the HTTP client.
+- **A-dependencies**: library dependencies.
+- **A-docs**: documentation.
+- **A-error**: error reporting and types.
+- **A-ffi**: the C API.
+- **A-http1**: the HTTP/1 specifics.
+- **A-http2**: the HTTP/2 specifics.
+- **A-server**: the HTTP server.
+- **A-tests**: the unit and integration tests.
+
+### Blocked
+
+These labels indicate an issue is "blocked" for some reason.
+
+- **B-breaking-change**: a breaking change that is waiting for the next semver-compatible release.
+- **B-rfc**: request for comments. More discussion is needed to explore the design.
+- **B-upstream**: waiting on something in a dependency or the compiler.
+
+### Effort
+
+The effort labels are a best-guess at roughly how much effort and knowledge of hyper is needed to accomplish the task.
+
+- **E-easy**: a great starting point for a new contributor.
+- **E-medium**: some knowledge of how hyper internals work would be useful.
+- **E-hard**: likely requires a deeper understanding of how hyper internals work.
+
+### Severity
+
+The severity marks how _severe_ the issue is. Note this isn't "importance" or "priority".
+
+- **S-bug**: something is wrong, this is bad!
+- **S-feature**: this is a new feature request, adding something new.
+- **S-performance**: make existing working code go faster.
+- **S-refactor**: improve internal code to help readability and maintenance.
+
+[issues]: https://github.com/hyperium/hyper/issues
+[COC]: ./CODE_OF_CONDUCT.md
+[PRs]: ./PULL_REQUESTS.md
diff --git a/hyper/docs/MSRV.md b/hyper/docs/MSRV.md
new file mode 100644
index 0000000..65127c9
--- /dev/null
+++ b/hyper/docs/MSRV.md
@@ -0,0 +1,9 @@
+# Minimum Support Rust Version (MSRV)
+
+hyper's current policy is to always support a Rust version at least 6 months
+old. That is, a compiler version released within the last 6 months can compile
+hyper. It is possible that an older compiler can work, but that is not
+guaranteed. We try to increase the MSRV responsibly, only when a significant
+new feature is needed.
+
+The current MSRV is: **1.56**.
diff --git a/hyper/docs/PULL_REQUESTS.md b/hyper/docs/PULL_REQUESTS.md
new file mode 100644
index 0000000..0df7d73
--- /dev/null
+++ b/hyper/docs/PULL_REQUESTS.md
@@ -0,0 +1,49 @@
+# Pull Requests
+
+Pull requests are the way to submit changes to the hyper repository.
+
+## Submitting a Pull Request
+
+In most cases, it a good idea to discuss a potential change in an
+[issue](ISSUES.md). This will allow other contributors to provide guidance and
+feedback _before_ significant code work is done, and can increase the
+likelihood of getting the pull request merged.
+
+### Tests
+
+If the change being proposed alters code (as opposed to only documentation for
+example), it is either adding new functionality to hyper or it is fixing
+existing, broken functionality. In both of these cases, the pull request should
+include one or more tests to ensure that hyper does not regress in the future.
+
+### Commits
+
+Once code, tests, and documentation have been written, a commit needs to be
+made. Following the [commit guidelines](COMMITS.md) will help with the review
+process by making your change easier to understand, and makes it easier for
+hyper to produce a valuable changelog with each release.
+
+However, if your message doesn't perfectly match the guidelines, **do not
+worry!** The person that eventually merges can easily fixup the message at that
+time.
+
+### Opening the Pull Request
+
+From within GitHub, open a new pull request from your personal branch.
+
+Once opened, pull requests are usually reviewed within a few days.
+
+### Discuss and Update
+
+You will probably get feedback or requests for changes to your Pull Request.
+This is a big part of the submission process so don't be discouraged! Some
+contributors may sign off on the Pull Request right away, others may have more
+detailed comments or feedback. This is a necessary part of the process in order
+to evaluate whether the changes are correct and necessary.
+
+Any community member can review a PR and you might get conflicting feedback.
+Keep an eye out for comments from code owners to provide guidance on
+conflicting feedback.
+
+You don't need to close the PR and create a new one to address feedback. You
+may simply push new commits to the existing branch.
diff --git a/hyper/docs/README.md b/hyper/docs/README.md
new file mode 100644
index 0000000..fe1a5d5
--- /dev/null
+++ b/hyper/docs/README.md
@@ -0,0 +1,3 @@
+# Developing hyper
+
+This is a set of documents outline how hyper is developed, how to contribute or get involved, various processes we use, and internal design explanations.
diff --git a/hyper/docs/ROADMAP.md b/hyper/docs/ROADMAP.md
new file mode 100644
index 0000000..184cc7a
--- /dev/null
+++ b/hyper/docs/ROADMAP.md
@@ -0,0 +1,404 @@
+# hyper 1.0 Roadmap
+
+## Goal
+
+Align current hyper to the [hyper VISION][VISION].
+
+The VISION outlines a decision-making framework, use-cases, and general shape
+of hyper. This roadmap describes the currently known problems with hyper, and
+then shows what changes are needed to make hyper 1.0 look more like what is in
+the VISION.
+
+## Known Issues
+
+
+> **Note**: These known issues are as of hyper v0.14.x. After v1.0 is released,
+ideally these issues will have been solved. Keeping this history may be helpful
+to Future Us, though.
+
+### Higher-level Client and Server problems
+
+Both the higher-level `Client` and `Server` types have stability concerns.
+
+For the `hyper::Server`:
+
+- The `Accept` trait is complex, and too easy to get wrong. If used with TLS, a slow TLS handshake
+  can affect all other new connections waiting for it to finish.
+- The `MakeService<&IO>` is confusing. The bounds are an assault on the eyes.
+- The `MakeService` API doesn't allow to easily annotate the HTTP connection with `tracing`.
+- Graceful shutdown doesn't give enough control.
+
+
+It's more common for people to simply use `hyper::server::conn` at this point,
+than to bother with the `hyper::Server`.
+
+While the `hyper::Client` is much easier to use, problems still exist:
+
+- The whole `Connect` design isn't stable.
+  - ALPN and proxies can provide surprising extra configuration of connections.
+  - Some `Connect` implementations may wish to view the path, in addition to the scheme, host, and port.
+  - Wants `runtime` feature
+- The Pool could be made more general or composable. At the same time, more customization is
+  desired, and it's not clear
+how to expose it yet.
+
+
+### Runtime woes
+
+hyper has been able to support different runtimes, but it has sometimes awkward
+default support for Tokio.
+
+- The `runtime` cargo-feature isn't additive
+- Built-in Tokio support can be confusing
+- Executors and Timers
+  - The `runtime` feature currently enables a few options that require a timer, such as timeouts and
+    keepalive intervals. It implicitly relies on Tokio's timer context. This can be quite confusing.
+- IO traits
+  - Should we publicly depend on Tokio's traits?
+  - `futures-io`?
+    - Definitely nope.
+    - Not stable. (0.3?)
+    - No uninitialized memory.
+  - Eventual `std` traits?
+    - They've been in design for years.
+    - We cannot base our schedule on them.
+    - When they are stable, we can:
+      - Provide a bridge in `hyper-util`.
+      - Consider a 2.0 of hyper.
+  - Define our own traits, provide util wrappers?
+
+### Forwards-compatibility
+
+There's a concern about forwards-compatibility. We want to be able to add
+support for new HTTP features without needing a new major version. While most
+of `http` and `hyper` are prepared for that, there's two potential problems.
+
+- New frames on an HTTP stream (body)
+   - Receiving a new frame type would require a new trait method
+     - There's no way to implement a "receive unknown frame" that hyper doesn't know about.
+   - Sending an unknown frame type would be even harder.
+     - Besides being able to pass an "unknown" type through the trait, the user would need to be
+       able to describe how that frame is encoded in HTTP/2/3.
+- New HTTP versions
+  - HTTP/3 will require a new transport abstraction. It's not as simple as just using some
+    `impl AsyncRead + AsyncWrite`. While HTTP/2 bundled the concept of stream creation internally,
+    and thus could be managed wholly on top of a read-write transport, HTTP/3 is different. Stream
+    creation is shifted to the QUIC protocol, and HTTP/3 needs to be able to use that directly.
+  - This means the existing `Connection` types for both client and server will not be able to
+    accept a QUIC transport so we can add HTTP/3 support.
+
+### Errors
+
+It's not easy to match for specific errors.
+
+The `Error::source()` can leak an internal dependency. For example, a
+`hyper::Error` may wrap an `h2::Error`. Users can downcast the source at
+runtime, and hyper internally changing the version of its `h2` dependency can
+cause runtime breakage for users.
+
+Formatting errors is in conflict with the current expected norm. The
+`fmt::Display` implementation for `hyper::Error` currently prints its own
+message, and then prints the message of any wrapped source error. The Errors
+Working Group currently recommends that errors only print their own message
+(link?). This conflict means that error "reporters", which crawl a source chain
+and print each error, has a lot of duplicated information.
+
+```
+error fetching website: error trying to connect: tcp connect error: Connection refused (os error 61)
+tcp connect error: Connection refused (os error 61)
+Connection refused (os error 61)
+```
+
+While there is a good reason for why hyper's `Error` types do this, at the very
+least, it _is_ unfortunate.
+
+### You call hyper, or hyper calls you?
+
+> Note: this problem space, of who calls whom, will be explored more deeply in
+> a future article.
+
+At times, it's been wondered whether hyper should call user code, or if user
+code should call hyper. For instance, should a `Service` be called with a
+request when the connection receives one, or should the user always poll for
+the next request.
+
+There's a similar question around sending a message body. Should hyper ask the
+body for more data to write, or should the user call a `write` method directly?
+
+These both get at a root topic about [write
+observability](https://github.com/hyperium/hyper/issues/2181). How do you know
+when a response, or when body data, has been written successfully? This is
+desirable for metrics, or for triggering other side-effects. 
+
+The `Service` trait also has some other frequently mentioned issues. Does
+`poll_ready` pull its complexity weight for servers? What about returning
+errors, what does that mean? Ideally users would turn all errors into
+appropriate `http::Response`s. But in HTTP/2 and beyond, stream errors are
+different from HTTP Server Error responses. Could the `Service::Error` type do
+more to encourage best practices?
+
+## Design
+
+The goal is to get hyper closer to the [VISION][], using that to determine the
+best way to solve the known issues above. The main thrust of the proposed
+changes are to make hyper more **Flexible** and stable.
+
+In order to keep hyper **Understandable**, however, the proposed changes *must*
+be accompanied by providing utilities that solve the common usage patterns,
+documentation explaining how to use the more flexible pieces, and guides on how
+to reach for the `hyper-util`ity belt.
+
+The majority of the changes are smaller and can be contained to the *Public
+API* section, since they usually only apply to a single module or type. But the
+biggest changes are explained in detail here.
+
+### Split per HTTP version
+
+The existing `Connection` types, both for the client and server, abstract over
+HTTP version by requiring a generic `AsyncRead + AsyncWrite` transport type.
+But as we figure out HTTP/3, that needs to change. So to prepare now, the
+`Connection` types will be split up.
+
+For example, there will now be `hyper::server::conn::http1::Connection` and
+`hyper::server::conn::http2::Connection` types.
+
+These specific types will still have a very similar looking API that, as the
+VISION describes, provides **Correct** connection management as it pertains to
+HTTP.
+
+There will be still be a type to wrap the different versions. It will no longer
+be generic over the transport type, to prepare for being able to wrap HTTP/3
+connections. Exactly how it will wrap, either by using internal trait objects,
+or an `enum Either` style, or using a `trait Connection` that each type
+implements, is something to be determined. It's likely that this "auto" type
+will start in `hyper-util`.
+
+### Focus on the `Connection` level
+
+As mentioned in the *Known Issues*, the higher-level `Client` and `Server` have
+stability and complexity problems. Therefore, for hyper 1.0, the main API will
+focus on the "lower-level" connection types. The `Client` and `Server` helpers
+will be moved to `hyper-util`.
+
+## Public API
+
+### body
+
+The `Body` struct is removed. Its internal "variants" are [separated into
+distinct types](https://github.com/hyperium/hyper/issues/2345), and can start
+in either `hyper-util` or `http-body-util`.
+
+The exported trait `HttpBody` is renamed to `Body`.
+
+A single `Body` implementation in `hyper` is the one provided by receiving
+client responses and server requests. It has the name `Streaming`.
+
+> **Unresolved**: Other names can be considered during implementation. Another
+> option is to not publicly name the implementation, but return `Response<impl
+Body>`s.
+
+The `Body` trait will be experimented on to see about making it possible to
+return more frame types beyonds just data and trailers.
+
+> **Unresolved**: What exactly this looks like will only be known after
+> experimentation.
+
+### client
+
+The high-level `hyper::Client` will be removed, along with the
+`hyper::client::connect` module. They will be explored more in `hyper-util`.
+
+As described in *Design*, the `client::conn` module will gain `http1` and
+`http2` sub-modules, providing per-version `SendRequest`, `Connection`, and
+`Builder` structs. An `auto` version can be explored in `hyper-util`.
+
+### error
+
+The `hyper::Error` struct remains in place.
+
+All errors returned from `Error::source()` are made opaque. They are wrapped an
+internal `Opaque` newtype that still allows printing, but prevents downcasting
+to the internal dependency.
+
+A new `hyper::error::Code` struct is defined. It is an opaque struct, with
+associated constants defining various code variants.
+
+> Alternative: define a non-exhaustive enum. It's not clear that this is
+> definitely better, though. Keeping it an opaque struct means we can add
+> secondary parts to the code in the future, or add bit flags, or similar
+> extensions.
+
+The purpose of `Code` is to provide an abstraction over the kind of error that
+is encountered. The `Code` could be some behavior noticed inside hyper, such as
+an incomplete HTTP message. Or it can be "translated" from the underlying
+protocol, if it defines protocol level errors. For example, an
+`h2::Reason::CANCEL`.
+
+### rt
+
+The `Executor` trait stays in here.
+
+Define a new trait `Timer`, which describes a way for users to provide a source
+of sleeping/timeout futures. Similar to `Executor`, a new generic is added to
+connection builders to provide a `Timer`.
+
+### server
+
+The higher-level `hyper::Server` struct, its related `Builder`, and the
+`Accept` trait are all removed.
+
+The `AddrStream` struct will be completely removed, as it provides no value but
+causes binary bloat.
+
+Similar to `client`, and as describe in the *Design*, the `conn` modules will
+be expanded to support `http1` and `http2` submodules. An `auto` version can be
+explored in `hyper-util`.
+
+### service
+
+A vendored and simplified `Service` trait will be explored.
+
+The error type for `Service`s used for a server will explore having the return
+type changed from any error to one that can become a `hyper::error::Code`.
+
+> **Unresolved**: Both of the above points are not set in stone. We will
+> explore and decide if they are the best outcome during development.
+
+The `MakeService` pieces will be removed.
+
+### Cargo Features
+
+Remove the `stream` feature. The `Stream` trait is not stable, and we cannot
+depend on an unstable API.
+
+Remove the `tcp` and `runtime` features. The automatic executor and timer parts
+are handled by providing implementations of `Executor` and `Timer`. The
+`connect` and `Accept` parts are also moving to `hyper-util`.
+
+### Public Dependencies
+
+- `http`
+- `http-body`
+- `bytes`
+
+Cannot be public while "unstable":
+
+- `tracing`
+
+## `hyper-util`
+
+
+### body
+
+A channel implementation of `Body` that has an API to know when the data has
+been successfully written is provided in `hyper_util::body::channel`.
+
+### client
+
+A `Pool` struct that implements `Service` is provided. It fills a similar role
+as the previous `hyper::Client`.
+
+> **Note**: The `Pool` might be something that goes into the `tower` crate
+> instead. Or it might stay here as a slightly more specialized racing-connect
+> pool. We'll find out as we go.
+
+A `connect` submodule that mostly mirrors the existing `hyper::client::connect`
+module is moved here. Connectors can be used as a source to provide `Service`s
+used by the `Pool`.
+
+### rt
+
+We can provide Tokio-backed implementations of `Executor` and `Timer`.
+
+### server
+
+A `GracefulShutdown` helper is provided, to allow for similar style of graceful
+shutdown as the previous `hyper::Server` did, but with better control.
+
+# Appendix
+
+## Unresolved Questions
+
+There are some parts of the proposal which are not fully resolved. They are
+mentioned in Design and API sections above, but also collected here for easy
+finding. While they all have _plans_, they are more exploratory parts of the
+API, and thus they have a higher possibility of changing as we implement them.
+
+The goal is to have these questions resolved and removed from the document by
+the time there is a [Release Candidate][timeline].
+
+### Should there be `hyper::io` traits?
+
+Depending on `tokio` just for `AsyncRead` and `AsyncWrite` is convenient, but
+can be confusing for users integrating hyper with other runtimes. It also ties
+our version directly to Tokio. We can consider having vendored traits, and
+providing Tokio wrappers in `hyper-util`.
+
+### Should returned body types be `impl Body`?
+
+### How could the `Body` trait prepare for unknown frames?
+
+We will experiment with this, and keep track of those experiments in a
+dedicated issue. It might be possible to use something like this:
+
+```rust
+pub trait Body {
+    type Data;
+    fn poll_frame(..) -> Result<Option<Frame<Self::Data>>>;
+}
+
+pub struct Frame<T>(Kind<T>);
+
+enum Kind<T> {
+   Data(T),
+   Trailers(HeaderMap),
+   Unknown(Box<dyn FrameThingy>),
+}
+```
+
+### Should there be a simplified `hyper::Service` trait, or should hyper depend on `tower-service`?
+
+- There's still a few uncertain decisions around tower, such as if it should be
+  changed to `async fn call`, and if `poll_ready` is the best way to handle
+  backpressure.
+- It's not clear that the backpressure is something needed at the `Server`
+  boundary, thus meaning we should remove `poll_ready` from hyper.
+- It's not 100% clear if we should keep the service pattern, or use a
+  pull-based API. This will be explored in a future blog post.
+
+## FAQ
+
+### Why did you pick _that_ name? Why not this other better name?
+
+Naming is hard. We certainly should solve it, but discussion for particular
+names for structs and traits should be scoped to the specific issues. This
+document is to define the shape of the library API.
+
+### Should I publicly depend on `hyper-util`?
+
+The `hyper-util` crate will not reach 1.0 when `hyper` does. Some types and
+traits are being moved to `hyper-util`. As with any pre-1.0 crate, you _can_
+publicly depend on it, but it is explicitly less stable.
+
+In most cases, it's recommended to not publicly expose your dependency on
+`hyper-util`. If you depend on a trait, such as used by the moved higher-level
+`Client` or `Server`, it may be better for your users to define your own
+abstraction, and then make an internal adapter.
+
+### Isn't this making hyper harder?
+
+We are making hyper more **flexible**. As noted in the [VISION][], most use
+cases of hyper require it to be flexible. That _can_ mean that the exposed API
+is lower level, and that it feels more complicated. It should still be
+**understandable**.
+
+But the hyper 1.0 effort is more than just the single `hyper` crate. Many
+useful helpers will be migrated to a `hyper-util` crate, and likely improved in
+the process. The [timeline][] also points out that we will have a significant
+documentation push. While the flexible pieces will be in hyper to compose how
+they need, we will also write guides for the [hyper.rs][] showing people how to
+accomplish the most common tasks.
+
+[timeline]: https://seanmonstar.com/post/676912131372875776/hyper-10-timeline
+[VISION]: https://github.com/hyperium/hyper/pull/2772
+[hyper.rs]: https://hyper.rs
diff --git a/hyper/docs/TENETS.md b/hyper/docs/TENETS.md
new file mode 100644
index 0000000..5517289
--- /dev/null
+++ b/hyper/docs/TENETS.md
@@ -0,0 +1,100 @@
+# Charter
+
+> hyper is a protective and efficient HTTP library for all.
+
+# Tenets
+
+Tenets are guiding principles. They guide how decisions are made for the whole
+project. Ideally, we do all of them all the time. In some cases, though, we may
+be forced to decide between slightly penalizing one goal or another. In that
+case, we tend to support those goals that come earlier in the list over those
+that come later (but every case is different).
+
+## 0. Open
+
+hyper is open source, always. The success of hyper depends on the health of the
+community building and using it. All contributions are in the open. We don't
+maintain private versions, and don't include features that aren't useful to
+others.
+
+[We prioritize kindness][CONDUCT], compassion and empathy towards all
+contributors. Technical skill is not a substitute for human decency.
+
+[CONDUCT]: https://github.com/hyperium/hyper/blob/master/docs/CODE_OF_CONDUCT.md
+
+### Examples
+
+It's not usually hard for an open source library to stay open and also meet its
+other priorities. Here's some instances where being **Open** would be more
+important than **Correct** or **Fast**:
+
+- Say an individual were to bring forward a contribution that makes hyper more
+  correct, or faster, perhaps fixing some serious bug. But in doing so, they
+  also insulted people, harassed other contributors or users, or shamed
+  everyone for the previous code. They felt their contribution was "invaluable".
+  We would not accept such a contribution, instead banning the user and
+  rewriting the code amongst the kind collaborators of the project.
+
+- Say someone brings a contribution that adds a new feature useful for
+  performance or correctness, but their work accomplishes this by integrating
+  hyper with a proprietary library. We would not accept such a contribution,
+  because we don't want such a feature limited only to those users willing to
+  compromise openness, and we don't want to bifurcate the ecosystem between those
+  who make that compromise and those who don't.
+
+## 1. Correct
+
+hyper is a memory safe and precise implementation of the HTTP specification.
+Memory safety is vital in a core Internet technology. Following the HTTP
+specifications correctly protects users. It makes the software durable to the
+“real world”. Where feasible, hyper enforces correct usage.
+
+This is more than just "don't write bugs". hyper actively protects the user.
+
+### Examples
+
+- Even though we follow the **HTTP/\*** specs, hyper doesn't blindly implement
+  everything without considering if it is safe to do so.
+
+## 2. Fast
+
+A fast experience delights users. A faster network library means a faster
+application, resulting in delighting our users’ users. Whether with one request,
+or millions.
+
+Being _fast_ means we improve throughput, drive down CPU usage, and improve
+sustainability.
+
+Fast _enough_. We don't sacrifice sanity for speed.
+
+## 3. HTTP/*
+
+hyper is specifically focused on HTTP. Supporting new HTTP versions is in scope,
+but supporting separate protocols is not.
+
+This also defines what the abstraction layer is: the API is designed around
+sending and receiving HTTP messages.
+
+## 4. Flexible
+
+hyper enables as many usecases as possible. It has no opinion on application
+structure, and makes few assumptions about its environment. This includes being
+portable to different operating systems.
+
+### Examples
+
+- While we choose safer defaults to be **Correct**, hyper includes options to
+  _allow_ different behavior, when the user requires them.
+- Providing choice usually makes things more complex, so being **Flexible** does
+  mean it's less _easy_. That can sometimes conflict with simplest way of making
+  hyper **Understandable**.
+
+## 5. Understandable
+
+hyper is [no more complicated than it has to
+be](https://en.wikipedia.org/wiki/Occam%27s_razor). HTTP is not simple. It may
+not be as "easy" as 1-line to do everything, but it shouldn't be "hard" to find
+the answers.
+
+From logical and misuse-resistant APIs, to stellar documentation, to transparent
+metrics.
diff --git a/hyper/docs/VISION.md b/hyper/docs/VISION.md
new file mode 100644
index 0000000..75104c3
--- /dev/null
+++ b/hyper/docs/VISION.md
@@ -0,0 +1,230 @@
+# hyper Vision
+
+## Purpose
+
+This is an overview of what the shape of hyper looks like, but also somewhat
+zoomed out, so that the _vision_ can survive while the exact minute details
+might shift and change over time.
+
+### Charter
+
+> hyper is a protective and efficient HTTP library for all.
+
+### Tenets
+
+Tenets are guiding principles. They guide how decisions are made for the whole
+project. Ideally, we do all of them all the time. In some cases, though, we may
+be forced to decide between slightly penalizing one goal or another. In that
+case, we tend to support those goals that come earlier in the list over those
+that come later (but every case is different).
+
+0. Open
+1. Correct
+2. Fast
+3. HTTP/\*
+4. Flexible
+5. Understandable
+
+There's a lot more detail about each in [TENETS](./TENETS.md).
+
+## Use Cases
+
+Who are the *users* of hyper? How would they use hyper?
+
+### Low-Level Client Library (curl, reqwest, aws-sdk)
+
+These client libraries care that hyper is **Flexible**, since they are
+expressing their own opinion on how a more-featured HTTP client should act.
+This includes opinions on connection establishment, management, pooling, HTTP
+version options, and even runtimes.
+
+curl's main reason for using hyper is that it is **Safe**.
+
+### Web Server Frameworks (deno, axum)
+
+These are using hyper's server feature to expose a different, higher-level API
+to users. Besides the obvious requirements, these require that hyper is
+**Fast**. Servers are costly, handling more requests faster is important to
+them.
+
+That hyper is **Flexible** is also important, in that it needs to be flexible
+enough for them to build a server framework, and allow them to express their
+own opinions about API to their users.
+
+### Services and Proxies (linkerd, cloudflare, fastly)
+
+These are using hyper directly, likely both the client and server, in order to
+build efficient and powerful services, applications, and tools for their end
+users. They care greatly that hyper is **Correct**, since web traffic can
+stretch the limits of what is valid HTTP, and exercise less-common parts of the
+specifications.
+
+They also require hyper to be **Fast**, for similar reasons that the web server
+frameworks do.
+
+### New Rust Web Developers
+
+These are developers who are either new to Rust, or new to web servers, and
+have reached for hyper to start with.
+
+It's likely that these users don't have strong opinions about how an HTTP
+server or client should work, just that it _should_ handle all the things they
+normally assume it would. For these users, it would be best to quickly help
+them compare their own expectations with hyper's capabilities, and may
+suggest reaching for higher-level, _easier_ libraries instead.
+
+Those that stick around after that recommendation are users that wish both to
+learn at a lower level, and to pick and choose what batteries they plug in to
+hyper as they move along. While they do care about the other tenets, that hyper
+is **Understandable** is of extra importance to them.
+
+## The Library
+
+So with all that context in mind, what does hyper, the library, actually look
+like? This doesn't highlight what _is_ and _isn't_ present. What currently
+needs to change to reach this vision is left to individual version roadmaps.
+
+### Layers
+
+In all cases, a user brings their own runtime and IO to work with hyper. The IO
+is provided to hyper, and hyper acts on top of it. hyper returns `Future`s that
+the user then decides how to poll, likely involving their runtime options.
+
+![architecture diagram](./vision-arch.svg)
+
+
+#### Protocol Codecs
+
+hyper has dedicated codecs for the major HTTP versions. Each is internally
+designed to be **Correct** and **Fast** when it comes to encoding and decoding.
+
+The individual codecs may be implemented as sub-crates, with a less-stable
+promise, to support the **Flexible** needs of some users who wish to build
+their own connection management, or customize encoding and decoding beyond what
+is officially supported.
+
+#### Connection State Management
+
+A **Correct** implementation includes more than just enforcing certain
+characters when encoding and decoding. Order of frames, and flags in certain
+frames can affect the state of the connection. Some examples of things enforced
+at this layer:
+
+- If a message has a `content-length`, enforce only that many bytes are read or
+  written.
+- Reading a `Response` before a `Request` is even written implies a mismatched
+  reply that should be interpreted as an error.
+- The presence of some headers, such as `Connection: close`, or the absence of
+  others, such as `content-length` and `transfer-encoding`, can mean that the
+  connection should terminate after the current message.
+- HTTP/2 and HTTP/3 may send connection-level frames that don't pertain to any
+  specific transaction, and must be read and handled regardless of if a user is
+  currently checking for a message.
+
+#### HTTP Role and Version Abstraction
+
+This is the public API layer. Methods exposed are around sending and receiving
+`http::Request`s and `http::Response`s, not around framing specifics of the
+different versions. These are built around a client or server `Connection`
+interface.
+
+By exposing this layer publicly, we take care of the **Correct** tenet, by not
+forcing the user to send the specific frames themselves. The API should be
+designed in a way that a user cannot easily (if at all) create an _incorrect_
+HTTP connection.
+
+Motivated by the **Flexible** tenet, there _are_ version-specific options that
+can be configured at this level, and version-specific functionality can usually
+be handled via `http::Extensions`.
+
+### Not quite stable, but utile (useful)
+
+Beyond what is directly in the hyper crate, there are useful (utile) parts that
+may not meet hyper's stability promise. Developing, experimenting, and exposing
+those parts is the purpose of the `hyper-util` crate. That crate does not have
+the same stability level as hyper. However, the goal is that things that other
+libraries might want to expose as a public dependency do not live in
+`hyper-util` forever, but rather stabilize and get promoted into `hyper`.
+
+Exactly what gets put into `hyper-util` presently is kept in the roadmap
+documents.
+
+### Stability Promise
+
+What even is hyper's stability promise? Does it mean we are "done"? No. Will we
+ever make breaking changes again? Probably. We'll still follow the [semantic
+versioning](https://semver.org).
+
+Prior to 1.0, hyper has already only done breaking changes once a year. So 1
+year isn't much of a promise. We'll have significant more use and understanding
+after a few years, and that could prompt some redesign.
+
+As of this writing, we'll promise that _major_ versions of hyper are stable for
+3 years. New features will come out in _minor_ versions frequently. If it is
+determined necessary to make breaking changes to the API, we'll save them for
+after the 3 years.
+
+hyper also establishes a Minimum Supported Rust Version (MSRV). hyper will
+support Rust versions at least 6 months old. If a new Rust version is released
+with a feature hyper wishes to use, we won't do so until at least 6 months
+afterwards. hyper will only ever require a new Rust version as a _minor_
+release (1.x), not as a patch (1.x.y).
+
+## Security
+
+The security of hyper is a large part of what makes hyper _protective_. We make
+hyper secure via the combined efforts of being **Correct**, focusing on
+**HTTP/\***, and making it all **Understandable**.
+
+### Memory Safety
+
+Being **Correct** requires that hyper be memory-safe. Using the Rust language
+gets us most of the way there. But there is the ability to write `unsafe`
+Rust. Does being **Correct** mean that we can _never_ write `unsafe` code
+anywhere? Even if it helps make hyper **Fast**? We can, carefully.
+
+How do we balance the two, so that hyper is secure?
+
+hyper prefers not to have large modules of intertwined `unsafe` code. hyper
+does allow small `unsafe` blocks, no more than a few lines, where it's easier
+to verify that the `unsafe` code was written **Correctly**.
+
+### Meticulous Testing
+
+hyper's test suite grows and grows. There's a lot that needs to be right.
+Parsers, encoders, state machines. When easily isolated, those pieces have
+internal unit tests. But hyper also keeps a large list of growing integration
+tests that make sure all the parts are **Correct**.
+
+Making writing new tests easy is a high priority. Investing in the testing
+infrastructure is a proven way to make sure hyper stays **Correct** and secure.
+
+### Constant Fuzzing
+
+One thing is to know specific cases to test for. But we can't know all the
+inputs or states that *might* cause a bug. That's why hyper has rounds of
+fuzzing built into its CI. It's also why hyper signs up for and uses resources
+to provide *constant*, around-the-clock fuzzing, always looking for something
+that hyper should be hardened against.
+
+### Security Process
+
+hyper has an outlined
+[SECURITY](https://github.com/hyperium/hyper/blob/master/SECURITY.md) process,
+so we can safely report and fix issues.
+
+## Non-goals
+
+After writing this up, it is easier to articulate what sorts of things many
+might associate with an HTTP library, but which are explicitly *not* for hyper.
+These are all things that definitely **out of scope**.
+
+- TLS: We learned early that bundling TLS directly in hyper [has
+  problems](https://github.com/hyperium/hyper/issues/985). People also have
+  very strong opinions about which TLS implementation to use. The design of
+  hyper allows users to bring their own TLS.
+- Routing
+- Cookies
+- Not-HTTP: WebSockets, or other protocols that are built next to HTTP. It
+  should be possible to _use_ hyper to upgrade, but the actual next-protocol
+  should be handled by a different library.
diff --git a/hyper/docs/vision-arch.svg b/hyper/docs/vision-arch.svg
new file mode 100644
index 0000000..c0a8f9b
--- /dev/null
+++ b/hyper/docs/vision-arch.svg
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Do not edit this file with editors other than diagrams.net -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" style="background-color: rgb(255, 255, 255);" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="401px" height="381px" viewBox="-0.5 -0.5 401 381" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2022-03-14T15:24:10.980Z&quot; agent=&quot;5.0 (Windows)&quot; etag=&quot;5GW9xmoXkXI_t_oHIfuD&quot; version=&quot;16.5.3&quot;&gt;&lt;diagram id=&quot;2mAnZI3o06idv06jzYpb&quot; name=&quot;Page-1&quot;&gt;3Zddb9sgFIZ/jS8n2WA7zuWafmwX+5BSadfEHAdUbCxM4mS/fjjGXyGtWi1ps0mWBS8HDjy8MtjDi3z3oEjJvkkKwkM+3Xn41kMoCBHymsen+1aZ+34rrBWnNmgQlvw3WLEL23AK1SRQSyk0L6diKosCUj3RiFKynoZlUkyzlmQNjrBMiXDVX5xq1qpJ5A/6F+Br1mUOuvXlpAu2QsUIlfVIwnceXigpdVvKdwsQDbyOS9vv/pnWfmIKCv2aDiy+xejx5/dSRWi2Lasn/Fh+sqNsidjYBaeCNwO2U9b7joOSm4JCM5Tv4ZuacQ3LkqRNa2123mhM58LUAlN0p9blAaVhN5LsVB9A5qDV3oT0zrHYrG+Cua3Xwy4EidXYaAdiqxG78et+6IGNKVg8b0CFHVQVKLOgD0eFrw5V6KDyUCxM1hvKt6a4bopsXxp4+LN5SiW17EJMxlHUh9M9NiKauXTxu9KNHLpM6zL4O1IZF2IhhVSHvjjLMpSmRq+0kk8waqHxKo7iy7DF0QnnovdkG7ts0ZnBQvwM2Nl85fvnAdub9GrAzlyw+B8EG/rXBjZxwH798QLY4M1gaQQJDU+BTdAKxxf6FIThKz+z4aXAzk8cYkdYq5rnghRwgEOUttfXM3ktwEfneuIi6f04RnI5Jt2tfAQFdpButLFE4/p781abQvMc/gMP9nf5Cxz1pjpc/Q9tox8ofPcH&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><rect x="10" y="90" width="180" height="60" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 120px; margin-left: 11px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">client</div></div></div></foreignObject><text x="100" y="124" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">client</text></switch></g><rect x="210" y="90" width="180" height="60" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 120px; margin-left: 211px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">server</div></div></div></foreignObject><text x="300" y="124" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">server</text></switch></g><rect x="10" y="170" width="380" height="60" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 378px; height: 1px; padding-top: 200px; margin-left: 11px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;"><div>hyper::proto</div></div></div></div></foreignObject><text x="200" y="204" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">hyper::proto</text></switch></g><rect x="10" y="250" width="120" height="60" fill="#fff2cc" stroke="#d6b656" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 280px; margin-left: 11px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">http1</div></div></div></foreignObject><text x="70" y="284" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">http1</text></switch></g><rect x="140" y="250" width="120" height="60" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 280px; margin-left: 141px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">h2</div></div></div></foreignObject><text x="200" y="284" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">h2</text></switch></g><rect x="270" y="250" width="120" height="60" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 280px; margin-left: 271px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">h3</div></div></div></foreignObject><text x="330" y="284" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">h3</text></switch></g><rect x="10" y="340" width="380" height="40" rx="6" ry="6" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 378px; height: 1px; padding-top: 360px; margin-left: 11px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: all; white-space: normal; overflow-wrap: normal;">IO</div></div></div></foreignObject><text x="200" y="364" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">IO</text></switch></g><path d="M 0 80 L 0 80 L 400 80 L 400 80" fill="rgb(255, 255, 255)" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="all"/><path d="M 0 80 L 0 320 L 400 320 L 400 80" fill="none" stroke="rgb(0, 0, 0)" stroke-miterlimit="10" pointer-events="none"/><rect x="10" y="0" width="380" height="60" rx="9" ry="9" fill="#d5e8d4" stroke="#82b366" pointer-events="none"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 378px; height: 1px; padding-top: 30px; margin-left: 11px;"><div style="box-sizing: border-box; font-size: 0px; text-align: center;" data-drawio-colors="color: rgb(0, 0, 0); "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: rgb(0, 0, 0); line-height: 1.2; pointer-events: none; white-space: normal; overflow-wrap: normal;">executor / runtime</div></div></div></foreignObject><text x="200" y="34" fill="rgb(0, 0, 0)" font-family="Helvetica" font-size="12px" text-anchor="middle">executor / runtime</text></switch></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.diagrams.net/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg>
diff --git a/hyper/src/body/aggregate.rs b/hyper/src/body/aggregate.rs
new file mode 100644
index 0000000..9966241
--- /dev/null
+++ b/hyper/src/body/aggregate.rs
@@ -0,0 +1,31 @@
+use bytes::Buf;
+
+use super::HttpBody;
+use crate::common::buf::BufList;
+
+/// Aggregate the data buffers from a body asynchronously.
+///
+/// The returned `impl Buf` groups the `Buf`s from the `HttpBody` without
+/// copying them. This is ideal if you don't require a contiguous buffer.
+///
+/// # Note
+///
+/// Care needs to be taken if the remote is untrusted. The function doesn't implement any length
+/// checks and an malicious peer might make it consume arbitrary amounts of memory. Checking the
+/// `Content-Length` is a possibility, but it is not strictly mandated to be present.
+pub async fn aggregate<T>(body: T) -> Result<impl Buf, T::Error>
+where
+    T: HttpBody,
+{
+    let mut bufs = BufList::new();
+
+    futures_util::pin_mut!(body);
+    while let Some(buf) = body.data().await {
+        let buf = buf?;
+        if buf.has_remaining() {
+            bufs.push(buf);
+        }
+    }
+
+    Ok(bufs)
+}
diff --git a/hyper/src/body/body.rs b/hyper/src/body/body.rs
new file mode 100644
index 0000000..a2efa34
--- /dev/null
+++ b/hyper/src/body/body.rs
@@ -0,0 +1,675 @@
+use std::borrow::Cow;
+#[cfg(feature = "stream")]
+use std::error::Error as StdError;
+use std::fmt;
+use bytes::Bytes;
+use futures_channel::mpsc;
+use futures_channel::oneshot;
+use futures_core::Stream;
+#[cfg(feature = "stream")]
+use futures_util::TryStreamExt;
+use http::HeaderMap;
+use http_body::{Body as HttpBody, SizeHint};
+use super::DecodedLength;
+#[cfg(feature = "stream")]
+use crate::common::sync_wrapper::SyncWrapper;
+use crate::common::Future;
+#[cfg(all(feature = "client", any(feature = "http1", feature = "http2")))]
+use crate::common::Never;
+use crate::common::{task, watch, Pin, Poll};
+#[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
+use crate::proto::h2::ping;
+type BodySender = mpsc::Sender<Result<Bytes, crate::Error>>;
+type TrailersSender = oneshot::Sender<HeaderMap>;
+/// A stream of `Bytes`, used when receiving bodies.
+///
+/// A good default [`HttpBody`](crate::body::HttpBody) to use in many
+/// applications.
+///
+/// Note: To read the full body, use [`body::to_bytes`](crate::body::to_bytes)
+/// or [`body::aggregate`](crate::body::aggregate).
+#[must_use = "streams do nothing unless polled"]
+pub struct Body {
+    kind: Kind,
+    /// Keep the extra bits in an `Option<Box<Extra>>`, so that
+    /// Body stays small in the common case (no extras needed).
+    extra: Option<Box<Extra>>,
+}
+enum Kind {
+    Once(Option<Bytes>),
+    Chan {
+        content_length: DecodedLength,
+        want_tx: watch::Sender,
+        data_rx: mpsc::Receiver<Result<Bytes, crate::Error>>,
+        trailers_rx: oneshot::Receiver<HeaderMap>,
+    },
+    #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
+    H2 { ping: ping::Recorder, content_length: DecodedLength, recv: h2::RecvStream },
+    #[cfg(feature = "ffi")]
+    Ffi(crate::ffi::UserBody),
+    #[cfg(feature = "stream")]
+    Wrapped(
+        SyncWrapper<
+            Pin<
+                Box<
+                    dyn Stream<
+                        Item = Result<Bytes, Box<dyn StdError + Send + Sync>>,
+                    > + Send,
+                >,
+            >,
+        >,
+    ),
+}
+struct Extra {
+    /// Allow the client to pass a future to delay the `Body` from returning
+    /// EOF. This allows the `Client` to try to put the idle connection
+    /// back into the pool before the body is "finished".
+    ///
+    /// The reason for this is so that creating a new request after finishing
+    /// streaming the body of a response could sometimes result in creating
+    /// a brand new connection, since the pool didn't know about the idle
+    /// connection yet.
+    delayed_eof: Option<DelayEof>,
+}
+#[cfg(all(feature = "client", any(feature = "http1", feature = "http2")))]
+type DelayEofUntil = oneshot::Receiver<Never>;
+enum DelayEof {
+    /// Initial state, stream hasn't seen EOF yet.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    NotEof(DelayEofUntil),
+    /// Transitions to this state once we've seen `poll` try to
+    /// return EOF (`None`). This future is then polled, and
+    /// when it completes, the Body finally returns EOF (`None`).
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    Eof(DelayEofUntil),
+}
+/// A sender half created through [`Body::channel()`].
+///
+/// Useful when wanting to stream chunks from another thread.
+///
+/// ## Body Closing
+///
+/// Note that the request body will always be closed normally when the sender is dropped (meaning
+/// that the empty terminating chunk will be sent to the remote). If you desire to close the
+/// connection with an incomplete response (e.g. in the case of an error during asynchronous
+/// processing), call the [`Sender::abort()`] method to abort the body in an abnormal fashion.
+///
+/// [`Body::channel()`]: struct.Body.html#method.channel
+/// [`Sender::abort()`]: struct.Sender.html#method.abort
+#[must_use = "Sender does nothing unless sent on"]
+pub struct Sender {
+    want_rx: watch::Receiver,
+    data_tx: BodySender,
+    trailers_tx: Option<TrailersSender>,
+}
+const WANT_PENDING: usize = 1;
+const WANT_READY: usize = 2;
+impl Body {
+    /// Create an empty `Body` stream.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use hyper::{Body, Request};
+    ///
+    /// // create a `GET /` request
+    /// let get = Request::new(Body::empty());
+    /// ```
+    #[inline]
+    pub fn empty() -> Body {
+        Body::new(Kind::Once(None))
+    }
+    /// Create a `Body` stream with an associated sender half.
+    ///
+    /// Useful when wanting to stream chunks from another thread.
+    #[inline]
+    pub(crate) fn channel() -> (Sender, Body) {
+        Self::new_channel(DecodedLength::CHUNKED, false)
+    }
+    pub(crate) fn new_channel(
+        content_length: DecodedLength,
+        wanter: bool,
+    ) -> (Sender, Body) {
+        let (data_tx, data_rx) = mpsc::channel(0);
+        let (trailers_tx, trailers_rx) = oneshot::channel();
+        let want = if wanter { WANT_PENDING } else { WANT_READY };
+        let (want_tx, want_rx) = watch::channel(want);
+        let tx = Sender {
+            want_rx,
+            data_tx,
+            trailers_tx: Some(trailers_tx),
+        };
+        let rx = Body::new(Kind::Chan {
+            content_length,
+            want_tx,
+            data_rx,
+            trailers_rx,
+        });
+        (tx, rx)
+    }
+    /// Wrap a futures `Stream` in a box inside `Body`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use hyper::Body;
+    /// let chunks: Vec<Result<_, std::io::Error>> = vec![
+    ///     Ok("hello"),
+    ///     Ok(" "),
+    ///     Ok("world"),
+    /// ];
+    ///
+    /// let stream = futures_util::stream::iter(chunks);
+    ///
+    /// let body = Body::wrap_stream(stream);
+    /// ```
+    ///
+    /// # Optional
+    ///
+    /// This function requires enabling the `stream` feature in your
+    /// `Cargo.toml`.
+    #[cfg(feature = "stream")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "stream")))]
+    pub fn wrap_stream<S, O, E>(stream: S) -> Body
+    where
+        S: Stream<Item = Result<O, E>> + Send + 'static,
+        O: Into<Bytes> + 'static,
+        E: Into<Box<dyn StdError + Send + Sync>> + 'static,
+    {
+        let mapped = stream.map_ok(Into::into).map_err(Into::into);
+        Body::new(Kind::Wrapped(SyncWrapper::new(Box::pin(mapped))))
+    }
+    fn new(kind: Kind) -> Body {
+        Body { kind, extra: None }
+    }
+    #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
+    pub(crate) fn h2(
+        recv: h2::RecvStream,
+        mut content_length: DecodedLength,
+        ping: ping::Recorder,
+    ) -> Self {
+        if !content_length.is_exact() && recv.is_end_stream() {
+            content_length = DecodedLength::ZERO;
+        }
+        let body = Body::new(Kind::H2 {
+            ping,
+            content_length,
+            recv,
+        });
+        body
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    pub(crate) fn delayed_eof(&mut self, fut: DelayEofUntil) {
+        self.extra_mut().delayed_eof = Some(DelayEof::NotEof(fut));
+    }
+    fn take_delayed_eof(&mut self) -> Option<DelayEof> {
+        self.extra.as_mut().and_then(|extra| extra.delayed_eof.take())
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    fn extra_mut(&mut self) -> &mut Extra {
+        self.extra.get_or_insert_with(|| Box::new(Extra { delayed_eof: None }))
+    }
+    fn poll_eof(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<crate::Result<Bytes>>> {
+        match self.take_delayed_eof() {
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "client")]
+            Some(DelayEof::NotEof(mut delay)) => {
+                match self.poll_inner(cx) {
+                    ok @ Poll::Ready(Some(Ok(..))) | ok @ Poll::Pending => {
+                        self.extra_mut().delayed_eof = Some(DelayEof::NotEof(delay));
+                        ok
+                    }
+                    Poll::Ready(None) => {
+                        match Pin::new(&mut delay).poll(cx) {
+                            Poll::Ready(Ok(never)) => match never {}
+                            Poll::Pending => {
+                                self.extra_mut().delayed_eof = Some(DelayEof::Eof(delay));
+                                Poll::Pending
+                            }
+                            Poll::Ready(Err(_done)) => Poll::Ready(None),
+                        }
+                    }
+                    Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(e))),
+                }
+            }
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "client")]
+            Some(DelayEof::Eof(mut delay)) => {
+                match Pin::new(&mut delay).poll(cx) {
+                    Poll::Ready(Ok(never)) => match never {}
+                    Poll::Pending => {
+                        self.extra_mut().delayed_eof = Some(DelayEof::Eof(delay));
+                        Poll::Pending
+                    }
+                    Poll::Ready(Err(_done)) => Poll::Ready(None),
+                }
+            }
+            #[cfg(
+                any(
+                    not(any(feature = "http1", feature = "http2")),
+                    not(feature = "client")
+                )
+            )]
+            Some(delay_eof) => match delay_eof {}
+            None => self.poll_inner(cx),
+        }
+    }
+    #[cfg(feature = "ffi")]
+    pub(crate) fn as_ffi_mut(&mut self) -> &mut crate::ffi::UserBody {
+        match self.kind {
+            Kind::Ffi(ref mut body) => return body,
+            _ => {
+                self.kind = Kind::Ffi(crate::ffi::UserBody::new());
+            }
+        }
+        match self.kind {
+            Kind::Ffi(ref mut body) => body,
+            _ => unreachable!(),
+        }
+    }
+    fn poll_inner(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<crate::Result<Bytes>>> {
+        match self.kind {
+            Kind::Once(ref mut val) => Poll::Ready(val.take().map(Ok)),
+            Kind::Chan {
+                content_length: ref mut len,
+                ref mut data_rx,
+                ref mut want_tx,
+                ..
+            } => {
+                want_tx.send(WANT_READY);
+                match ready!(Pin::new(data_rx).poll_next(cx) ?) {
+                    Some(chunk) => {
+                        len.sub_if(chunk.len() as u64);
+                        Poll::Ready(Some(Ok(chunk)))
+                    }
+                    None => Poll::Ready(None),
+                }
+            }
+            #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
+            Kind::H2 { ref ping, recv: ref mut h2, content_length: ref mut len } => {
+                match ready!(h2.poll_data(cx)) {
+                    Some(Ok(bytes)) => {
+                        let _ = h2.flow_control().release_capacity(bytes.len());
+                        len.sub_if(bytes.len() as u64);
+                        ping.record_data(bytes.len());
+                        Poll::Ready(Some(Ok(bytes)))
+                    }
+                    Some(Err(e)) => Poll::Ready(Some(Err(crate::Error::new_body(e)))),
+                    None => Poll::Ready(None),
+                }
+            }
+            #[cfg(feature = "ffi")]
+            Kind::Ffi(ref mut body) => body.poll_data(cx),
+            #[cfg(feature = "stream")]
+            Kind::Wrapped(ref mut s) => {
+                match ready!(s.get_mut().as_mut().poll_next(cx)) {
+                    Some(res) => Poll::Ready(Some(res.map_err(crate::Error::new_body))),
+                    None => Poll::Ready(None),
+                }
+            }
+        }
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn take_full_data(&mut self) -> Option<Bytes> {
+        if let Kind::Once(ref mut chunk) = self.kind { chunk.take() } else { None }
+    }
+}
+impl Default for Body {
+    /// Returns `Body::empty()`.
+    #[inline]
+    fn default() -> Body {
+        Body::empty()
+    }
+}
+impl HttpBody for Body {
+    type Data = Bytes;
+    type Error = crate::Error;
+    fn poll_data(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<Result<Self::Data, Self::Error>>> {
+        self.poll_eof(cx)
+    }
+    fn poll_trailers(
+        #[cfg_attr(not(feature = "http2"), allow(unused_mut))]
+        mut self: Pin<&mut Self>,
+        #[cfg_attr(not(feature = "http2"), allow(unused))]
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<Option<HeaderMap>, Self::Error>> {
+        match self.kind {
+            #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
+            Kind::H2 { recv: ref mut h2, ref ping, .. } => {
+                match ready!(h2.poll_trailers(cx)) {
+                    Ok(t) => {
+                        ping.record_non_data();
+                        Poll::Ready(Ok(t))
+                    }
+                    Err(e) => Poll::Ready(Err(crate::Error::new_h2(e))),
+                }
+            }
+            Kind::Chan { ref mut trailers_rx, .. } => {
+                match ready!(Pin::new(trailers_rx).poll(cx)) {
+                    Ok(t) => Poll::Ready(Ok(Some(t))),
+                    Err(_) => Poll::Ready(Ok(None)),
+                }
+            }
+            #[cfg(feature = "ffi")]
+            Kind::Ffi(ref mut body) => body.poll_trailers(cx),
+            _ => Poll::Ready(Ok(None)),
+        }
+    }
+    fn is_end_stream(&self) -> bool {
+        match self.kind {
+            Kind::Once(ref val) => val.is_none(),
+            Kind::Chan { content_length, .. } => content_length == DecodedLength::ZERO,
+            #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
+            Kind::H2 { recv: ref h2, .. } => h2.is_end_stream(),
+            #[cfg(feature = "ffi")]
+            Kind::Ffi(..) => false,
+            #[cfg(feature = "stream")]
+            Kind::Wrapped(..) => false,
+        }
+    }
+    fn size_hint(&self) -> SizeHint {
+        macro_rules! opt_len {
+            ($content_length:expr) => {
+                { let mut hint = SizeHint::default(); if let Some(content_length) =
+                $content_length .into_opt() { hint.set_exact(content_length); } hint }
+            };
+        }
+        match self.kind {
+            Kind::Once(Some(ref val)) => SizeHint::with_exact(val.len() as u64),
+            Kind::Once(None) => SizeHint::with_exact(0),
+            #[cfg(feature = "stream")]
+            Kind::Wrapped(..) => SizeHint::default(),
+            Kind::Chan { content_length, .. } => opt_len!(content_length),
+            #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
+            Kind::H2 { content_length, .. } => opt_len!(content_length),
+            #[cfg(feature = "ffi")]
+            Kind::Ffi(..) => SizeHint::default(),
+        }
+    }
+}
+impl fmt::Debug for Body {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[derive(Debug)]
+        struct Streaming;
+        #[derive(Debug)]
+        struct Empty;
+        #[derive(Debug)]
+        struct Full<'a>(&'a Bytes);
+        let mut builder = f.debug_tuple("Body");
+        match self.kind {
+            Kind::Once(None) => builder.field(&Empty),
+            Kind::Once(Some(ref chunk)) => builder.field(&Full(chunk)),
+            _ => builder.field(&Streaming),
+        };
+        builder.finish()
+    }
+}
+/// # Optional
+///
+/// This function requires enabling the `stream` feature in your
+/// `Cargo.toml`.
+#[cfg(feature = "stream")]
+impl Stream for Body {
+    type Item = crate::Result<Bytes>;
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        HttpBody::poll_data(self, cx)
+    }
+}
+/// # Optional
+///
+/// This function requires enabling the `stream` feature in your
+/// `Cargo.toml`.
+#[cfg(feature = "stream")]
+impl From<Box<dyn Stream<Item = Result<Bytes, Box<dyn StdError + Send + Sync>>> + Send>>
+for Body {
+    #[inline]
+    fn from(
+        stream: Box<
+            dyn Stream<Item = Result<Bytes, Box<dyn StdError + Send + Sync>>> + Send,
+        >,
+    ) -> Body {
+        Body::new(Kind::Wrapped(SyncWrapper::new(stream.into())))
+    }
+}
+impl From<Bytes> for Body {
+    #[inline]
+    fn from(chunk: Bytes) -> Body {
+        if chunk.is_empty() { Body::empty() } else { Body::new(Kind::Once(Some(chunk))) }
+    }
+}
+impl From<Vec<u8>> for Body {
+    #[inline]
+    fn from(vec: Vec<u8>) -> Body {
+        Body::from(Bytes::from(vec))
+    }
+}
+impl From<&'static [u8]> for Body {
+    #[inline]
+    fn from(slice: &'static [u8]) -> Body {
+        Body::from(Bytes::from(slice))
+    }
+}
+impl From<Cow<'static, [u8]>> for Body {
+    #[inline]
+    fn from(cow: Cow<'static, [u8]>) -> Body {
+        match cow {
+            Cow::Borrowed(b) => Body::from(b),
+            Cow::Owned(o) => Body::from(o),
+        }
+    }
+}
+impl From<String> for Body {
+    #[inline]
+    fn from(s: String) -> Body {
+        Body::from(Bytes::from(s.into_bytes()))
+    }
+}
+impl From<&'static str> for Body {
+    #[inline]
+    fn from(slice: &'static str) -> Body {
+        Body::from(Bytes::from(slice.as_bytes()))
+    }
+}
+impl From<Cow<'static, str>> for Body {
+    #[inline]
+    fn from(cow: Cow<'static, str>) -> Body {
+        match cow {
+            Cow::Borrowed(b) => Body::from(b),
+            Cow::Owned(o) => Body::from(o),
+        }
+    }
+}
+impl Sender {
+    /// Check to see if this `Sender` can send more data.
+    pub(crate) fn poll_ready(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<crate::Result<()>> {
+        ready!(self.poll_want(cx) ?);
+        self.data_tx.poll_ready(cx).map_err(|_| crate::Error::new_closed())
+    }
+    fn poll_want(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        match self.want_rx.load(cx) {
+            WANT_READY => Poll::Ready(Ok(())),
+            WANT_PENDING => Poll::Pending,
+            watch::CLOSED => Poll::Ready(Err(crate::Error::new_closed())),
+            unexpected => unreachable!("want_rx value: {}", unexpected),
+        }
+    }
+    async fn ready(&mut self) -> crate::Result<()> {
+        futures_util::future::poll_fn(|cx| self.poll_ready(cx)).await
+    }
+    /// Send data on data channel when it is ready.
+    pub(crate) async fn send_data(&mut self, chunk: Bytes) -> crate::Result<()> {
+        self.ready().await?;
+        self.data_tx.try_send(Ok(chunk)).map_err(|_| crate::Error::new_closed())
+    }
+    /// Send trailers on trailers channel.
+    pub(crate) async fn send_trailers(
+        &mut self,
+        trailers: HeaderMap,
+    ) -> crate::Result<()> {
+        let tx = match self.trailers_tx.take() {
+            Some(tx) => tx,
+            None => return Err(crate::Error::new_closed()),
+        };
+        tx.send(trailers).map_err(|_| crate::Error::new_closed())
+    }
+    /// Try to send data on this channel.
+    ///
+    /// # Errors
+    ///
+    /// Returns `Err(Bytes)` if the channel could not (currently) accept
+    /// another `Bytes`.
+    ///
+    /// # Note
+    ///
+    /// This is mostly useful for when trying to send from some other thread
+    /// that doesn't have an async context. If in an async context, prefer
+    /// `send_data()` instead.
+    pub(crate) fn try_send_data(&mut self, chunk: Bytes) -> Result<(), Bytes> {
+        self.data_tx
+            .try_send(Ok(chunk))
+            .map_err(|err| err.into_inner().expect("just sent Ok"))
+    }
+    /// Aborts the body in an abnormal fashion.
+    pub(crate) fn abort(self) {
+        let _ = self
+            .data_tx
+            .clone()
+            .try_send(Err(crate::Error::new_body_write_aborted()));
+    }
+    #[cfg(feature = "http1")]
+    pub(crate) fn send_error(&mut self, err: crate::Error) {
+        let _ = self.data_tx.try_send(Err(err));
+    }
+}
+impl fmt::Debug for Sender {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[derive(Debug)]
+        struct Open;
+        #[derive(Debug)]
+        struct Closed;
+        let mut builder = f.debug_tuple("Sender");
+        match self.want_rx.peek() {
+            watch::CLOSED => builder.field(&Closed),
+            _ => builder.field(&Open),
+        };
+        builder.finish()
+    }
+}
+#[cfg(test)]
+mod tests {
+    use std::mem;
+    use std::task::Poll;
+    use super::{Body, DecodedLength, HttpBody, Sender, SizeHint};
+    #[test]
+    fn test_size_of() {
+        let body_size = mem::size_of::<Body>();
+        let body_expected_size = mem::size_of::<u64>() * 6;
+        assert!(
+            body_size <= body_expected_size, "Body size = {} <= {}", body_size,
+            body_expected_size,
+        );
+        assert_eq!(body_size, mem::size_of::< Option < Body >> (), "Option<Body>");
+        assert_eq!(
+            mem::size_of::< Sender > (), mem::size_of::< usize > () * 5, "Sender"
+        );
+        assert_eq!(
+            mem::size_of::< Sender > (), mem::size_of::< Option < Sender >> (),
+            "Option<Sender>"
+        );
+    }
+    #[test]
+    fn size_hint() {
+        fn eq(body: Body, b: SizeHint, note: &str) {
+            let a = body.size_hint();
+            assert_eq!(a.lower(), b.lower(), "lower for {:?}", note);
+            assert_eq!(a.upper(), b.upper(), "upper for {:?}", note);
+        }
+        eq(Body::from("Hello"), SizeHint::with_exact(5), "from str");
+        eq(Body::empty(), SizeHint::with_exact(0), "empty");
+        eq(Body::channel().1, SizeHint::new(), "channel");
+        eq(
+            Body::new_channel(DecodedLength::new(4), false).1,
+            SizeHint::with_exact(4),
+            "channel with length",
+        );
+    }
+    #[tokio::test]
+    async fn channel_abort() {
+        let (tx, mut rx) = Body::channel();
+        tx.abort();
+        let err = rx.data().await.unwrap().unwrap_err();
+        assert!(err.is_body_write_aborted(), "{:?}", err);
+    }
+    #[tokio::test]
+    async fn channel_abort_when_buffer_is_full() {
+        let (mut tx, mut rx) = Body::channel();
+        tx.try_send_data("chunk 1".into()).expect("send 1");
+        tx.abort();
+        let chunk1 = rx.data().await.expect("item 1").expect("chunk 1");
+        assert_eq!(chunk1, "chunk 1");
+        let err = rx.data().await.unwrap().unwrap_err();
+        assert!(err.is_body_write_aborted(), "{:?}", err);
+    }
+    #[test]
+    fn channel_buffers_one() {
+        let (mut tx, _rx) = Body::channel();
+        tx.try_send_data("chunk 1".into()).expect("send 1");
+        let chunk2 = tx.try_send_data("chunk 2".into()).expect_err("send 2");
+        assert_eq!(chunk2, "chunk 2");
+    }
+    #[tokio::test]
+    async fn channel_empty() {
+        let (_, mut rx) = Body::channel();
+        assert!(rx.data().await.is_none());
+    }
+    #[test]
+    fn channel_ready() {
+        let (mut tx, _rx) = Body::new_channel(DecodedLength::CHUNKED, false);
+        let mut tx_ready = tokio_test::task::spawn(tx.ready());
+        assert!(tx_ready.poll().is_ready(), "tx is ready immediately");
+    }
+    #[test]
+    fn channel_wanter() {
+        let (mut tx, mut rx) = Body::new_channel(DecodedLength::CHUNKED, true);
+        let mut tx_ready = tokio_test::task::spawn(tx.ready());
+        let mut rx_data = tokio_test::task::spawn(rx.data());
+        assert!(
+            tx_ready.poll().is_pending(), "tx isn't ready before rx has been polled"
+        );
+        assert!(rx_data.poll().is_pending(), "poll rx.data");
+        assert!(tx_ready.is_woken(), "rx poll wakes tx");
+        assert!(tx_ready.poll().is_ready(), "tx is ready after rx has been polled");
+    }
+    #[test]
+    fn channel_notices_closure() {
+        let (mut tx, rx) = Body::new_channel(DecodedLength::CHUNKED, true);
+        let mut tx_ready = tokio_test::task::spawn(tx.ready());
+        assert!(
+            tx_ready.poll().is_pending(), "tx isn't ready before rx has been polled"
+        );
+        drop(rx);
+        assert!(tx_ready.is_woken(), "dropping rx wakes tx");
+        match tx_ready.poll() {
+            Poll::Ready(Err(ref e)) if e.is_closed() => {}
+            unexpected => panic!("tx poll ready unexpected: {:?}", unexpected),
+        }
+    }
+}
diff --git a/hyper/src/body/length.rs b/hyper/src/body/length.rs
new file mode 100644
index 0000000..e2bbee8
--- /dev/null
+++ b/hyper/src/body/length.rs
@@ -0,0 +1,123 @@
+use std::fmt;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) struct DecodedLength(u64);
+
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl From<Option<u64>> for DecodedLength {
+    fn from(len: Option<u64>) -> Self {
+        len.and_then(|len| {
+            // If the length is u64::MAX, oh well, just reported chunked.
+            Self::checked_new(len).ok()
+        })
+        .unwrap_or(DecodedLength::CHUNKED)
+    }
+}
+
+#[cfg(any(feature = "http1", feature = "http2", test))]
+const MAX_LEN: u64 = std::u64::MAX - 2;
+
+impl DecodedLength {
+    pub(crate) const CLOSE_DELIMITED: DecodedLength = DecodedLength(::std::u64::MAX);
+    pub(crate) const CHUNKED: DecodedLength = DecodedLength(::std::u64::MAX - 1);
+    pub(crate) const ZERO: DecodedLength = DecodedLength(0);
+
+    #[cfg(test)]
+    pub(crate) fn new(len: u64) -> Self {
+        debug_assert!(len <= MAX_LEN);
+        DecodedLength(len)
+    }
+
+    /// Takes the length as a content-length without other checks.
+    ///
+    /// Should only be called if previously confirmed this isn't
+    /// CLOSE_DELIMITED or CHUNKED.
+    #[inline]
+    #[cfg(feature = "http1")]
+    pub(crate) fn danger_len(self) -> u64 {
+        debug_assert!(self.0 < Self::CHUNKED.0);
+        self.0
+    }
+
+    /// Converts to an Option<u64> representing a Known or Unknown length.
+    pub(crate) fn into_opt(self) -> Option<u64> {
+        match self {
+            DecodedLength::CHUNKED | DecodedLength::CLOSE_DELIMITED => None,
+            DecodedLength(known) => Some(known),
+        }
+    }
+
+    /// Checks the `u64` is within the maximum allowed for content-length.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    pub(crate) fn checked_new(len: u64) -> Result<Self, crate::error::Parse> {
+        use tracing::warn;
+
+        if len <= MAX_LEN {
+            Ok(DecodedLength(len))
+        } else {
+            warn!("content-length bigger than maximum: {} > {}", len, MAX_LEN);
+            Err(crate::error::Parse::TooLarge)
+        }
+    }
+
+    pub(crate) fn sub_if(&mut self, amt: u64) {
+        match *self {
+            DecodedLength::CHUNKED | DecodedLength::CLOSE_DELIMITED => (),
+            DecodedLength(ref mut known) => {
+                *known -= amt;
+            }
+        }
+    }
+
+    /// Returns whether this represents an exact length.
+    ///
+    /// This includes 0, which of course is an exact known length.
+    ///
+    /// It would return false if "chunked" or otherwise size-unknown.
+    #[cfg(feature = "http2")]
+    pub(crate) fn is_exact(&self) -> bool {
+        self.0 <= MAX_LEN
+    }
+}
+
+impl fmt::Debug for DecodedLength {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            DecodedLength::CLOSE_DELIMITED => f.write_str("CLOSE_DELIMITED"),
+            DecodedLength::CHUNKED => f.write_str("CHUNKED"),
+            DecodedLength(n) => f.debug_tuple("DecodedLength").field(&n).finish(),
+        }
+    }
+}
+
+impl fmt::Display for DecodedLength {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            DecodedLength::CLOSE_DELIMITED => f.write_str("close-delimited"),
+            DecodedLength::CHUNKED => f.write_str("chunked encoding"),
+            DecodedLength::ZERO => f.write_str("empty"),
+            DecodedLength(n) => write!(f, "content-length ({} bytes)", n),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sub_if_known() {
+        let mut len = DecodedLength::new(30);
+        len.sub_if(20);
+
+        assert_eq!(len.0, 10);
+    }
+
+    #[test]
+    fn sub_if_chunked() {
+        let mut len = DecodedLength::CHUNKED;
+        len.sub_if(20);
+
+        assert_eq!(len, DecodedLength::CHUNKED);
+    }
+}
diff --git a/hyper/src/body/mod.rs b/hyper/src/body/mod.rs
new file mode 100644
index 0000000..5e2181e
--- /dev/null
+++ b/hyper/src/body/mod.rs
@@ -0,0 +1,65 @@
+//! Streaming bodies for Requests and Responses
+//!
+//! For both [Clients](crate::client) and [Servers](crate::server), requests and
+//! responses use streaming bodies, instead of complete buffering. This
+//! allows applications to not use memory they don't need, and allows exerting
+//! back-pressure on connections by only reading when asked.
+//!
+//! There are two pieces to this in hyper:
+//!
+//! - **The [`HttpBody`](HttpBody) trait** describes all possible bodies.
+//!   hyper allows any body type that implements `HttpBody`, allowing
+//!   applications to have fine-grained control over their streaming.
+//! - **The [`Body`](Body) concrete type**, which is an implementation of
+//!   `HttpBody`, and returned by hyper as a "receive stream" (so, for server
+//!   requests and client responses). It is also a decent default implementation
+//!   if you don't have very custom needs of your send streams.
+
+pub use bytes::{Buf, Bytes};
+pub use http_body::Body as HttpBody;
+pub use http_body::SizeHint;
+
+pub use self::aggregate::aggregate;
+pub use self::body::{Body, Sender};
+pub(crate) use self::length::DecodedLength;
+pub use self::to_bytes::to_bytes;
+
+mod aggregate;
+mod body;
+mod length;
+mod to_bytes;
+
+/// An optimization to try to take a full body if immediately available.
+///
+/// This is currently limited to *only* `hyper::Body`s.
+#[cfg(feature = "http1")]
+pub(crate) fn take_full_data<T: HttpBody + 'static>(body: &mut T) -> Option<T::Data> {
+    use std::any::{Any, TypeId};
+
+    // This static type check can be optimized at compile-time.
+    if TypeId::of::<T>() == TypeId::of::<Body>() {
+        let mut full = (body as &mut dyn Any)
+            .downcast_mut::<Body>()
+            .expect("must be Body")
+            .take_full_data();
+        // This second cast is required to make the type system happy.
+        // Without it, the compiler cannot reason that the type is actually
+        // `T::Data`. Oh wells.
+        //
+        // It's still a measurable win!
+        (&mut full as &mut dyn Any)
+            .downcast_mut::<Option<T::Data>>()
+            .expect("must be T::Data")
+            .take()
+    } else {
+        None
+    }
+}
+
+fn _assert_send_sync() {
+    fn _assert_send<T: Send>() {}
+    fn _assert_sync<T: Sync>() {}
+
+    _assert_send::<Body>();
+    _assert_sync::<Body>();
+}
diff --git a/hyper/src/body/to_bytes.rs b/hyper/src/body/to_bytes.rs
new file mode 100644
index 0000000..038c6fd
--- /dev/null
+++ b/hyper/src/body/to_bytes.rs
@@ -0,0 +1,82 @@
+use bytes::{Buf, BufMut, Bytes};
+
+use super::HttpBody;
+
+/// Concatenate the buffers from a body into a single `Bytes` asynchronously.
+///
+/// This may require copying the data into a single buffer. If you don't need
+/// a contiguous buffer, prefer the [`aggregate`](crate::body::aggregate())
+/// function.
+///
+/// # Note
+///
+/// Care needs to be taken if the remote is untrusted. The function doesn't implement any length
+/// checks and an malicious peer might make it consume arbitrary amounts of memory. Checking the
+/// `Content-Length` is a possibility, but it is not strictly mandated to be present.
+///
+/// # Example
+///
+/// ```
+/// # #[cfg(all(feature = "client", feature = "tcp", any(feature = "http1", feature = "http2")))]
+/// # async fn doc() -> hyper::Result<()> {
+/// use hyper::{body::HttpBody};
+///
+/// # let request = hyper::Request::builder()
+/// #        .method(hyper::Method::POST)
+/// #        .uri("http://httpbin.org/post")
+/// #        .header("content-type", "application/json")
+/// #        .body(hyper::Body::from(r#"{"library":"hyper"}"#)).unwrap();
+/// # let client = hyper::Client::new();
+/// let response = client.request(request).await?;
+///
+/// const MAX_ALLOWED_RESPONSE_SIZE: u64 = 1024;
+///
+/// let response_content_length = match response.body().size_hint().upper() {
+///     Some(v) => v,
+///     None => MAX_ALLOWED_RESPONSE_SIZE + 1 // Just to protect ourselves from a malicious response
+/// };
+///
+/// if response_content_length < MAX_ALLOWED_RESPONSE_SIZE {
+///     let body_bytes = hyper::body::to_bytes(response.into_body()).await?;
+///     println!("body: {:?}", body_bytes);
+/// }
+///
+/// # Ok(())
+/// # }
+/// ```
+pub async fn to_bytes<T>(body: T) -> Result<Bytes, T::Error>
+where
+    T: HttpBody,
+{
+    futures_util::pin_mut!(body);
+
+    // If there's only 1 chunk, we can just return Buf::to_bytes()
+    let mut first = if let Some(buf) = body.data().await {
+        buf?
+    } else {
+        return Ok(Bytes::new());
+    };
+
+    let second = if let Some(buf) = body.data().await {
+        buf?
+    } else {
+        return Ok(first.copy_to_bytes(first.remaining()));
+    };
+
+    // Don't pre-emptively reserve *too* much.
+    let rest = (body.size_hint().lower() as usize).min(1024 * 16);
+    let cap = first
+        .remaining()
+        .saturating_add(second.remaining())
+        .saturating_add(rest);
+    // With more than 1 buf, we gotta flatten into a Vec first.
+    let mut vec = Vec::with_capacity(cap);
+    vec.put(first);
+    vec.put(second);
+
+    while let Some(buf) = body.data().await {
+        vec.put(buf?);
+    }
+
+    Ok(vec.into())
+}
diff --git a/hyper/src/cfg.rs b/hyper/src/cfg.rs
new file mode 100644
index 0000000..71a5351
--- /dev/null
+++ b/hyper/src/cfg.rs
@@ -0,0 +1,44 @@
+macro_rules! cfg_feature {
+    (
+        #![$meta:meta]
+        $($item:item)*
+    ) => {
+        $(
+            #[cfg($meta)]
+            #[cfg_attr(docsrs, doc(cfg($meta)))]
+            $item
+        )*
+    }
+}
+
+macro_rules! cfg_proto {
+    ($($item:item)*) => {
+        cfg_feature! {
+            #![all(
+                any(feature = "http1", feature = "http2"),
+                any(feature = "client", feature = "server"),
+            )]
+            $($item)*
+        }
+    }
+}
+
+cfg_proto! {
+    macro_rules! cfg_client {
+        ($($item:item)*) => {
+            cfg_feature! {
+                #![feature = "client"]
+                $($item)*
+            }
+        }
+    }
+
+    macro_rules! cfg_server {
+        ($($item:item)*) => {
+            cfg_feature! {
+                #![feature = "server"]
+                $($item)*
+            }
+        }
+    }
+}
diff --git a/hyper/src/client/client.rs b/hyper/src/client/client.rs
new file mode 100644
index 0000000..4255a27
--- /dev/null
+++ b/hyper/src/client/client.rs
@@ -0,0 +1,1305 @@
+use std::error::Error as StdError;
+use std::fmt;
+use std::mem;
+use std::time::Duration;
+use futures_channel::oneshot;
+use futures_util::future::{self, Either, FutureExt as _, TryFutureExt as _};
+use http::header::{HeaderValue, HOST};
+use http::uri::{Port, Scheme};
+use http::{Method, Request, Response, Uri, Version};
+use tracing::{debug, trace, warn};
+use super::conn;
+use super::connect::{self, sealed::Connect, Alpn, Connected, Connection};
+use super::pool::{
+    self, CheckoutIsClosedError, Key as PoolKey, Pool, Poolable, Pooled, Reservation,
+};
+#[cfg(feature = "tcp")]
+use super::HttpConnector;
+use crate::body::{Body, HttpBody};
+use crate::common::{
+    exec::BoxSendFuture, sync_wrapper::SyncWrapper, lazy as hyper_lazy, task, Future,
+    Lazy, Pin, Poll,
+};
+use crate::rt::Executor;
+/// A Client to make outgoing HTTP requests.
+///
+/// `Client` is cheap to clone and cloning is the recommended way to share a `Client`. The
+/// underlying connection pool will be reused.
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+pub struct Client<C, B = Body> {
+    config: Config,
+    conn_builder: conn::Builder,
+    connector: C,
+    pool: Pool<PoolClient<B>>,
+}
+#[derive(Clone, Copy, Debug)]
+struct Config {
+    retry_canceled_requests: bool,
+    set_host: bool,
+    ver: Ver,
+}
+/// A `Future` that will resolve to an HTTP Response.
+///
+/// This is returned by `Client::request` (and `Client::get`).
+#[must_use = "futures do nothing unless polled"]
+pub struct ResponseFuture {
+    inner: SyncWrapper<
+        Pin<Box<dyn Future<Output = crate::Result<Response<Body>>> + Send>>,
+    >,
+}
+#[cfg(feature = "tcp")]
+impl Client<HttpConnector, Body> {
+    /// Create a new Client with the default [config](Builder).
+    ///
+    /// # Note
+    ///
+    /// The default connector does **not** handle TLS. Speaking to `https`
+    /// destinations will require [configuring a connector that implements
+    /// TLS](https://hyper.rs/guides/client/configuration).
+    #[cfg_attr(docsrs, doc(cfg(feature = "tcp")))]
+    #[inline]
+    pub(crate) fn new() -> Client<HttpConnector, Body> {
+        Builder::default().build_http()
+    }
+}
+#[cfg(feature = "tcp")]
+impl Default for Client<HttpConnector, Body> {
+    fn default() -> Client<HttpConnector, Body> {
+        Client::new()
+    }
+}
+impl Client<(), Body> {
+    /// Create a builder to configure a new `Client`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # #[cfg(feature  = "runtime")]
+    /// # fn run () {
+    /// use std::time::Duration;
+    /// use hyper::Client;
+    ///
+    /// let client = Client::builder()
+    ///     .pool_idle_timeout(Duration::from_secs(30))
+    ///     .http2_only(true)
+    ///     .build_http();
+    /// # let infer: Client<_, hyper::Body> = client;
+    /// # drop(infer);
+    /// # }
+    /// # fn main() {}
+    /// ```
+    #[inline]
+    pub(crate) fn builder() -> Builder {
+        Builder::default()
+    }
+}
+impl<C, B> Client<C, B>
+where
+    C: Connect + Clone + Send + Sync + 'static,
+    B: HttpBody + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    /// Send a `GET` request to the supplied `Uri`.
+    ///
+    /// # Note
+    ///
+    /// This requires that the `HttpBody` type have a `Default` implementation.
+    /// It *should* return an "empty" version of itself, such that
+    /// `HttpBody::is_end_stream` is `true`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # #[cfg(feature  = "runtime")]
+    /// # fn run () {
+    /// use hyper::{Client, Uri};
+    ///
+    /// let client = Client::new();
+    ///
+    /// let future = client.get(Uri::from_static("http://httpbin.org/ip"));
+    /// # }
+    /// # fn main() {}
+    /// ```
+    pub(crate) fn get(&self, uri: Uri) -> ResponseFuture
+    where
+        B: Default,
+    {
+        let body = B::default();
+        if !body.is_end_stream() {
+            warn!(
+                "default HttpBody used for get() does not return true for is_end_stream"
+            );
+        }
+        let mut req = Request::new(body);
+        *req.uri_mut() = uri;
+        self.request(req)
+    }
+    /// Send a constructed `Request` using this `Client`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # #[cfg(feature  = "runtime")]
+    /// # fn run () {
+    /// use hyper::{Body, Method, Client, Request};
+    ///
+    /// let client = Client::new();
+    ///
+    /// let req = Request::builder()
+    ///     .method(Method::POST)
+    ///     .uri("http://httpbin.org/post")
+    ///     .body(Body::from("Hallo!"))
+    ///     .expect("request builder");
+    ///
+    /// let future = client.request(req);
+    /// # }
+    /// # fn main() {}
+    /// ```
+    pub(crate) fn request(&self, mut req: Request<B>) -> ResponseFuture {
+        let is_http_connect = req.method() == Method::CONNECT;
+        match req.version() {
+            Version::HTTP_11 => {}
+            Version::HTTP_10 => {
+                if is_http_connect {
+                    warn!("CONNECT is not allowed for HTTP/1.0");
+                    return ResponseFuture::new(
+                        future::err(crate::Error::new_user_unsupported_request_method()),
+                    );
+                }
+            }
+            Version::HTTP_2 => {}
+            other => return ResponseFuture::error_version(other),
+        };
+        let pool_key = match extract_domain(req.uri_mut(), is_http_connect) {
+            Ok(s) => s,
+            Err(err) => {
+                return ResponseFuture::new(future::err(err));
+            }
+        };
+        ResponseFuture::new(self.clone().retryably_send_request(req, pool_key))
+    }
+    async fn retryably_send_request(
+        self,
+        mut req: Request<B>,
+        pool_key: PoolKey,
+    ) -> crate::Result<Response<Body>> {
+        let uri = req.uri().clone();
+        loop {
+            req = match self.send_request(req, pool_key.clone()).await {
+                Ok(resp) => return Ok(resp),
+                Err(ClientError::Normal(err)) => return Err(err),
+                Err(ClientError::Canceled { connection_reused, mut req, reason }) => {
+                    if !self.config.retry_canceled_requests || !connection_reused {
+                        return Err(reason);
+                    }
+                    trace!(
+                        "unstarted request canceled, trying again (reason={:?})", reason
+                    );
+                    *req.uri_mut() = uri.clone();
+                    req
+                }
+            };
+        }
+    }
+    async fn send_request(
+        &self,
+        mut req: Request<B>,
+        pool_key: PoolKey,
+    ) -> Result<Response<Body>, ClientError<B>> {
+        let mut pooled = match self.connection_for(pool_key).await {
+            Ok(pooled) => pooled,
+            Err(ClientConnectError::Normal(err)) => return Err(ClientError::Normal(err)),
+            Err(ClientConnectError::H2CheckoutIsClosed(reason)) => {
+                return Err(ClientError::Canceled {
+                    connection_reused: true,
+                    req,
+                    reason,
+                });
+            }
+        };
+        if pooled.is_http1() {
+            if req.version() == Version::HTTP_2 {
+                warn!("Connection is HTTP/1, but request requires HTTP/2");
+                return Err(
+                    ClientError::Normal(crate::Error::new_user_unsupported_version()),
+                );
+            }
+            if self.config.set_host {
+                let uri = req.uri().clone();
+                req.headers_mut()
+                    .entry(HOST)
+                    .or_insert_with(|| {
+                        let hostname = uri.host().expect("authority implies host");
+                        if let Some(port) = get_non_default_port(&uri) {
+                            let s = format!("{}:{}", hostname, port);
+                            HeaderValue::from_str(&s)
+                        } else {
+                            HeaderValue::from_str(hostname)
+                        }
+                            .expect("uri host is valid header value")
+                    });
+            }
+            if req.method() == Method::CONNECT {
+                authority_form(req.uri_mut());
+            } else if pooled.conn_info.is_proxied {
+                absolute_form(req.uri_mut());
+            } else {
+                origin_form(req.uri_mut());
+            }
+        } else if req.method() == Method::CONNECT {
+            authority_form(req.uri_mut());
+        }
+        let fut = pooled
+            .send_request_retryable(req)
+            .map_err(ClientError::map_with_reused(pooled.is_reused()));
+        let extra_info = pooled.conn_info.extra.clone();
+        let fut = fut
+            .map_ok(move |mut res| {
+                if let Some(extra) = extra_info {
+                    extra.set(res.extensions_mut());
+                }
+                res
+            });
+        if pooled.is_closed() {
+            return fut.await;
+        }
+        let mut res = fut.await?;
+        if pooled.is_http2() || !pooled.is_pool_enabled() || pooled.is_ready() {
+            drop(pooled);
+        } else if !res.body().is_end_stream() {
+            let (delayed_tx, delayed_rx) = oneshot::channel();
+            res.body_mut().delayed_eof(delayed_rx);
+            let on_idle = future::poll_fn(move |cx| pooled.poll_ready(cx))
+                .map(move |_| {
+                    drop(delayed_tx);
+                });
+            self.conn_builder.exec.execute(on_idle);
+        } else {
+            let on_idle = future::poll_fn(move |cx| pooled.poll_ready(cx)).map(|_| ());
+            self.conn_builder.exec.execute(on_idle);
+        }
+        Ok(res)
+    }
+    async fn connection_for(
+        &self,
+        pool_key: PoolKey,
+    ) -> Result<Pooled<PoolClient<B>>, ClientConnectError> {
+        let checkout = self.pool.checkout(pool_key.clone());
+        let connect = self.connect_to(pool_key);
+        let is_ver_h2 = self.config.ver == Ver::Http2;
+        match future::select(checkout, connect).await {
+            Either::Left((Ok(checked_out), connecting)) => {
+                if connecting.started() {
+                    let bg = connecting
+                        .map_err(|err| {
+                            trace!("background connect error: {}", err);
+                        })
+                        .map(|_pooled| {});
+                    self.conn_builder.exec.execute(bg);
+                }
+                Ok(checked_out)
+            }
+            Either::Right((Ok(connected), _checkout)) => Ok(connected),
+            Either::Left((Err(err), connecting)) => {
+                if err.is_canceled() {
+                    connecting.await.map_err(ClientConnectError::Normal)
+                } else {
+                    Err(ClientConnectError::Normal(err))
+                }
+            }
+            Either::Right((Err(err), checkout)) => {
+                if err.is_canceled() {
+                    checkout
+                        .await
+                        .map_err(move |err| {
+                            if is_ver_h2 && err.is_canceled()
+                                && err.find_source::<CheckoutIsClosedError>().is_some()
+                            {
+                                ClientConnectError::H2CheckoutIsClosed(err)
+                            } else {
+                                ClientConnectError::Normal(err)
+                            }
+                        })
+                } else {
+                    Err(ClientConnectError::Normal(err))
+                }
+            }
+        }
+    }
+    fn connect_to(
+        &self,
+        pool_key: PoolKey,
+    ) -> impl Lazy<Output = crate::Result<Pooled<PoolClient<B>>>> + Unpin {
+        let executor = self.conn_builder.exec.clone();
+        let pool = self.pool.clone();
+        #[cfg(not(feature = "http2"))]
+        let conn_builder = self.conn_builder.clone();
+        #[cfg(feature = "http2")]
+        let mut conn_builder = self.conn_builder.clone();
+        let ver = self.config.ver;
+        let is_ver_h2 = ver == Ver::Http2;
+        let connector = self.connector.clone();
+        let dst = domain_as_uri(pool_key.clone());
+        hyper_lazy(move || {
+            let connecting = match pool.connecting(&pool_key, ver) {
+                Some(lock) => lock,
+                None => {
+                    let canceled = crate::Error::new_canceled()
+                        .with("HTTP/2 connection in progress");
+                    return Either::Right(future::err(canceled));
+                }
+            };
+            Either::Left(
+                connector
+                    .connect(connect::sealed::Internal, dst)
+                    .map_err(crate::Error::new_connect)
+                    .and_then(move |io| {
+                        let connected = io.connected();
+                        let connecting = if connected.alpn == Alpn::H2 && !is_ver_h2 {
+                            match connecting.alpn_h2(&pool) {
+                                Some(lock) => {
+                                    trace!("ALPN negotiated h2, updating pool");
+                                    lock
+                                }
+                                None => {
+                                    let canceled = crate::Error::new_canceled()
+                                        .with("ALPN upgraded to HTTP/2");
+                                    return Either::Right(future::err(canceled));
+                                }
+                            }
+                        } else {
+                            connecting
+                        };
+                        #[cfg_attr(not(feature = "http2"), allow(unused))]
+                        let is_h2 = is_ver_h2 || connected.alpn == Alpn::H2;
+                        #[cfg(feature = "http2")]
+                        {
+                            conn_builder.http2_only(is_h2);
+                        }
+                        Either::Left(
+                            Box::pin(async move {
+                                let (tx, conn) = conn_builder.handshake(io).await?;
+                                trace!(
+                                    "handshake complete, spawning background dispatcher task"
+                                );
+                                executor
+                                    .execute(
+                                        conn
+                                            .map_err(|e| debug!("client connection error: {}", e))
+                                            .map(|_| ()),
+                                    );
+                                let tx = tx.when_ready().await?;
+                                let tx = {
+                                    #[cfg(feature = "http2")]
+                                    {
+                                        if is_h2 {
+                                            PoolTx::Http2(tx.into_http2())
+                                        } else {
+                                            PoolTx::Http1(tx)
+                                        }
+                                    }
+                                    #[cfg(not(feature = "http2"))] PoolTx::Http1(tx)
+                                };
+                                Ok(
+                                    pool
+                                        .pooled(
+                                            connecting,
+                                            PoolClient {
+                                                conn_info: connected,
+                                                tx,
+                                            },
+                                        ),
+                                )
+                            }),
+                        )
+                    }),
+            )
+        })
+    }
+}
+impl<C, B> tower_service::Service<Request<B>> for Client<C, B>
+where
+    C: Connect + Clone + Send + Sync + 'static,
+    B: HttpBody + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Response = Response<Body>;
+    type Error = crate::Error;
+    type Future = ResponseFuture;
+    fn poll_ready(
+        &mut self,
+        _: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, req: Request<B>) -> Self::Future {
+        self.request(req)
+    }
+}
+impl<C, B> tower_service::Service<Request<B>> for &'_ Client<C, B>
+where
+    C: Connect + Clone + Send + Sync + 'static,
+    B: HttpBody + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Response = Response<Body>;
+    type Error = crate::Error;
+    type Future = ResponseFuture;
+    fn poll_ready(
+        &mut self,
+        _: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, req: Request<B>) -> Self::Future {
+        self.request(req)
+    }
+}
+impl<C: Clone, B> Clone for Client<C, B> {
+    fn clone(&self) -> Client<C, B> {
+        Client {
+            config: self.config.clone(),
+            conn_builder: self.conn_builder.clone(),
+            connector: self.connector.clone(),
+            pool: self.pool.clone(),
+        }
+    }
+}
+impl<C, B> fmt::Debug for Client<C, B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Client").finish()
+    }
+}
+impl ResponseFuture {
+    fn new<F>(value: F) -> Self
+    where
+        F: Future<Output = crate::Result<Response<Body>>> + Send + 'static,
+    {
+        Self {
+            inner: SyncWrapper::new(Box::pin(value)),
+        }
+    }
+    fn error_version(ver: Version) -> Self {
+        warn!("Request has unsupported version \"{:?}\"", ver);
+        ResponseFuture::new(
+            Box::pin(future::err(crate::Error::new_user_unsupported_version())),
+        )
+    }
+}
+impl fmt::Debug for ResponseFuture {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("Future<Response>")
+    }
+}
+impl Future for ResponseFuture {
+    type Output = crate::Result<Response<Body>>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        self.inner.get_mut().as_mut().poll(cx)
+    }
+}
+#[allow(missing_debug_implementations)]
+struct PoolClient<B> {
+    conn_info: Connected,
+    tx: PoolTx<B>,
+}
+enum PoolTx<B> {
+    Http1(conn::SendRequest<B>),
+    #[cfg(feature = "http2")]
+    Http2(conn::Http2SendRequest<B>),
+}
+impl<B> PoolClient<B> {
+    fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        match self.tx {
+            PoolTx::Http1(ref mut tx) => tx.poll_ready(cx),
+            #[cfg(feature = "http2")]
+            PoolTx::Http2(_) => Poll::Ready(Ok(())),
+        }
+    }
+    fn is_http1(&self) -> bool {
+        !self.is_http2()
+    }
+    fn is_http2(&self) -> bool {
+        match self.tx {
+            PoolTx::Http1(_) => false,
+            #[cfg(feature = "http2")]
+            PoolTx::Http2(_) => true,
+        }
+    }
+    fn is_ready(&self) -> bool {
+        match self.tx {
+            PoolTx::Http1(ref tx) => tx.is_ready(),
+            #[cfg(feature = "http2")]
+            PoolTx::Http2(ref tx) => tx.is_ready(),
+        }
+    }
+    fn is_closed(&self) -> bool {
+        match self.tx {
+            PoolTx::Http1(ref tx) => tx.is_closed(),
+            #[cfg(feature = "http2")]
+            PoolTx::Http2(ref tx) => tx.is_closed(),
+        }
+    }
+}
+impl<B: HttpBody + 'static> PoolClient<B> {
+    fn send_request_retryable(
+        &mut self,
+        req: Request<B>,
+    ) -> impl Future<Output = Result<Response<Body>, (crate::Error, Option<Request<B>>)>>
+    where
+        B: Send,
+    {
+        match self.tx {
+            #[cfg(not(feature = "http2"))]
+            PoolTx::Http1(ref mut tx) => tx.send_request_retryable(req),
+            #[cfg(feature = "http2")]
+            PoolTx::Http1(ref mut tx) => Either::Left(tx.send_request_retryable(req)),
+            #[cfg(feature = "http2")]
+            PoolTx::Http2(ref mut tx) => Either::Right(tx.send_request_retryable(req)),
+        }
+    }
+}
+impl<B> Poolable for PoolClient<B>
+where
+    B: Send + 'static,
+{
+    fn is_open(&self) -> bool {
+        match self.tx {
+            PoolTx::Http1(ref tx) => tx.is_ready(),
+            #[cfg(feature = "http2")]
+            PoolTx::Http2(ref tx) => tx.is_ready(),
+        }
+    }
+    fn reserve(self) -> Reservation<Self> {
+        match self.tx {
+            PoolTx::Http1(tx) => {
+                Reservation::Unique(PoolClient {
+                    conn_info: self.conn_info,
+                    tx: PoolTx::Http1(tx),
+                })
+            }
+            #[cfg(feature = "http2")]
+            PoolTx::Http2(tx) => {
+                let b = PoolClient {
+                    conn_info: self.conn_info.clone(),
+                    tx: PoolTx::Http2(tx.clone()),
+                };
+                let a = PoolClient {
+                    conn_info: self.conn_info,
+                    tx: PoolTx::Http2(tx),
+                };
+                Reservation::Shared(a, b)
+            }
+        }
+    }
+    fn can_share(&self) -> bool {
+        self.is_http2()
+    }
+}
+#[allow(missing_debug_implementations)]
+enum ClientError<B> {
+    Normal(crate::Error),
+    Canceled { connection_reused: bool, req: Request<B>, reason: crate::Error },
+}
+impl<B> ClientError<B> {
+    fn map_with_reused(
+        conn_reused: bool,
+    ) -> impl Fn((crate::Error, Option<Request<B>>)) -> Self {
+        move |(err, orig_req)| {
+            if let Some(req) = orig_req {
+                ClientError::Canceled {
+                    connection_reused: conn_reused,
+                    reason: err,
+                    req,
+                }
+            } else {
+                ClientError::Normal(err)
+            }
+        }
+    }
+}
+enum ClientConnectError {
+    Normal(crate::Error),
+    H2CheckoutIsClosed(crate::Error),
+}
+/// A marker to identify what version a pooled connection is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(super) enum Ver {
+    Auto,
+    Http2,
+}
+fn origin_form(uri: &mut Uri) {
+    let path = match uri.path_and_query() {
+        Some(path) if path.as_str() != "/" => {
+            let mut parts = ::http::uri::Parts::default();
+            parts.path_and_query = Some(path.clone());
+            Uri::from_parts(parts).expect("path is valid uri")
+        }
+        _none_or_just_slash => {
+            debug_assert!(Uri::default() == "/");
+            Uri::default()
+        }
+    };
+    *uri = path;
+}
+fn absolute_form(uri: &mut Uri) {
+    debug_assert!(uri.scheme().is_some(), "absolute_form needs a scheme");
+    debug_assert!(uri.authority().is_some(), "absolute_form needs an authority");
+    if uri.scheme() == Some(&Scheme::HTTPS) {
+        origin_form(uri);
+    }
+}
+fn authority_form(uri: &mut Uri) {
+    if let Some(path) = uri.path_and_query() {
+        if path != "/" {
+            warn!("HTTP/1.1 CONNECT request stripping path: {:?}", path);
+        }
+    }
+    *uri = match uri.authority() {
+        Some(auth) => {
+            let mut parts = ::http::uri::Parts::default();
+            parts.authority = Some(auth.clone());
+            Uri::from_parts(parts).expect("authority is valid")
+        }
+        None => {
+            unreachable!("authority_form with relative uri");
+        }
+    };
+}
+fn extract_domain(uri: &mut Uri, is_http_connect: bool) -> crate::Result<PoolKey> {
+    let uri_clone = uri.clone();
+    match (uri_clone.scheme(), uri_clone.authority()) {
+        (Some(scheme), Some(auth)) => Ok((scheme.clone(), auth.clone())),
+        (None, Some(auth)) if is_http_connect => {
+            let scheme = match auth.port_u16() {
+                Some(443) => {
+                    set_scheme(uri, Scheme::HTTPS);
+                    Scheme::HTTPS
+                }
+                _ => {
+                    set_scheme(uri, Scheme::HTTP);
+                    Scheme::HTTP
+                }
+            };
+            Ok((scheme, auth.clone()))
+        }
+        _ => {
+            debug!("Client requires absolute-form URIs, received: {:?}", uri);
+            Err(crate::Error::new_user_absolute_uri_required())
+        }
+    }
+}
+fn domain_as_uri((scheme, auth): PoolKey) -> Uri {
+    http::uri::Builder::new()
+        .scheme(scheme)
+        .authority(auth)
+        .path_and_query("/")
+        .build()
+        .expect("domain is valid Uri")
+}
+fn set_scheme(uri: &mut Uri, scheme: Scheme) {
+    debug_assert!(uri.scheme().is_none(), "set_scheme expects no existing scheme");
+    let old = mem::replace(uri, Uri::default());
+    let mut parts: ::http::uri::Parts = old.into();
+    parts.scheme = Some(scheme);
+    parts.path_and_query = Some("/".parse().expect("slash is a valid path"));
+    *uri = Uri::from_parts(parts).expect("scheme is valid");
+}
+fn get_non_default_port(uri: &Uri) -> Option<Port<&str>> {
+    match (uri.port().map(|p| p.as_u16()), is_schema_secure(uri)) {
+        (Some(443), true) => None,
+        (Some(80), false) => None,
+        _ => uri.port(),
+    }
+}
+fn is_schema_secure(uri: &Uri) -> bool {
+    uri.scheme_str()
+        .map(|scheme_str| matches!(scheme_str, "wss" | "https"))
+        .unwrap_or_default()
+}
+/// A builder to configure a new [`Client`](Client).
+///
+/// # Example
+///
+/// ```
+/// # #[cfg(feature  = "runtime")]
+/// # fn run () {
+/// use std::time::Duration;
+/// use hyper::Client;
+///
+/// let client = Client::builder()
+///     .pool_idle_timeout(Duration::from_secs(30))
+///     .http2_only(true)
+///     .build_http();
+/// # let infer: Client<_, hyper::Body> = client;
+/// # drop(infer);
+/// # }
+/// # fn main() {}
+/// ```
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+#[derive(Clone)]
+pub struct Builder {
+    client_config: Config,
+    conn_builder: conn::Builder,
+    pool_config: pool::Config,
+}
+impl Default for Builder {
+    fn default() -> Self {
+        Self {
+            client_config: Config {
+                retry_canceled_requests: true,
+                set_host: true,
+                ver: Ver::Auto,
+            },
+            conn_builder: conn::Builder::new(),
+            pool_config: pool::Config {
+                idle_timeout: Some(Duration::from_secs(90)),
+                max_idle_per_host: std::usize::MAX,
+            },
+        }
+    }
+}
+impl Builder {
+    #[doc(hidden)]
+    #[deprecated(
+        note = "name is confusing, to disable the connection pool, call pool_max_idle_per_host(0)"
+    )]
+    pub(crate) fn keep_alive(&mut self, val: bool) -> &mut Self {
+        if !val {
+            self.pool_max_idle_per_host(0)
+        } else if self.pool_config.max_idle_per_host == 0 {
+            self.pool_max_idle_per_host(std::usize::MAX)
+        } else {
+            self
+        }
+    }
+    #[doc(hidden)]
+    #[deprecated(note = "renamed to `pool_idle_timeout`")]
+    pub(crate) fn keep_alive_timeout<D>(&mut self, val: D) -> &mut Self
+    where
+        D: Into<Option<Duration>>,
+    {
+        self.pool_idle_timeout(val)
+    }
+    /// Set an optional timeout for idle sockets being kept-alive.
+    ///
+    /// Pass `None` to disable timeout.
+    ///
+    /// Default is 90 seconds.
+    pub(crate) fn pool_idle_timeout<D>(&mut self, val: D) -> &mut Self
+    where
+        D: Into<Option<Duration>>,
+    {
+        self.pool_config.idle_timeout = val.into();
+        self
+    }
+    #[doc(hidden)]
+    #[deprecated(note = "renamed to `pool_max_idle_per_host`")]
+    pub(crate) fn max_idle_per_host(&mut self, max_idle: usize) -> &mut Self {
+        self.pool_config.max_idle_per_host = max_idle;
+        self
+    }
+    /// Sets the maximum idle connection per host allowed in the pool.
+    ///
+    /// Default is `usize::MAX` (no limit).
+    pub(crate) fn pool_max_idle_per_host(&mut self, max_idle: usize) -> &mut Self {
+        self.pool_config.max_idle_per_host = max_idle;
+        self
+    }
+    /// Sets the exact size of the read buffer to *always* use.
+    ///
+    /// Note that setting this option unsets the `http1_max_buf_size` option.
+    ///
+    /// Default is an adaptive read buffer.
+    pub(crate) fn http1_read_buf_exact_size(&mut self, sz: usize) -> &mut Self {
+        self.conn_builder.http1_read_buf_exact_size(Some(sz));
+        self
+    }
+    /// Set the maximum buffer size for the connection.
+    ///
+    /// Default is ~400kb.
+    ///
+    /// Note that setting this option unsets the `http1_read_exact_buf_size` option.
+    ///
+    /// # Panics
+    ///
+    /// The minimum value allowed is 8192. This method panics if the passed `max` is less than the minimum.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_max_buf_size(&mut self, max: usize) -> &mut Self {
+        self.conn_builder.http1_max_buf_size(max);
+        self
+    }
+    /// Set whether HTTP/1 connections will accept spaces between header names
+    /// and the colon that follow them in responses.
+    ///
+    /// Newline codepoints (`\r` and `\n`) will be transformed to spaces when
+    /// parsing.
+    ///
+    /// You probably don't need this, here is what [RFC 7230 Section 3.2.4.] has
+    /// to say about it:
+    ///
+    /// > No whitespace is allowed between the header field-name and colon. In
+    /// > the past, differences in the handling of such whitespace have led to
+    /// > security vulnerabilities in request routing and response handling. A
+    /// > server MUST reject any received request message that contains
+    /// > whitespace between a header field-name and colon with a response code
+    /// > of 400 (Bad Request). A proxy MUST remove any such whitespace from a
+    /// > response message before forwarding the message downstream.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    ///
+    /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
+    pub(crate) fn http1_allow_spaces_after_header_name_in_responses(
+        &mut self,
+        val: bool,
+    ) -> &mut Self {
+        self.conn_builder.http1_allow_spaces_after_header_name_in_responses(val);
+        self
+    }
+    /// Set whether HTTP/1 connections will accept obsolete line folding for
+    /// header values.
+    ///
+    /// You probably don't need this, here is what [RFC 7230 Section 3.2.4.] has
+    /// to say about it:
+    ///
+    /// > A server that receives an obs-fold in a request message that is not
+    /// > within a message/http container MUST either reject the message by
+    /// > sending a 400 (Bad Request), preferably with a representation
+    /// > explaining that obsolete line folding is unacceptable, or replace
+    /// > each received obs-fold with one or more SP octets prior to
+    /// > interpreting the field value or forwarding the message downstream.
+    ///
+    /// > A proxy or gateway that receives an obs-fold in a response message
+    /// > that is not within a message/http container MUST either discard the
+    /// > message and replace it with a 502 (Bad Gateway) response, preferably
+    /// > with a representation explaining that unacceptable line folding was
+    /// > received, or replace each received obs-fold with one or more SP
+    /// > octets prior to interpreting the field value or forwarding the
+    /// > message downstream.
+    ///
+    /// > A user agent that receives an obs-fold in a response message that is
+    /// > not within a message/http container MUST replace each received
+    /// > obs-fold with one or more SP octets prior to interpreting the field
+    /// > value.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    ///
+    /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
+    pub(crate) fn http1_allow_obsolete_multiline_headers_in_responses(
+        &mut self,
+        val: bool,
+    ) -> &mut Self {
+        self.conn_builder.http1_allow_obsolete_multiline_headers_in_responses(val);
+        self
+    }
+    /// Sets whether invalid header lines should be silently ignored in HTTP/1 responses.
+    ///
+    /// This mimicks the behaviour of major browsers. You probably don't want this.
+    /// You should only want this if you are implementing a proxy whose main
+    /// purpose is to sit in front of browsers whose users access arbitrary content
+    /// which may be malformed, and they expect everything that works without
+    /// the proxy to keep working with the proxy.
+    ///
+    /// This option will prevent Hyper's client from returning an error encountered
+    /// when parsing a header, except if the error was caused by the character NUL
+    /// (ASCII code 0), as Chrome specifically always reject those.
+    ///
+    /// The ignorable errors are:
+    /// * empty header names;
+    /// * characters that are not allowed in header names, except for `\0` and `\r`;
+    /// * when `allow_spaces_after_header_name_in_responses` is not enabled,
+    ///   spaces and tabs between the header name and the colon;
+    /// * missing colon between header name and colon;
+    /// * characters that are not allowed in header values except for `\0` and `\r`.
+    ///
+    /// If an ignorable error is encountered, the parser tries to find the next
+    /// line in the input to resume parsing the rest of the headers. An error
+    /// will be emitted nonetheless if it finds `\0` or a lone `\r` while
+    /// looking for the next line.
+    pub(crate) fn http1_ignore_invalid_headers_in_responses(
+        &mut self,
+        val: bool,
+    ) -> &mut Builder {
+        self.conn_builder.http1_ignore_invalid_headers_in_responses(val);
+        self
+    }
+    /// Set whether HTTP/1 connections should try to use vectored writes,
+    /// or always flatten into a single buffer.
+    ///
+    /// Note that setting this to false may mean more copies of body data,
+    /// but may also improve performance when an IO transport doesn't
+    /// support vectored writes well, such as most TLS implementations.
+    ///
+    /// Setting this to true will force hyper to use queued strategy
+    /// which may eliminate unnecessary cloning on some TLS backends
+    ///
+    /// Default is `auto`. In this mode hyper will try to guess which
+    /// mode to use
+    pub(crate) fn http1_writev(&mut self, enabled: bool) -> &mut Builder {
+        self.conn_builder.http1_writev(enabled);
+        self
+    }
+    /// Set whether HTTP/1 connections will write header names as title case at
+    /// the socket level.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    pub(crate) fn http1_title_case_headers(&mut self, val: bool) -> &mut Self {
+        self.conn_builder.http1_title_case_headers(val);
+        self
+    }
+    /// Set whether to support preserving original header cases.
+    ///
+    /// Currently, this will record the original cases received, and store them
+    /// in a private extension on the `Response`. It will also look for and use
+    /// such an extension in any provided `Request`.
+    ///
+    /// Since the relevant extension is still private, there is no way to
+    /// interact with the original cases. The only effect this can have now is
+    /// to forward the cases in a proxy-like fashion.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    pub(crate) fn http1_preserve_header_case(&mut self, val: bool) -> &mut Self {
+        self.conn_builder.http1_preserve_header_case(val);
+        self
+    }
+    /// Set whether HTTP/0.9 responses should be tolerated.
+    ///
+    /// Default is false.
+    pub(crate) fn http09_responses(&mut self, val: bool) -> &mut Self {
+        self.conn_builder.http09_responses(val);
+        self
+    }
+    /// Set whether the connection **must** use HTTP/2.
+    ///
+    /// The destination must either allow HTTP2 Prior Knowledge, or the
+    /// `Connect` should be configured to do use ALPN to upgrade to `h2`
+    /// as part of the connection process. This will not make the `Client`
+    /// utilize ALPN by itself.
+    ///
+    /// Note that setting this to true prevents HTTP/1 from being allowed.
+    ///
+    /// Default is false.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_only(&mut self, val: bool) -> &mut Self {
+        self.client_config.ver = if val { Ver::Http2 } else { Ver::Auto };
+        self
+    }
+    /// Sets the [`SETTINGS_INITIAL_WINDOW_SIZE`][spec] option for HTTP2
+    /// stream-level flow control.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    ///
+    /// [spec]: https://http2.github.io/http2-spec/#SETTINGS_INITIAL_WINDOW_SIZE
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_stream_window_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        self.conn_builder.http2_initial_stream_window_size(sz.into());
+        self
+    }
+    /// Sets the max connection-level flow control for HTTP2
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_connection_window_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        self.conn_builder.http2_initial_connection_window_size(sz.into());
+        self
+    }
+    /// Sets whether to use an adaptive flow control.
+    ///
+    /// Enabling this will override the limits set in
+    /// `http2_initial_stream_window_size` and
+    /// `http2_initial_connection_window_size`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_adaptive_window(&mut self, enabled: bool) -> &mut Self {
+        self.conn_builder.http2_adaptive_window(enabled);
+        self
+    }
+    /// Sets the maximum frame size to use for HTTP2.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_frame_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        self.conn_builder.http2_max_frame_size(sz);
+        self
+    }
+    /// Sets an interval for HTTP2 Ping frames should be sent to keep a
+    /// connection alive.
+    ///
+    /// Pass `None` to disable HTTP2 keep-alive.
+    ///
+    /// Default is currently disabled.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_interval(
+        &mut self,
+        interval: impl Into<Option<Duration>>,
+    ) -> &mut Self {
+        self.conn_builder.http2_keep_alive_interval(interval);
+        self
+    }
+    /// Sets a timeout for receiving an acknowledgement of the keep-alive ping.
+    ///
+    /// If the ping is not acknowledged within the timeout, the connection will
+    /// be closed. Does nothing if `http2_keep_alive_interval` is disabled.
+    ///
+    /// Default is 20 seconds.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
+        self.conn_builder.http2_keep_alive_timeout(timeout);
+        self
+    }
+    /// Sets whether HTTP2 keep-alive should apply while the connection is idle.
+    ///
+    /// If disabled, keep-alive pings are only sent while there are open
+    /// request/responses streams. If enabled, pings are also sent when no
+    /// streams are active. Does nothing if `http2_keep_alive_interval` is
+    /// disabled.
+    ///
+    /// Default is `false`.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_while_idle(&mut self, enabled: bool) -> &mut Self {
+        self.conn_builder.http2_keep_alive_while_idle(enabled);
+        self
+    }
+    /// Sets the maximum number of HTTP2 concurrent locally reset streams.
+    ///
+    /// See the documentation of [`h2::client::Builder::max_concurrent_reset_streams`] for more
+    /// details.
+    ///
+    /// The default value is determined by the `h2` crate.
+    ///
+    /// [`h2::client::Builder::max_concurrent_reset_streams`]: https://docs.rs/h2/client/struct.Builder.html#method.max_concurrent_reset_streams
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_concurrent_reset_streams(
+        &mut self,
+        max: usize,
+    ) -> &mut Self {
+        self.conn_builder.http2_max_concurrent_reset_streams(max);
+        self
+    }
+    /// Set the maximum write buffer size for each HTTP/2 stream.
+    ///
+    /// Default is currently 1MB, but may change.
+    ///
+    /// # Panics
+    ///
+    /// The value must be no larger than `u32::MAX`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_send_buf_size(&mut self, max: usize) -> &mut Self {
+        self.conn_builder.http2_max_send_buf_size(max);
+        self
+    }
+    /// Set whether to retry requests that get disrupted before ever starting
+    /// to write.
+    ///
+    /// This means a request that is queued, and gets given an idle, reused
+    /// connection, and then encounters an error immediately as the idle
+    /// connection was found to be unusable.
+    ///
+    /// When this is set to `false`, the related `ResponseFuture` would instead
+    /// resolve to an `Error::Cancel`.
+    ///
+    /// Default is `true`.
+    #[inline]
+    pub(crate) fn retry_canceled_requests(&mut self, val: bool) -> &mut Self {
+        self.client_config.retry_canceled_requests = val;
+        self
+    }
+    /// Set whether to automatically add the `Host` header to requests.
+    ///
+    /// If true, and a request does not include a `Host` header, one will be
+    /// added automatically, derived from the authority of the `Uri`.
+    ///
+    /// Default is `true`.
+    #[inline]
+    pub(crate) fn set_host(&mut self, val: bool) -> &mut Self {
+        self.client_config.set_host = val;
+        self
+    }
+    /// Provide an executor to execute background `Connection` tasks.
+    pub(crate) fn executor<E>(&mut self, exec: E) -> &mut Self
+    where
+        E: Executor<BoxSendFuture> + Send + Sync + 'static,
+    {
+        self.conn_builder.executor(exec);
+        self
+    }
+    /// Builder a client with this configuration and the default `HttpConnector`.
+    #[cfg(feature = "tcp")]
+    pub(crate) fn build_http<B>(&self) -> Client<HttpConnector, B>
+    where
+        B: HttpBody + Send,
+        B::Data: Send,
+    {
+        let mut connector = HttpConnector::new();
+        if self.pool_config.is_enabled() {
+            connector.set_keepalive(self.pool_config.idle_timeout);
+        }
+        self.build(connector)
+    }
+    /// Combine the configuration of this builder with a connector to create a `Client`.
+    pub(crate) fn build<C, B>(&self, connector: C) -> Client<C, B>
+    where
+        C: Connect + Clone,
+        B: HttpBody + Send,
+        B::Data: Send,
+    {
+        Client {
+            config: self.client_config,
+            conn_builder: self.conn_builder.clone(),
+            connector,
+            pool: Pool::new(self.pool_config, &self.conn_builder.exec),
+        }
+    }
+}
+impl fmt::Debug for Builder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Builder")
+            .field("client_config", &self.client_config)
+            .field("conn_builder", &self.conn_builder)
+            .field("pool_config", &self.pool_config)
+            .finish()
+    }
+}
+#[cfg(test)]
+mod unit_tests {
+    use super::*;
+    #[test]
+    fn response_future_is_sync() {
+        fn assert_sync<T: Sync>() {}
+        assert_sync::<ResponseFuture>();
+    }
+    #[test]
+    fn set_relative_uri_with_implicit_path() {
+        let mut uri = "http://hyper.rs".parse().unwrap();
+        origin_form(&mut uri);
+        assert_eq!(uri.to_string(), "/");
+    }
+    #[test]
+    fn test_origin_form() {
+        let mut uri = "http://hyper.rs/guides".parse().unwrap();
+        origin_form(&mut uri);
+        assert_eq!(uri.to_string(), "/guides");
+        let mut uri = "http://hyper.rs/guides?foo=bar".parse().unwrap();
+        origin_form(&mut uri);
+        assert_eq!(uri.to_string(), "/guides?foo=bar");
+    }
+    #[test]
+    fn test_absolute_form() {
+        let mut uri = "http://hyper.rs/guides".parse().unwrap();
+        absolute_form(&mut uri);
+        assert_eq!(uri.to_string(), "http://hyper.rs/guides");
+        let mut uri = "https://hyper.rs/guides".parse().unwrap();
+        absolute_form(&mut uri);
+        assert_eq!(uri.to_string(), "/guides");
+    }
+    #[test]
+    fn test_authority_form() {
+        let _ = pretty_env_logger::try_init();
+        let mut uri = "http://hyper.rs".parse().unwrap();
+        authority_form(&mut uri);
+        assert_eq!(uri.to_string(), "hyper.rs");
+        let mut uri = "hyper.rs".parse().unwrap();
+        authority_form(&mut uri);
+        assert_eq!(uri.to_string(), "hyper.rs");
+    }
+    #[test]
+    fn test_extract_domain_connect_no_port() {
+        let mut uri = "hyper.rs".parse().unwrap();
+        let (scheme, host) = extract_domain(&mut uri, true).expect("extract domain");
+        assert_eq!(scheme, * "http");
+        assert_eq!(host, "hyper.rs");
+    }
+    #[test]
+    fn test_is_secure() {
+        assert_eq!(
+            is_schema_secure(& "http://hyper.rs".parse::< Uri > ().unwrap()), false
+        );
+        assert_eq!(is_schema_secure(& "hyper.rs".parse::< Uri > ().unwrap()), false);
+        assert_eq!(
+            is_schema_secure(& "wss://hyper.rs".parse::< Uri > ().unwrap()), true
+        );
+        assert_eq!(
+            is_schema_secure(& "ws://hyper.rs".parse::< Uri > ().unwrap()), false
+        );
+    }
+    #[test]
+    fn test_get_non_default_port() {
+        assert!(
+            get_non_default_port(& "http://hyper.rs".parse::< Uri > ().unwrap())
+            .is_none()
+        );
+        assert!(
+            get_non_default_port(& "http://hyper.rs:80".parse::< Uri > ().unwrap())
+            .is_none()
+        );
+        assert!(
+            get_non_default_port(& "https://hyper.rs:443".parse::< Uri > ().unwrap())
+            .is_none()
+        );
+        assert!(
+            get_non_default_port(& "hyper.rs:80".parse::< Uri > ().unwrap()).is_none()
+        );
+        assert_eq!(
+            get_non_default_port(& "http://hyper.rs:123".parse::< Uri > ().unwrap())
+            .unwrap().as_u16(), 123
+        );
+        assert_eq!(
+            get_non_default_port(& "https://hyper.rs:80".parse::< Uri > ().unwrap())
+            .unwrap().as_u16(), 80
+        );
+        assert_eq!(
+            get_non_default_port(& "hyper.rs:123".parse::< Uri > ().unwrap()).unwrap()
+            .as_u16(), 123
+        );
+    }
+}
diff --git a/hyper/src/client/conn.rs b/hyper/src/client/conn.rs
new file mode 100644
index 0000000..543b33e
--- /dev/null
+++ b/hyper/src/client/conn.rs
@@ -0,0 +1,1025 @@
+//! Lower-level client connection API.
+//!
+//! The types in this module are to provide a lower-level API based around a
+//! single connection. Connecting to a host, pooling connections, and the like
+//! are not handled at this level. This module provides the building blocks to
+//! customize those things externally.
+//!
+//! If don't have need to manage connections yourself, consider using the
+//! higher-level [Client](super) API.
+//!
+//! ## Example
+//! A simple example that uses the `SendRequest` struct to talk HTTP over a Tokio TCP stream
+//! ```no_run
+//! # #[cfg(all(feature = "client", feature = "http1", feature = "runtime"))]
+//! # mod rt {
+//! use tower::ServiceExt;
+//! use http::{Request, StatusCode};
+//! use hyper::{client::conn, Body};
+//! use tokio::net::TcpStream;
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     let target_stream = TcpStream::connect("example.com:80").await?;
+//!
+//!     let (mut request_sender, connection) = conn::handshake(target_stream).await?;
+//!
+//!     // spawn a task to poll the connection and drive the HTTP state
+//!     tokio::spawn(async move {
+//!         if let Err(e) = connection.await {
+//!             eprintln!("Error in connection: {}", e);
+//!         }
+//!     });
+//!
+//!     let request = Request::builder()
+//!         // We need to manually add the host header because SendRequest does not
+//!         .header("Host", "example.com")
+//!         .method("GET")
+//!         .body(Body::from(""))?;
+//!     let response = request_sender.send_request(request).await?;
+//!     assert!(response.status() == StatusCode::OK);
+//!
+//!     // To send via the same connection again, it may not work as it may not be ready,
+//!     // so we have to wait until the request_sender becomes ready.
+//!     request_sender.ready().await?;
+//!     let request = Request::builder()
+//!         .header("Host", "example.com")
+//!         .method("GET")
+//!         .body(Body::from(""))?;
+//!     let response = request_sender.send_request(request).await?;
+//!     assert!(response.status() == StatusCode::OK);
+//!     Ok(())
+//! }
+//!
+//! # }
+//! ```
+use std::error::Error as StdError;
+use std::fmt;
+#[cfg(not(all(feature = "http1", feature = "http2")))]
+use std::marker::PhantomData;
+use std::sync::Arc;
+#[cfg(all(feature = "runtime", feature = "http2"))]
+use std::time::Duration;
+use bytes::Bytes;
+use futures_util::future::{self, Either, FutureExt as _};
+use httparse::ParserConfig;
+use pin_project_lite::pin_project;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tower_service::Service;
+use tracing::{debug, trace};
+use super::dispatch;
+use crate::body::HttpBody;
+#[cfg(not(all(feature = "http1", feature = "http2")))]
+use crate::common::Never;
+use crate::common::{
+    exec::{BoxSendFuture, Exec},
+    task, Future, Pin, Poll,
+};
+use crate::proto;
+use crate::rt::Executor;
+#[cfg(feature = "http1")]
+use crate::upgrade::Upgraded;
+use crate::{Body, Request, Response};
+#[cfg(feature = "http1")]
+type Http1Dispatcher<T, B> = proto::dispatch::Dispatcher<
+    proto::dispatch::Client<B>,
+    B,
+    T,
+    proto::h1::ClientTransaction,
+>;
+#[cfg(not(feature = "http1"))]
+type Http1Dispatcher<T, B> = (Never, PhantomData<(T, Pin<Box<B>>)>);
+#[cfg(feature = "http2")]
+type Http2ClientTask<B> = proto::h2::ClientTask<B>;
+#[cfg(not(feature = "http2"))]
+type Http2ClientTask<B> = (Never, PhantomData<Pin<Box<B>>>);
+pin_project! {
+    #[project = ProtoClientProj] enum ProtoClient < T, B > where B : HttpBody, { H1 {
+    #[pin] h1 : Http1Dispatcher < T, B >, }, H2 { #[pin] h2 : Http2ClientTask < B >, }, }
+}
+/// Returns a handshake future over some IO.
+///
+/// This is a shortcut for `Builder::new().handshake(io)`.
+/// See [`client::conn`](crate::client::conn) for more.
+pub(crate) async fn handshake<T>(
+    io: T,
+) -> crate::Result<(SendRequest<crate::Body>, Connection<T, crate::Body>)>
+where
+    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+{
+    Builder::new().handshake(io).await
+}
+/// The sender side of an established connection.
+pub struct SendRequest<B> {
+    dispatch: dispatch::Sender<Request<B>, Response<Body>>,
+}
+/// A future that processes all HTTP state for the IO object.
+///
+/// In most cases, this should just be spawned into an executor, so that it
+/// can process incoming and outgoing messages, notice hangups, and the like.
+#[must_use = "futures do nothing unless polled"]
+pub struct Connection<T, B>
+where
+    T: AsyncRead + AsyncWrite + Send + 'static,
+    B: HttpBody + 'static,
+{
+    inner: Option<ProtoClient<T, B>>,
+}
+/// A builder to configure an HTTP connection.
+///
+/// After setting options, the builder is used to create a handshake future.
+#[derive(Clone, Debug)]
+pub struct Builder {
+    pub(super) exec: Exec,
+    h09_responses: bool,
+    h1_parser_config: ParserConfig,
+    h1_writev: Option<bool>,
+    h1_title_case_headers: bool,
+    h1_preserve_header_case: bool,
+    #[cfg(feature = "ffi")]
+    h1_preserve_header_order: bool,
+    h1_read_buf_exact_size: Option<usize>,
+    h1_max_buf_size: Option<usize>,
+    #[cfg(feature = "ffi")]
+    h1_headers_raw: bool,
+    #[cfg(feature = "http2")]
+    h2_builder: proto::h2::client::Config,
+    version: Proto,
+}
+#[derive(Clone, Debug)]
+enum Proto {
+    #[cfg(feature = "http1")]
+    Http1,
+    #[cfg(feature = "http2")]
+    Http2,
+}
+/// A future returned by `SendRequest::send_request`.
+///
+/// Yields a `Response` if successful.
+#[must_use = "futures do nothing unless polled"]
+pub struct ResponseFuture {
+    inner: ResponseFutureState,
+}
+enum ResponseFutureState {
+    Waiting(dispatch::Promise<Response<Body>>),
+    Error(Option<crate::Error>),
+}
+/// Deconstructed parts of a `Connection`.
+///
+/// This allows taking apart a `Connection` at a later time, in order to
+/// reclaim the IO object, and additional related pieces.
+#[derive(Debug)]
+pub struct Parts<T> {
+    /// The original IO object used in the handshake.
+    pub(crate) io: T,
+    /// A buffer of bytes that have been read but not processed as HTTP.
+    ///
+    /// For instance, if the `Connection` is used for an HTTP upgrade request,
+    /// it is possible the server sent back the first bytes of the new protocol
+    /// along with the response upgrade.
+    ///
+    /// You will want to check for any existing bytes if you plan to continue
+    /// communicating on the IO object.
+    pub(crate) read_buf: Bytes,
+    _inner: (),
+}
+#[must_use = "futures do nothing unless polled"]
+#[cfg(feature = "http2")]
+pub(super) struct Http2SendRequest<B> {
+    dispatch: dispatch::UnboundedSender<Request<B>, Response<Body>>,
+}
+impl<B> SendRequest<B> {
+    /// Polls to determine whether this sender can be used yet for a request.
+    ///
+    /// If the associated connection is closed, this returns an Error.
+    pub(crate) fn poll_ready(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<crate::Result<()>> {
+        self.dispatch.poll_ready(cx)
+    }
+    pub(super) async fn when_ready(self) -> crate::Result<Self> {
+        let mut me = Some(self);
+        future::poll_fn(move |cx| {
+                ready!(me.as_mut().unwrap().poll_ready(cx))?;
+                Poll::Ready(Ok(me.take().unwrap()))
+            })
+            .await
+    }
+    pub(super) fn is_ready(&self) -> bool {
+        self.dispatch.is_ready()
+    }
+    pub(super) fn is_closed(&self) -> bool {
+        self.dispatch.is_closed()
+    }
+    #[cfg(feature = "http2")]
+    pub(super) fn into_http2(self) -> Http2SendRequest<B> {
+        Http2SendRequest {
+            dispatch: self.dispatch.unbound(),
+        }
+    }
+}
+impl<B> SendRequest<B>
+where
+    B: HttpBody + 'static,
+{
+    /// Sends a `Request` on the associated connection.
+    ///
+    /// Returns a future that if successful, yields the `Response`.
+    ///
+    /// # Note
+    ///
+    /// There are some key differences in what automatic things the `Client`
+    /// does for you that will not be done here:
+    ///
+    /// - `Client` requires absolute-form `Uri`s, since the scheme and
+    ///   authority are needed to connect. They aren't required here.
+    /// - Since the `Client` requires absolute-form `Uri`s, it can add
+    ///   the `Host` header based on it. You must add a `Host` header yourself
+    ///   before calling this method.
+    /// - Since absolute-form `Uri`s are not required, if received, they will
+    ///   be serialized as-is.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use http::header::HOST;
+    /// # use hyper::client::conn::SendRequest;
+    /// # use hyper::Body;
+    /// use hyper::Request;
+    ///
+    /// # async fn doc(mut tx: SendRequest<Body>) -> hyper::Result<()> {
+    /// // build a Request
+    /// let req = Request::builder()
+    ///     .uri("/foo/bar")
+    ///     .header(HOST, "hyper.rs")
+    ///     .body(Body::empty())
+    ///     .unwrap();
+    ///
+    /// // send it and await a Response
+    /// let res = tx.send_request(req).await?;
+    /// // assert the Response
+    /// assert!(res.status().is_success());
+    /// # Ok(())
+    /// # }
+    /// # fn main() {}
+    /// ```
+    pub(crate) fn send_request(&mut self, req: Request<B>) -> ResponseFuture {
+        let inner = match self.dispatch.send(req) {
+            Ok(rx) => ResponseFutureState::Waiting(rx),
+            Err(_req) => {
+                debug!("connection was not ready");
+                let err = crate::Error::new_canceled().with("connection was not ready");
+                ResponseFutureState::Error(Some(err))
+            }
+        };
+        ResponseFuture { inner }
+    }
+    pub(super) fn send_request_retryable(
+        &mut self,
+        req: Request<B>,
+    ) -> impl Future<
+        Output = Result<Response<Body>, (crate::Error, Option<Request<B>>)>,
+    > + Unpin
+    where
+        B: Send,
+    {
+        match self.dispatch.try_send(req) {
+            Ok(rx) => {
+                Either::Left(
+                    rx
+                        .then(move |res| {
+                            match res {
+                                Ok(Ok(res)) => future::ok(res),
+                                Ok(Err(err)) => future::err(err),
+                                Err(_) => panic!("dispatch dropped without returning error"),
+                            }
+                        }),
+                )
+            }
+            Err(req) => {
+                debug!("connection was not ready");
+                let err = crate::Error::new_canceled().with("connection was not ready");
+                Either::Right(future::err((err, Some(req))))
+            }
+        }
+    }
+}
+impl<B> Service<Request<B>> for SendRequest<B>
+where
+    B: HttpBody + 'static,
+{
+    type Response = Response<Body>;
+    type Error = crate::Error;
+    type Future = ResponseFuture;
+    fn poll_ready(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        self.poll_ready(cx)
+    }
+    fn call(&mut self, req: Request<B>) -> Self::Future {
+        self.send_request(req)
+    }
+}
+impl<B> fmt::Debug for SendRequest<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SendRequest").finish()
+    }
+}
+#[cfg(feature = "http2")]
+impl<B> Http2SendRequest<B> {
+    pub(super) fn is_ready(&self) -> bool {
+        self.dispatch.is_ready()
+    }
+    pub(super) fn is_closed(&self) -> bool {
+        self.dispatch.is_closed()
+    }
+}
+#[cfg(feature = "http2")]
+impl<B> Http2SendRequest<B>
+where
+    B: HttpBody + 'static,
+{
+    pub(super) fn send_request_retryable(
+        &mut self,
+        req: Request<B>,
+    ) -> impl Future<Output = Result<Response<Body>, (crate::Error, Option<Request<B>>)>>
+    where
+        B: Send,
+    {
+        match self.dispatch.try_send(req) {
+            Ok(rx) => {
+                Either::Left(
+                    rx
+                        .then(move |res| {
+                            match res {
+                                Ok(Ok(res)) => future::ok(res),
+                                Ok(Err(err)) => future::err(err),
+                                Err(_) => panic!("dispatch dropped without returning error"),
+                            }
+                        }),
+                )
+            }
+            Err(req) => {
+                debug!("connection was not ready");
+                let err = crate::Error::new_canceled().with("connection was not ready");
+                Either::Right(future::err((err, Some(req))))
+            }
+        }
+    }
+}
+#[cfg(feature = "http2")]
+impl<B> fmt::Debug for Http2SendRequest<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Http2SendRequest").finish()
+    }
+}
+#[cfg(feature = "http2")]
+impl<B> Clone for Http2SendRequest<B> {
+    fn clone(&self) -> Self {
+        Http2SendRequest {
+            dispatch: self.dispatch.clone(),
+        }
+    }
+}
+impl<T, B> Connection<T, B>
+where
+    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    B: HttpBody + Unpin + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    /// Return the inner IO object, and additional information.
+    ///
+    /// Only works for HTTP/1 connections. HTTP/2 connections will panic.
+    pub(crate) fn into_parts(self) -> Parts<T> {
+        match self.inner.expect("already upgraded") {
+            #[cfg(feature = "http1")]
+            ProtoClient::H1 { h1 } => {
+                let (io, read_buf, _) = h1.into_inner();
+                Parts { io, read_buf, _inner: () }
+            }
+            ProtoClient::H2 { .. } => {
+                panic!("http2 cannot into_inner");
+            }
+            #[cfg(not(feature = "http1"))]
+            ProtoClient::H1 { h1 } => match h1.0 {}
+        }
+    }
+    /// Poll the connection for completion, but without calling `shutdown`
+    /// on the underlying IO.
+    ///
+    /// This is useful to allow running a connection while doing an HTTP
+    /// upgrade. Once the upgrade is completed, the connection would be "done",
+    /// but it is not desired to actually shutdown the IO object. Instead you
+    /// would take it back using `into_parts`.
+    ///
+    /// Use [`poll_fn`](https://docs.rs/futures/0.1.25/futures/future/fn.poll_fn.html)
+    /// and [`try_ready!`](https://docs.rs/futures/0.1.25/futures/macro.try_ready.html)
+    /// to work with this function; or use the `without_shutdown` wrapper.
+    pub(crate) fn poll_without_shutdown(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<crate::Result<()>> {
+        match *self.inner.as_mut().expect("already upgraded") {
+            #[cfg(feature = "http1")]
+            ProtoClient::H1 { ref mut h1 } => h1.poll_without_shutdown(cx),
+            #[cfg(feature = "http2")]
+            ProtoClient::H2 { ref mut h2, .. } => Pin::new(h2).poll(cx).map_ok(|_| ()),
+            #[cfg(not(feature = "http1"))]
+            ProtoClient::H1 { ref mut h1 } => match h1.0 {}
+            #[cfg(not(feature = "http2"))]
+            ProtoClient::H2 { ref mut h2, .. } => match h2.0 {}
+        }
+    }
+    /// Prevent shutdown of the underlying IO object at the end of service the request,
+    /// instead run `into_parts`. This is a convenience wrapper over `poll_without_shutdown`.
+    pub(crate) fn without_shutdown(
+        self,
+    ) -> impl Future<Output = crate::Result<Parts<T>>> {
+        let mut conn = Some(self);
+        future::poll_fn(move |cx| -> Poll<crate::Result<Parts<T>>> {
+            ready!(conn.as_mut().unwrap().poll_without_shutdown(cx))?;
+            Poll::Ready(Ok(conn.take().unwrap().into_parts()))
+        })
+    }
+    /// Returns whether the [extended CONNECT protocol][1] is enabled or not.
+    ///
+    /// This setting is configured by the server peer by sending the
+    /// [`SETTINGS_ENABLE_CONNECT_PROTOCOL` parameter][2] in a `SETTINGS` frame.
+    /// This method returns the currently acknowledged value received from the
+    /// remote.
+    ///
+    /// [1]: https://datatracker.ietf.org/doc/html/rfc8441#section-4
+    /// [2]: https://datatracker.ietf.org/doc/html/rfc8441#section-3
+    #[cfg(feature = "http2")]
+    pub(crate) fn http2_is_extended_connect_protocol_enabled(&self) -> bool {
+        match self.inner.as_ref().unwrap() {
+            ProtoClient::H1 { .. } => false,
+            ProtoClient::H2 { h2 } => h2.is_extended_connect_protocol_enabled(),
+        }
+    }
+}
+impl<T, B> Future for Connection<T, B>
+where
+    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    B: HttpBody + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Output = crate::Result<()>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        match ready!(Pin::new(self.inner.as_mut().unwrap()).poll(cx))? {
+            proto::Dispatched::Shutdown => Poll::Ready(Ok(())),
+            #[cfg(feature = "http1")]
+            proto::Dispatched::Upgrade(pending) => {
+                match self.inner.take() {
+                    Some(ProtoClient::H1 { h1 }) => {
+                        let (io, buf, _) = h1.into_inner();
+                        pending.fulfill(Upgraded::new(io, buf));
+                        Poll::Ready(Ok(()))
+                    }
+                    _ => {
+                        drop(pending);
+                        unreachable!("Upgrade expects h1");
+                    }
+                }
+            }
+        }
+    }
+}
+impl<T, B> fmt::Debug for Connection<T, B>
+where
+    T: AsyncRead + AsyncWrite + fmt::Debug + Send + 'static,
+    B: HttpBody + 'static,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Connection").finish()
+    }
+}
+impl Builder {
+    /// Creates a new connection builder.
+    #[inline]
+    pub(crate) fn new() -> Builder {
+        Builder {
+            exec: Exec::Default,
+            h09_responses: false,
+            h1_writev: None,
+            h1_read_buf_exact_size: None,
+            h1_parser_config: Default::default(),
+            h1_title_case_headers: false,
+            h1_preserve_header_case: false,
+            #[cfg(feature = "ffi")]
+            h1_preserve_header_order: false,
+            h1_max_buf_size: None,
+            #[cfg(feature = "ffi")]
+            h1_headers_raw: false,
+            #[cfg(feature = "http2")]
+            h2_builder: Default::default(),
+            #[cfg(feature = "http1")]
+            version: Proto::Http1,
+            #[cfg(not(feature = "http1"))]
+            version: Proto::Http2,
+        }
+    }
+    /// Provide an executor to execute background HTTP2 tasks.
+    pub(crate) fn executor<E>(&mut self, exec: E) -> &mut Builder
+    where
+        E: Executor<BoxSendFuture> + Send + Sync + 'static,
+    {
+        self.exec = Exec::Executor(Arc::new(exec));
+        self
+    }
+    /// Set whether HTTP/0.9 responses should be tolerated.
+    ///
+    /// Default is false.
+    pub(crate) fn http09_responses(&mut self, enabled: bool) -> &mut Builder {
+        self.h09_responses = enabled;
+        self
+    }
+    /// Set whether HTTP/1 connections will accept spaces between header names
+    /// and the colon that follow them in responses.
+    ///
+    /// You probably don't need this, here is what [RFC 7230 Section 3.2.4.] has
+    /// to say about it:
+    ///
+    /// > No whitespace is allowed between the header field-name and colon. In
+    /// > the past, differences in the handling of such whitespace have led to
+    /// > security vulnerabilities in request routing and response handling. A
+    /// > server MUST reject any received request message that contains
+    /// > whitespace between a header field-name and colon with a response code
+    /// > of 400 (Bad Request). A proxy MUST remove any such whitespace from a
+    /// > response message before forwarding the message downstream.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    ///
+    /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
+    pub(crate) fn http1_allow_spaces_after_header_name_in_responses(
+        &mut self,
+        enabled: bool,
+    ) -> &mut Builder {
+        self.h1_parser_config.allow_spaces_after_header_name_in_responses(enabled);
+        self
+    }
+    /// Set whether HTTP/1 connections will accept obsolete line folding for
+    /// header values.
+    ///
+    /// Newline codepoints (`\r` and `\n`) will be transformed to spaces when
+    /// parsing.
+    ///
+    /// You probably don't need this, here is what [RFC 7230 Section 3.2.4.] has
+    /// to say about it:
+    ///
+    /// > A server that receives an obs-fold in a request message that is not
+    /// > within a message/http container MUST either reject the message by
+    /// > sending a 400 (Bad Request), preferably with a representation
+    /// > explaining that obsolete line folding is unacceptable, or replace
+    /// > each received obs-fold with one or more SP octets prior to
+    /// > interpreting the field value or forwarding the message downstream.
+    ///
+    /// > A proxy or gateway that receives an obs-fold in a response message
+    /// > that is not within a message/http container MUST either discard the
+    /// > message and replace it with a 502 (Bad Gateway) response, preferably
+    /// > with a representation explaining that unacceptable line folding was
+    /// > received, or replace each received obs-fold with one or more SP
+    /// > octets prior to interpreting the field value or forwarding the
+    /// > message downstream.
+    ///
+    /// > A user agent that receives an obs-fold in a response message that is
+    /// > not within a message/http container MUST replace each received
+    /// > obs-fold with one or more SP octets prior to interpreting the field
+    /// > value.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    ///
+    /// [RFC 7230 Section 3.2.4.]: https://tools.ietf.org/html/rfc7230#section-3.2.4
+    pub(crate) fn http1_allow_obsolete_multiline_headers_in_responses(
+        &mut self,
+        enabled: bool,
+    ) -> &mut Builder {
+        self.h1_parser_config.allow_obsolete_multiline_headers_in_responses(enabled);
+        self
+    }
+    /// Set whether HTTP/1 connections will silently ignored malformed header lines.
+    ///
+    /// If this is enabled and and a header line does not start with a valid header
+    /// name, or does not include a colon at all, the line will be silently ignored
+    /// and no error will be reported.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    pub(crate) fn http1_ignore_invalid_headers_in_responses(
+        &mut self,
+        enabled: bool,
+    ) -> &mut Builder {
+        self.h1_parser_config.ignore_invalid_headers_in_responses(enabled);
+        self
+    }
+    /// Set whether HTTP/1 connections should try to use vectored writes,
+    /// or always flatten into a single buffer.
+    ///
+    /// Note that setting this to false may mean more copies of body data,
+    /// but may also improve performance when an IO transport doesn't
+    /// support vectored writes well, such as most TLS implementations.
+    ///
+    /// Setting this to true will force hyper to use queued strategy
+    /// which may eliminate unnecessary cloning on some TLS backends
+    ///
+    /// Default is `auto`. In this mode hyper will try to guess which
+    /// mode to use
+    pub(crate) fn http1_writev(&mut self, enabled: bool) -> &mut Builder {
+        self.h1_writev = Some(enabled);
+        self
+    }
+    /// Set whether HTTP/1 connections will write header names as title case at
+    /// the socket level.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    pub(crate) fn http1_title_case_headers(&mut self, enabled: bool) -> &mut Builder {
+        self.h1_title_case_headers = enabled;
+        self
+    }
+    /// Set whether to support preserving original header cases.
+    ///
+    /// Currently, this will record the original cases received, and store them
+    /// in a private extension on the `Response`. It will also look for and use
+    /// such an extension in any provided `Request`.
+    ///
+    /// Since the relevant extension is still private, there is no way to
+    /// interact with the original cases. The only effect this can have now is
+    /// to forward the cases in a proxy-like fashion.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    pub(crate) fn http1_preserve_header_case(&mut self, enabled: bool) -> &mut Builder {
+        self.h1_preserve_header_case = enabled;
+        self
+    }
+    /// Set whether to support preserving original header order.
+    ///
+    /// Currently, this will record the order in which headers are received, and store this
+    /// ordering in a private extension on the `Response`. It will also look for and use
+    /// such an extension in any provided `Request`.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    #[cfg(feature = "ffi")]
+    pub(crate) fn http1_preserve_header_order(&mut self, enabled: bool) -> &mut Builder {
+        self.h1_preserve_header_order = enabled;
+        self
+    }
+    /// Sets the exact size of the read buffer to *always* use.
+    ///
+    /// Note that setting this option unsets the `http1_max_buf_size` option.
+    ///
+    /// Default is an adaptive read buffer.
+    pub(crate) fn http1_read_buf_exact_size(
+        &mut self,
+        sz: Option<usize>,
+    ) -> &mut Builder {
+        self.h1_read_buf_exact_size = sz;
+        self.h1_max_buf_size = None;
+        self
+    }
+    /// Set the maximum buffer size for the connection.
+    ///
+    /// Default is ~400kb.
+    ///
+    /// Note that setting this option unsets the `http1_read_exact_buf_size` option.
+    ///
+    /// # Panics
+    ///
+    /// The minimum value allowed is 8192. This method panics if the passed `max` is less than the minimum.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_max_buf_size(&mut self, max: usize) -> &mut Self {
+        assert!(
+            max >= proto::h1::MINIMUM_MAX_BUFFER_SIZE,
+            "the max_buf_size cannot be smaller than the minimum that h1 specifies."
+        );
+        self.h1_max_buf_size = Some(max);
+        self.h1_read_buf_exact_size = None;
+        self
+    }
+    #[cfg(feature = "ffi")]
+    pub(crate) fn http1_headers_raw(&mut self, enabled: bool) -> &mut Self {
+        self.h1_headers_raw = enabled;
+        self
+    }
+    /// Sets whether HTTP2 is required.
+    ///
+    /// Default is false.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_only(&mut self, enabled: bool) -> &mut Builder {
+        if enabled {
+            self.version = Proto::Http2;
+        }
+        self
+    }
+    /// Sets the [`SETTINGS_INITIAL_WINDOW_SIZE`][spec] option for HTTP2
+    /// stream-level flow control.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    ///
+    /// [spec]: https://http2.github.io/http2-spec/#SETTINGS_INITIAL_WINDOW_SIZE
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_stream_window_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        if let Some(sz) = sz.into() {
+            self.h2_builder.adaptive_window = false;
+            self.h2_builder.initial_stream_window_size = sz;
+        }
+        self
+    }
+    /// Sets the max connection-level flow control for HTTP2
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_connection_window_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        if let Some(sz) = sz.into() {
+            self.h2_builder.adaptive_window = false;
+            self.h2_builder.initial_conn_window_size = sz;
+        }
+        self
+    }
+    /// Sets whether to use an adaptive flow control.
+    ///
+    /// Enabling this will override the limits set in
+    /// `http2_initial_stream_window_size` and
+    /// `http2_initial_connection_window_size`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_adaptive_window(&mut self, enabled: bool) -> &mut Self {
+        use proto::h2::SPEC_WINDOW_SIZE;
+        self.h2_builder.adaptive_window = enabled;
+        if enabled {
+            self.h2_builder.initial_conn_window_size = SPEC_WINDOW_SIZE;
+            self.h2_builder.initial_stream_window_size = SPEC_WINDOW_SIZE;
+        }
+        self
+    }
+    /// Sets the maximum frame size to use for HTTP2.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_frame_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        if let Some(sz) = sz.into() {
+            self.h2_builder.max_frame_size = sz;
+        }
+        self
+    }
+    /// Sets an interval for HTTP2 Ping frames should be sent to keep a
+    /// connection alive.
+    ///
+    /// Pass `None` to disable HTTP2 keep-alive.
+    ///
+    /// Default is currently disabled.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_interval(
+        &mut self,
+        interval: impl Into<Option<Duration>>,
+    ) -> &mut Self {
+        self.h2_builder.keep_alive_interval = interval.into();
+        self
+    }
+    /// Sets a timeout for receiving an acknowledgement of the keep-alive ping.
+    ///
+    /// If the ping is not acknowledged within the timeout, the connection will
+    /// be closed. Does nothing if `http2_keep_alive_interval` is disabled.
+    ///
+    /// Default is 20 seconds.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
+        self.h2_builder.keep_alive_timeout = timeout;
+        self
+    }
+    /// Sets whether HTTP2 keep-alive should apply while the connection is idle.
+    ///
+    /// If disabled, keep-alive pings are only sent while there are open
+    /// request/responses streams. If enabled, pings are also sent when no
+    /// streams are active. Does nothing if `http2_keep_alive_interval` is
+    /// disabled.
+    ///
+    /// Default is `false`.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_while_idle(&mut self, enabled: bool) -> &mut Self {
+        self.h2_builder.keep_alive_while_idle = enabled;
+        self
+    }
+    /// Sets the maximum number of HTTP2 concurrent locally reset streams.
+    ///
+    /// See the documentation of [`h2::client::Builder::max_concurrent_reset_streams`] for more
+    /// details.
+    ///
+    /// The default value is determined by the `h2` crate.
+    ///
+    /// [`h2::client::Builder::max_concurrent_reset_streams`]: https://docs.rs/h2/client/struct.Builder.html#method.max_concurrent_reset_streams
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_concurrent_reset_streams(
+        &mut self,
+        max: usize,
+    ) -> &mut Self {
+        self.h2_builder.max_concurrent_reset_streams = Some(max);
+        self
+    }
+    /// Set the maximum write buffer size for each HTTP/2 stream.
+    ///
+    /// Default is currently 1MB, but may change.
+    ///
+    /// # Panics
+    ///
+    /// The value must be no larger than `u32::MAX`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_send_buf_size(&mut self, max: usize) -> &mut Self {
+        assert!(max <= std::u32::MAX as usize);
+        self.h2_builder.max_send_buffer_size = max;
+        self
+    }
+    /// Constructs a connection with the configured options and IO.
+    /// See [`client::conn`](crate::client::conn) for more.
+    ///
+    /// Note, if [`Connection`] is not `await`-ed, [`SendRequest`] will
+    /// do nothing.
+    pub(crate) fn handshake<T, B>(
+        &self,
+        io: T,
+    ) -> impl Future<Output = crate::Result<(SendRequest<B>, Connection<T, B>)>>
+    where
+        T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+        B: HttpBody + 'static,
+        B::Data: Send,
+        B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        let opts = self.clone();
+        async move {
+            trace!("client handshake {:?}", opts.version);
+            let (tx, rx) = dispatch::channel();
+            let proto = match opts.version {
+                #[cfg(feature = "http1")]
+                Proto::Http1 => {
+                    let mut conn = proto::Conn::new(io);
+                    conn.set_h1_parser_config(opts.h1_parser_config);
+                    if let Some(writev) = opts.h1_writev {
+                        if writev {
+                            conn.set_write_strategy_queue();
+                        } else {
+                            conn.set_write_strategy_flatten();
+                        }
+                    }
+                    if opts.h1_title_case_headers {
+                        conn.set_title_case_headers();
+                    }
+                    if opts.h1_preserve_header_case {
+                        conn.set_preserve_header_case();
+                    }
+                    #[cfg(feature = "ffi")]
+                    if opts.h1_preserve_header_order {
+                        conn.set_preserve_header_order();
+                    }
+                    if opts.h09_responses {
+                        conn.set_h09_responses();
+                    }
+                    #[cfg(feature = "ffi")] conn.set_raw_headers(opts.h1_headers_raw);
+                    if let Some(sz) = opts.h1_read_buf_exact_size {
+                        conn.set_read_buf_exact_size(sz);
+                    }
+                    if let Some(max) = opts.h1_max_buf_size {
+                        conn.set_max_buf_size(max);
+                    }
+                    let cd = proto::h1::dispatch::Client::new(rx);
+                    let dispatch = proto::h1::Dispatcher::new(cd, conn);
+                    ProtoClient::H1 { h1: dispatch }
+                }
+                #[cfg(feature = "http2")]
+                Proto::Http2 => {
+                    let h2 = proto::h2::client::handshake(
+                            io,
+                            rx,
+                            &opts.h2_builder,
+                            opts.exec.clone(),
+                        )
+                        .await?;
+                    ProtoClient::H2 { h2 }
+                }
+            };
+            Ok((SendRequest { dispatch: tx }, Connection { inner: Some(proto) }))
+        }
+    }
+}
+impl Future for ResponseFuture {
+    type Output = crate::Result<Response<Body>>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        match self.inner {
+            ResponseFutureState::Waiting(ref mut rx) => {
+                Pin::new(rx)
+                    .poll(cx)
+                    .map(|res| match res {
+                        Ok(Ok(resp)) => Ok(resp),
+                        Ok(Err(err)) => Err(err),
+                        Err(_canceled) => {
+                            panic!("dispatch dropped without returning error")
+                        }
+                    })
+            }
+            ResponseFutureState::Error(ref mut err) => {
+                Poll::Ready(Err(err.take().expect("polled after ready")))
+            }
+        }
+    }
+}
+impl fmt::Debug for ResponseFuture {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ResponseFuture").finish()
+    }
+}
+impl<T, B> Future for ProtoClient<T, B>
+where
+    T: AsyncRead + AsyncWrite + Send + Unpin + 'static,
+    B: HttpBody + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Output = crate::Result<proto::Dispatched>;
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        match self.project() {
+            #[cfg(feature = "http1")]
+            ProtoClientProj::H1 { h1 } => h1.poll(cx),
+            #[cfg(feature = "http2")]
+            ProtoClientProj::H2 { h2, .. } => h2.poll(cx),
+            #[cfg(not(feature = "http1"))]
+            ProtoClientProj::H1 { h1 } => match h1.0 {}
+            #[cfg(not(feature = "http2"))]
+            ProtoClientProj::H2 { h2, .. } => match h2.0 {}
+        }
+    }
+}
+trait AssertSend: Send {}
+trait AssertSendSync: Send + Sync {}
+#[doc(hidden)]
+impl<B: Send> AssertSendSync for SendRequest<B> {}
+#[doc(hidden)]
+impl<T: Send, B: Send> AssertSend for Connection<T, B>
+where
+    T: AsyncRead + AsyncWrite + Send + 'static,
+    B: HttpBody + 'static,
+    B::Data: Send,
+{}
+#[doc(hidden)]
+impl<T: Send + Sync, B: Send + Sync> AssertSendSync for Connection<T, B>
+where
+    T: AsyncRead + AsyncWrite + Send + 'static,
+    B: HttpBody + 'static,
+    B::Data: Send + Sync + 'static,
+{}
+#[doc(hidden)]
+impl AssertSendSync for Builder {}
+#[doc(hidden)]
+impl AssertSend for ResponseFuture {}
diff --git a/hyper/src/client/connect/dns.rs b/hyper/src/client/connect/dns.rs
new file mode 100644
index 0000000..f4d2a53
--- /dev/null
+++ b/hyper/src/client/connect/dns.rs
@@ -0,0 +1,323 @@
+//! DNS Resolution used by the `HttpConnector`.
+//!
+//! This module contains:
+//!
+//! - A [`GaiResolver`](GaiResolver) that is the default resolver for the
+//!   `HttpConnector`.
+//! - The `Name` type used as an argument to custom resolvers.
+//!
+//! # Resolvers are `Service`s
+//!
+//! A resolver is just a
+//! `Service<Name, Response = impl Iterator<Item = SocketAddr>>`.
+//!
+//! A simple resolver that ignores the name and always returns a specific
+//! address:
+//!
+//! ```rust,ignore
+//! use std::{convert::Infallible, iter, net::SocketAddr};
+//!
+//! let resolver = tower::service_fn(|_name| async {
+//!     Ok::<_, Infallible>(iter::once(SocketAddr::from(([127, 0, 0, 1], 8080))))
+//! });
+//! ```
+use std::error::Error;
+use std::future::Future;
+use std::net::{
+    Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs,
+};
+use std::pin::Pin;
+use std::str::FromStr;
+use std::task::{self, Poll};
+use std::{fmt, io, vec};
+use tokio::task::JoinHandle;
+use tower_service::Service;
+use tracing::debug;
+pub(super) use self::sealed::Resolve;
+/// A domain name to resolve into IP addresses.
+#[derive(Clone, Hash, Eq, PartialEq)]
+pub struct Name {
+    host: Box<str>,
+}
+/// A resolver using blocking `getaddrinfo` calls in a threadpool.
+#[derive(Clone)]
+pub struct GaiResolver {
+    _priv: (),
+}
+/// An iterator of IP addresses returned from `getaddrinfo`.
+pub struct GaiAddrs {
+    inner: SocketAddrs,
+}
+/// A future to resolve a name returned by `GaiResolver`.
+pub struct GaiFuture {
+    inner: JoinHandle<Result<SocketAddrs, io::Error>>,
+}
+impl Name {
+    pub(super) fn new(host: Box<str>) -> Name {
+        Name { host }
+    }
+    /// View the hostname as a string slice.
+    pub(crate) fn as_str(&self) -> &str {
+        &self.host
+    }
+}
+impl fmt::Debug for Name {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.host, f)
+    }
+}
+impl fmt::Display for Name {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.host, f)
+    }
+}
+impl FromStr for Name {
+    type Err = InvalidNameError;
+    fn from_str(host: &str) -> Result<Self, Self::Err> {
+        Ok(Name::new(host.into()))
+    }
+}
+/// Error indicating a given string was not a valid domain name.
+#[derive(Debug)]
+pub struct InvalidNameError(());
+impl fmt::Display for InvalidNameError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("Not a valid domain name")
+    }
+}
+impl Error for InvalidNameError {}
+impl GaiResolver {
+    /// Construct a new `GaiResolver`.
+    pub(crate) fn new() -> Self {
+        GaiResolver { _priv: () }
+    }
+}
+impl Service<Name> for GaiResolver {
+    type Response = GaiAddrs;
+    type Error = io::Error;
+    type Future = GaiFuture;
+    fn poll_ready(
+        &mut self,
+        _cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, name: Name) -> Self::Future {
+        let blocking = tokio::task::spawn_blocking(move || {
+            debug!("resolving host={:?}", name.host);
+            (&*name.host, 0).to_socket_addrs().map(|i| SocketAddrs { iter: i })
+        });
+        GaiFuture { inner: blocking }
+    }
+}
+impl fmt::Debug for GaiResolver {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("GaiResolver")
+    }
+}
+impl Future for GaiFuture {
+    type Output = Result<GaiAddrs, io::Error>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.inner)
+            .poll(cx)
+            .map(|res| match res {
+                Ok(Ok(addrs)) => Ok(GaiAddrs { inner: addrs }),
+                Ok(Err(err)) => Err(err),
+                Err(join_err) => {
+                    if join_err.is_cancelled() {
+                        Err(io::Error::new(io::ErrorKind::Interrupted, join_err))
+                    } else {
+                        panic!("gai background task failed: {:?}", join_err)
+                    }
+                }
+            })
+    }
+}
+impl fmt::Debug for GaiFuture {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("GaiFuture")
+    }
+}
+impl Drop for GaiFuture {
+    fn drop(&mut self) {
+        self.inner.abort();
+    }
+}
+impl Iterator for GaiAddrs {
+    type Item = SocketAddr;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+}
+impl fmt::Debug for GaiAddrs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("GaiAddrs")
+    }
+}
+pub(super) struct SocketAddrs {
+    iter: vec::IntoIter<SocketAddr>,
+}
+impl SocketAddrs {
+    pub(super) fn new(addrs: Vec<SocketAddr>) -> Self {
+        SocketAddrs {
+            iter: addrs.into_iter(),
+        }
+    }
+    pub(super) fn try_parse(host: &str, port: u16) -> Option<SocketAddrs> {
+        if let Ok(addr) = host.parse::<Ipv4Addr>() {
+            let addr = SocketAddrV4::new(addr, port);
+            return Some(SocketAddrs {
+                iter: vec![SocketAddr::V4(addr)].into_iter(),
+            });
+        }
+        if let Ok(addr) = host.parse::<Ipv6Addr>() {
+            let addr = SocketAddrV6::new(addr, port, 0, 0);
+            return Some(SocketAddrs {
+                iter: vec![SocketAddr::V6(addr)].into_iter(),
+            });
+        }
+        None
+    }
+    #[inline]
+    fn filter(self, predicate: impl FnMut(&SocketAddr) -> bool) -> SocketAddrs {
+        SocketAddrs::new(self.iter.filter(predicate).collect())
+    }
+    pub(super) fn split_by_preference(
+        self,
+        local_addr_ipv4: Option<Ipv4Addr>,
+        local_addr_ipv6: Option<Ipv6Addr>,
+    ) -> (SocketAddrs, SocketAddrs) {
+        match (local_addr_ipv4, local_addr_ipv6) {
+            (Some(_), None) => {
+                (self.filter(SocketAddr::is_ipv4), SocketAddrs::new(vec![]))
+            }
+            (None, Some(_)) => {
+                (self.filter(SocketAddr::is_ipv6), SocketAddrs::new(vec![]))
+            }
+            _ => {
+                let preferring_v6 = self
+                    .iter
+                    .as_slice()
+                    .first()
+                    .map(SocketAddr::is_ipv6)
+                    .unwrap_or(false);
+                let (preferred, fallback) = self
+                    .iter
+                    .partition::<Vec<_>, _>(|addr| addr.is_ipv6() == preferring_v6);
+                (SocketAddrs::new(preferred), SocketAddrs::new(fallback))
+            }
+        }
+    }
+    pub(super) fn is_empty(&self) -> bool {
+        self.iter.as_slice().is_empty()
+    }
+    pub(super) fn len(&self) -> usize {
+        self.iter.as_slice().len()
+    }
+}
+impl Iterator for SocketAddrs {
+    type Item = SocketAddr;
+    #[inline]
+    fn next(&mut self) -> Option<SocketAddr> {
+        self.iter.next()
+    }
+}
+mod sealed {
+    use super::{SocketAddr, Name};
+    use crate::common::{task, Future, Poll};
+    use tower_service::Service;
+    pub trait Resolve {
+        type Addrs: Iterator<Item = SocketAddr>;
+        type Error: Into<Box<dyn std::error::Error + Send + Sync>>;
+        type Future: Future<Output = Result<Self::Addrs, Self::Error>>;
+        fn poll_ready(
+            &mut self,
+            cx: &mut task::Context<'_>,
+        ) -> Poll<Result<(), Self::Error>>;
+        fn resolve(&mut self, name: Name) -> Self::Future;
+    }
+    impl<S> Resolve for S
+    where
+        S: Service<Name>,
+        S::Response: Iterator<Item = SocketAddr>,
+        S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    {
+        type Addrs = S::Response;
+        type Error = S::Error;
+        type Future = S::Future;
+        fn poll_ready(
+            &mut self,
+            cx: &mut task::Context<'_>,
+        ) -> Poll<Result<(), Self::Error>> {
+            Service::poll_ready(self, cx)
+        }
+        fn resolve(&mut self, name: Name) -> Self::Future {
+            Service::call(self, name)
+        }
+    }
+}
+pub(super) async fn resolve<R>(
+    resolver: &mut R,
+    name: Name,
+) -> Result<R::Addrs, R::Error>
+where
+    R: Resolve,
+{
+    futures_util::future::poll_fn(|cx| resolver.poll_ready(cx)).await?;
+    resolver.resolve(name).await
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::net::{Ipv4Addr, Ipv6Addr};
+    #[test]
+    fn test_ip_addrs_split_by_preference() {
+        let ip_v4 = Ipv4Addr::new(127, 0, 0, 1);
+        let ip_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
+        let v4_addr = (ip_v4, 80).into();
+        let v6_addr = (ip_v6, 80).into();
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+            .split_by_preference(None, None);
+        assert!(preferred.next().unwrap().is_ipv4());
+        assert!(fallback.next().unwrap().is_ipv6());
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v6_addr, v4_addr].into_iter(),
+        }
+            .split_by_preference(None, None);
+        assert!(preferred.next().unwrap().is_ipv6());
+        assert!(fallback.next().unwrap().is_ipv4());
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+            .split_by_preference(Some(ip_v4), Some(ip_v6));
+        assert!(preferred.next().unwrap().is_ipv4());
+        assert!(fallback.next().unwrap().is_ipv6());
+        let (mut preferred, mut fallback) = SocketAddrs {
+            iter: vec![v6_addr, v4_addr].into_iter(),
+        }
+            .split_by_preference(Some(ip_v4), Some(ip_v6));
+        assert!(preferred.next().unwrap().is_ipv6());
+        assert!(fallback.next().unwrap().is_ipv4());
+        let (mut preferred, fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+            .split_by_preference(Some(ip_v4), None);
+        assert!(preferred.next().unwrap().is_ipv4());
+        assert!(fallback.is_empty());
+        let (mut preferred, fallback) = SocketAddrs {
+            iter: vec![v4_addr, v6_addr].into_iter(),
+        }
+            .split_by_preference(None, Some(ip_v6));
+        assert!(preferred.next().unwrap().is_ipv6());
+        assert!(fallback.is_empty());
+    }
+    #[test]
+    fn test_name_from_str() {
+        const DOMAIN: &str = "test.example.com";
+        let name = Name::from_str(DOMAIN).expect("Should be a valid domain");
+        assert_eq!(name.as_str(), DOMAIN);
+        assert_eq!(name.to_string(), DOMAIN);
+    }
+}
diff --git a/hyper/src/client/connect/http.rs b/hyper/src/client/connect/http.rs
new file mode 100644
index 0000000..a6aac0c
--- /dev/null
+++ b/hyper/src/client/connect/http.rs
@@ -0,0 +1,842 @@
+use std::error::Error as StdError;
+use std::fmt;
+use std::future::Future;
+use std::io;
+use std::marker::PhantomData;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{self, Poll};
+use std::time::Duration;
+use futures_util::future::Either;
+use http::uri::{Scheme, Uri};
+use pin_project_lite::pin_project;
+use tokio::net::{TcpSocket, TcpStream};
+use tokio::time::Sleep;
+use tracing::{debug, trace, warn};
+use super::dns::{self, resolve, GaiResolver, Resolve};
+use super::{Connected, Connection};
+/// A connector for the `http` scheme.
+///
+/// Performs DNS resolution in a thread pool, and then connects over TCP.
+///
+/// # Note
+///
+/// Sets the [`HttpInfo`](HttpInfo) value on responses, which includes
+/// transport information such as the remote socket address used.
+#[cfg_attr(docsrs, doc(cfg(feature = "tcp")))]
+#[derive(Clone)]
+pub struct HttpConnector<R = GaiResolver> {
+    config: Arc<Config>,
+    resolver: R,
+}
+/// Extra information about the transport when an HttpConnector is used.
+///
+/// # Example
+///
+/// ```
+/// # async fn doc() -> hyper::Result<()> {
+/// use hyper::Uri;
+/// use hyper::client::{Client, connect::HttpInfo};
+///
+/// let client = Client::new();
+/// let uri = Uri::from_static("http://example.com");
+///
+/// let res = client.get(uri).await?;
+/// res
+///     .extensions()
+///     .get::<HttpInfo>()
+///     .map(|info| {
+///         println!("remote addr = {}", info.remote_addr());
+///     });
+/// # Ok(())
+/// # }
+/// ```
+///
+/// # Note
+///
+/// If a different connector is used besides [`HttpConnector`](HttpConnector),
+/// this value will not exist in the extensions. Consult that specific
+/// connector to see what "extra" information it might provide to responses.
+#[derive(Clone, Debug)]
+pub struct HttpInfo {
+    remote_addr: SocketAddr,
+    local_addr: SocketAddr,
+}
+#[derive(Clone)]
+struct Config {
+    connect_timeout: Option<Duration>,
+    enforce_http: bool,
+    happy_eyeballs_timeout: Option<Duration>,
+    keep_alive_timeout: Option<Duration>,
+    local_address_ipv4: Option<Ipv4Addr>,
+    local_address_ipv6: Option<Ipv6Addr>,
+    nodelay: bool,
+    reuse_address: bool,
+    send_buffer_size: Option<usize>,
+    recv_buffer_size: Option<usize>,
+}
+impl HttpConnector {
+    /// Construct a new HttpConnector.
+    pub(crate) fn new() -> HttpConnector {
+        HttpConnector::new_with_resolver(GaiResolver::new())
+    }
+}
+impl<R> HttpConnector<R> {
+    /// Construct a new HttpConnector.
+    ///
+    /// Takes a [`Resolver`](crate::client::connect::dns#resolvers-are-services) to handle DNS lookups.
+    pub(crate) fn new_with_resolver(resolver: R) -> HttpConnector<R> {
+        HttpConnector {
+            config: Arc::new(Config {
+                connect_timeout: None,
+                enforce_http: true,
+                happy_eyeballs_timeout: Some(Duration::from_millis(300)),
+                keep_alive_timeout: None,
+                local_address_ipv4: None,
+                local_address_ipv6: None,
+                nodelay: false,
+                reuse_address: false,
+                send_buffer_size: None,
+                recv_buffer_size: None,
+            }),
+            resolver,
+        }
+    }
+    /// Option to enforce all `Uri`s have the `http` scheme.
+    ///
+    /// Enabled by default.
+    #[inline]
+    pub(crate) fn enforce_http(&mut self, is_enforced: bool) {
+        self.config_mut().enforce_http = is_enforced;
+    }
+    /// Set that all sockets have `SO_KEEPALIVE` set with the supplied duration.
+    ///
+    /// If `None`, the option will not be set.
+    ///
+    /// Default is `None`.
+    #[inline]
+    pub(crate) fn set_keepalive(&mut self, dur: Option<Duration>) {
+        self.config_mut().keep_alive_timeout = dur;
+    }
+    /// Set that all sockets have `SO_NODELAY` set to the supplied value `nodelay`.
+    ///
+    /// Default is `false`.
+    #[inline]
+    pub(crate) fn set_nodelay(&mut self, nodelay: bool) {
+        self.config_mut().nodelay = nodelay;
+    }
+    /// Sets the value of the SO_SNDBUF option on the socket.
+    #[inline]
+    pub(crate) fn set_send_buffer_size(&mut self, size: Option<usize>) {
+        self.config_mut().send_buffer_size = size;
+    }
+    /// Sets the value of the SO_RCVBUF option on the socket.
+    #[inline]
+    pub(crate) fn set_recv_buffer_size(&mut self, size: Option<usize>) {
+        self.config_mut().recv_buffer_size = size;
+    }
+    /// Set that all sockets are bound to the configured address before connection.
+    ///
+    /// If `None`, the sockets will not be bound.
+    ///
+    /// Default is `None`.
+    #[inline]
+    pub(crate) fn set_local_address(&mut self, addr: Option<IpAddr>) {
+        let (v4, v6) = match addr {
+            Some(IpAddr::V4(a)) => (Some(a), None),
+            Some(IpAddr::V6(a)) => (None, Some(a)),
+            _ => (None, None),
+        };
+        let cfg = self.config_mut();
+        cfg.local_address_ipv4 = v4;
+        cfg.local_address_ipv6 = v6;
+    }
+    /// Set that all sockets are bound to the configured IPv4 or IPv6 address (depending on host's
+    /// preferences) before connection.
+    #[inline]
+    pub(crate) fn set_local_addresses(
+        &mut self,
+        addr_ipv4: Ipv4Addr,
+        addr_ipv6: Ipv6Addr,
+    ) {
+        let cfg = self.config_mut();
+        cfg.local_address_ipv4 = Some(addr_ipv4);
+        cfg.local_address_ipv6 = Some(addr_ipv6);
+    }
+    /// Set the connect timeout.
+    ///
+    /// If a domain resolves to multiple IP addresses, the timeout will be
+    /// evenly divided across them.
+    ///
+    /// Default is `None`.
+    #[inline]
+    pub(crate) fn set_connect_timeout(&mut self, dur: Option<Duration>) {
+        self.config_mut().connect_timeout = dur;
+    }
+    /// Set timeout for [RFC 6555 (Happy Eyeballs)][RFC 6555] algorithm.
+    ///
+    /// If hostname resolves to both IPv4 and IPv6 addresses and connection
+    /// cannot be established using preferred address family before timeout
+    /// elapses, then connector will in parallel attempt connection using other
+    /// address family.
+    ///
+    /// If `None`, parallel connection attempts are disabled.
+    ///
+    /// Default is 300 milliseconds.
+    ///
+    /// [RFC 6555]: https://tools.ietf.org/html/rfc6555
+    #[inline]
+    pub(crate) fn set_happy_eyeballs_timeout(&mut self, dur: Option<Duration>) {
+        self.config_mut().happy_eyeballs_timeout = dur;
+    }
+    /// Set that all socket have `SO_REUSEADDR` set to the supplied value `reuse_address`.
+    ///
+    /// Default is `false`.
+    #[inline]
+    pub(crate) fn set_reuse_address(&mut self, reuse_address: bool) -> &mut Self {
+        self.config_mut().reuse_address = reuse_address;
+        self
+    }
+    fn config_mut(&mut self) -> &mut Config {
+        Arc::make_mut(&mut self.config)
+    }
+}
+static INVALID_NOT_HTTP: &str = "invalid URL, scheme is not http";
+static INVALID_MISSING_SCHEME: &str = "invalid URL, scheme is missing";
+static INVALID_MISSING_HOST: &str = "invalid URL, host is missing";
+impl<R: fmt::Debug> fmt::Debug for HttpConnector<R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("HttpConnector").finish()
+    }
+}
+impl<R> tower_service::Service<Uri> for HttpConnector<R>
+where
+    R: Resolve + Clone + Send + Sync + 'static,
+    R::Future: Send,
+{
+    type Response = TcpStream;
+    type Error = ConnectError;
+    type Future = HttpConnecting<R>;
+    fn poll_ready(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        ready!(self.resolver.poll_ready(cx)).map_err(ConnectError::dns)?;
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, dst: Uri) -> Self::Future {
+        let mut self_ = self.clone();
+        HttpConnecting {
+            fut: Box::pin(async move { self_.call_async(dst).await }),
+            _marker: PhantomData,
+        }
+    }
+}
+fn get_host_port<'u>(
+    config: &Config,
+    dst: &'u Uri,
+) -> Result<(&'u str, u16), ConnectError> {
+    trace!(
+        "Http::connect; scheme={:?}, host={:?}, port={:?}", dst.scheme(), dst.host(), dst
+        .port(),
+    );
+    if config.enforce_http {
+        if dst.scheme() != Some(&Scheme::HTTP) {
+            return Err(ConnectError {
+                msg: INVALID_NOT_HTTP.into(),
+                cause: None,
+            });
+        }
+    } else if dst.scheme().is_none() {
+        return Err(ConnectError {
+            msg: INVALID_MISSING_SCHEME.into(),
+            cause: None,
+        });
+    }
+    let host = match dst.host() {
+        Some(s) => s,
+        None => {
+            return Err(ConnectError {
+                msg: INVALID_MISSING_HOST.into(),
+                cause: None,
+            });
+        }
+    };
+    let port = match dst.port() {
+        Some(port) => port.as_u16(),
+        None => if dst.scheme() == Some(&Scheme::HTTPS) { 443 } else { 80 }
+    };
+    Ok((host, port))
+}
+impl<R> HttpConnector<R>
+where
+    R: Resolve,
+{
+    async fn call_async(&mut self, dst: Uri) -> Result<TcpStream, ConnectError> {
+        let config = &self.config;
+        let (host, port) = get_host_port(config, &dst)?;
+        let host = host.trim_start_matches('[').trim_end_matches(']');
+        let addrs = if let Some(addrs) = dns::SocketAddrs::try_parse(host, port) {
+            addrs
+        } else {
+            let addrs = resolve(&mut self.resolver, dns::Name::new(host.into()))
+                .await
+                .map_err(ConnectError::dns)?;
+            let addrs = addrs
+                .map(|mut addr| {
+                    addr.set_port(port);
+                    addr
+                })
+                .collect();
+            dns::SocketAddrs::new(addrs)
+        };
+        let c = ConnectingTcp::new(addrs, config);
+        let sock = c.connect().await?;
+        if let Err(e) = sock.set_nodelay(config.nodelay) {
+            warn!("tcp set_nodelay error: {}", e);
+        }
+        Ok(sock)
+    }
+}
+impl Connection for TcpStream {
+    fn connected(&self) -> Connected {
+        let connected = Connected::new();
+        if let (Ok(remote_addr), Ok(local_addr))
+            = (self.peer_addr(), self.local_addr()) {
+            connected
+                .extra(HttpInfo {
+                    remote_addr,
+                    local_addr,
+                })
+        } else {
+            connected
+        }
+    }
+}
+impl HttpInfo {
+    /// Get the remote address of the transport used.
+    pub(crate) fn remote_addr(&self) -> SocketAddr {
+        self.remote_addr
+    }
+    /// Get the local address of the transport used.
+    pub(crate) fn local_addr(&self) -> SocketAddr {
+        self.local_addr
+    }
+}
+pin_project! {
+    #[must_use = "futures do nothing unless polled"]
+    #[allow(missing_debug_implementations)] pub struct HttpConnecting < R > { #[pin] fut
+    : BoxConnecting, _marker : PhantomData < R >, }
+}
+type ConnectResult = Result<TcpStream, ConnectError>;
+type BoxConnecting = Pin<Box<dyn Future<Output = ConnectResult> + Send>>;
+impl<R: Resolve> Future for HttpConnecting<R> {
+    type Output = ConnectResult;
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        self.project().fut.poll(cx)
+    }
+}
+pub struct ConnectError {
+    msg: Box<str>,
+    cause: Option<Box<dyn StdError + Send + Sync>>,
+}
+impl ConnectError {
+    fn new<S, E>(msg: S, cause: E) -> ConnectError
+    where
+        S: Into<Box<str>>,
+        E: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        ConnectError {
+            msg: msg.into(),
+            cause: Some(cause.into()),
+        }
+    }
+    fn dns<E>(cause: E) -> ConnectError
+    where
+        E: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        ConnectError::new("dns error", cause)
+    }
+    fn m<S, E>(msg: S) -> impl FnOnce(E) -> ConnectError
+    where
+        S: Into<Box<str>>,
+        E: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        move |cause| ConnectError::new(msg, cause)
+    }
+}
+impl fmt::Debug for ConnectError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(ref cause) = self.cause {
+            f.debug_tuple("ConnectError").field(&self.msg).field(cause).finish()
+        } else {
+            self.msg.fmt(f)
+        }
+    }
+}
+impl fmt::Display for ConnectError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.msg)?;
+        if let Some(ref cause) = self.cause {
+            write!(f, ": {}", cause)?;
+        }
+        Ok(())
+    }
+}
+impl StdError for ConnectError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.cause.as_ref().map(|e| &**e as _)
+    }
+}
+struct ConnectingTcp<'a> {
+    preferred: ConnectingTcpRemote,
+    fallback: Option<ConnectingTcpFallback>,
+    config: &'a Config,
+}
+impl<'a> ConnectingTcp<'a> {
+    fn new(remote_addrs: dns::SocketAddrs, config: &'a Config) -> Self {
+        if let Some(fallback_timeout) = config.happy_eyeballs_timeout {
+            let (preferred_addrs, fallback_addrs) = remote_addrs
+                .split_by_preference(
+                    config.local_address_ipv4,
+                    config.local_address_ipv6,
+                );
+            if fallback_addrs.is_empty() {
+                return ConnectingTcp {
+                    preferred: ConnectingTcpRemote::new(
+                        preferred_addrs,
+                        config.connect_timeout,
+                    ),
+                    fallback: None,
+                    config,
+                };
+            }
+            ConnectingTcp {
+                preferred: ConnectingTcpRemote::new(
+                    preferred_addrs,
+                    config.connect_timeout,
+                ),
+                fallback: Some(ConnectingTcpFallback {
+                    delay: tokio::time::sleep(fallback_timeout),
+                    remote: ConnectingTcpRemote::new(
+                        fallback_addrs,
+                        config.connect_timeout,
+                    ),
+                }),
+                config,
+            }
+        } else {
+            ConnectingTcp {
+                preferred: ConnectingTcpRemote::new(
+                    remote_addrs,
+                    config.connect_timeout,
+                ),
+                fallback: None,
+                config,
+            }
+        }
+    }
+}
+struct ConnectingTcpFallback {
+    delay: Sleep,
+    remote: ConnectingTcpRemote,
+}
+struct ConnectingTcpRemote {
+    addrs: dns::SocketAddrs,
+    connect_timeout: Option<Duration>,
+}
+impl ConnectingTcpRemote {
+    fn new(addrs: dns::SocketAddrs, connect_timeout: Option<Duration>) -> Self {
+        let connect_timeout = connect_timeout.map(|t| t / (addrs.len() as u32));
+        Self { addrs, connect_timeout }
+    }
+}
+impl ConnectingTcpRemote {
+    async fn connect(&mut self, config: &Config) -> Result<TcpStream, ConnectError> {
+        let mut err = None;
+        for addr in &mut self.addrs {
+            debug!("connecting to {}", addr);
+            match connect(&addr, config, self.connect_timeout)?.await {
+                Ok(tcp) => {
+                    debug!("connected to {}", addr);
+                    return Ok(tcp);
+                }
+                Err(e) => {
+                    trace!("connect error for {}: {:?}", addr, e);
+                    err = Some(e);
+                }
+            }
+        }
+        match err {
+            Some(e) => Err(e),
+            None => {
+                Err(
+                    ConnectError::new(
+                        "tcp connect error",
+                        std::io::Error::new(
+                            std::io::ErrorKind::NotConnected,
+                            "Network unreachable",
+                        ),
+                    ),
+                )
+            }
+        }
+    }
+}
+fn bind_local_address(
+    socket: &socket2::Socket,
+    dst_addr: &SocketAddr,
+    local_addr_ipv4: &Option<Ipv4Addr>,
+    local_addr_ipv6: &Option<Ipv6Addr>,
+) -> io::Result<()> {
+    match (*dst_addr, local_addr_ipv4, local_addr_ipv6) {
+        (SocketAddr::V4(_), Some(addr), _) => {
+            socket.bind(&SocketAddr::new(addr.clone().into(), 0).into())?;
+        }
+        (SocketAddr::V6(_), _, Some(addr)) => {
+            socket.bind(&SocketAddr::new(addr.clone().into(), 0).into())?;
+        }
+        _ => {
+            if cfg!(windows) {
+                let any: SocketAddr = match *dst_addr {
+                    SocketAddr::V4(_) => ([0, 0, 0, 0], 0).into(),
+                    SocketAddr::V6(_) => ([0, 0, 0, 0, 0, 0, 0, 0], 0).into(),
+                };
+                socket.bind(&any.into())?;
+            }
+        }
+    }
+    Ok(())
+}
+fn connect(
+    addr: &SocketAddr,
+    config: &Config,
+    connect_timeout: Option<Duration>,
+) -> Result<impl Future<Output = Result<TcpStream, ConnectError>>, ConnectError> {
+    use socket2::{Domain, Protocol, Socket, TcpKeepalive, Type};
+    use std::convert::TryInto;
+    let domain = Domain::for_address(*addr);
+    let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))
+        .map_err(ConnectError::m("tcp open error"))?;
+    socket.set_nonblocking(true).map_err(ConnectError::m("tcp set_nonblocking error"))?;
+    if let Some(dur) = config.keep_alive_timeout {
+        let conf = TcpKeepalive::new().with_time(dur);
+        if let Err(e) = socket.set_tcp_keepalive(&conf) {
+            warn!("tcp set_keepalive error: {}", e);
+        }
+    }
+    bind_local_address(
+            &socket,
+            addr,
+            &config.local_address_ipv4,
+            &config.local_address_ipv6,
+        )
+        .map_err(ConnectError::m("tcp bind local error"))?;
+    #[cfg(unix)]
+    let socket = unsafe {
+        use std::os::unix::io::{FromRawFd, IntoRawFd};
+        TcpSocket::from_raw_fd(socket.into_raw_fd())
+    };
+    #[cfg(windows)]
+    let socket = unsafe {
+        use std::os::windows::io::{FromRawSocket, IntoRawSocket};
+        TcpSocket::from_raw_socket(socket.into_raw_socket())
+    };
+    if config.reuse_address {
+        if let Err(e) = socket.set_reuseaddr(true) {
+            warn!("tcp set_reuse_address error: {}", e);
+        }
+    }
+    if let Some(size) = config.send_buffer_size {
+        if let Err(e)
+            = socket.set_send_buffer_size(size.try_into().unwrap_or(std::u32::MAX))
+        {
+            warn!("tcp set_buffer_size error: {}", e);
+        }
+    }
+    if let Some(size) = config.recv_buffer_size {
+        if let Err(e)
+            = socket.set_recv_buffer_size(size.try_into().unwrap_or(std::u32::MAX))
+        {
+            warn!("tcp set_recv_buffer_size error: {}", e);
+        }
+    }
+    let connect = socket.connect(*addr);
+    Ok(async move {
+        match connect_timeout {
+            Some(dur) => {
+                match tokio::time::timeout(dur, connect).await {
+                    Ok(Ok(s)) => Ok(s),
+                    Ok(Err(e)) => Err(e),
+                    Err(e) => Err(io::Error::new(io::ErrorKind::TimedOut, e)),
+                }
+            }
+            None => connect.await,
+        }
+            .map_err(ConnectError::m("tcp connect error"))
+    })
+}
+impl ConnectingTcp<'_> {
+    async fn connect(mut self) -> Result<TcpStream, ConnectError> {
+        match self.fallback {
+            None => self.preferred.connect(self.config).await,
+            Some(mut fallback) => {
+                let preferred_fut = self.preferred.connect(self.config);
+                futures_util::pin_mut!(preferred_fut);
+                let fallback_fut = fallback.remote.connect(self.config);
+                futures_util::pin_mut!(fallback_fut);
+                let fallback_delay = fallback.delay;
+                futures_util::pin_mut!(fallback_delay);
+                let (result, future) = match futures_util::future::select(
+                        preferred_fut,
+                        fallback_delay,
+                    )
+                    .await
+                {
+                    Either::Left((result, _fallback_delay)) => {
+                        (result, Either::Right(fallback_fut))
+                    }
+                    Either::Right(((), preferred_fut)) => {
+                        futures_util::future::select(preferred_fut, fallback_fut)
+                            .await
+                            .factor_first()
+                    }
+                };
+                if result.is_err() { future.await } else { result }
+            }
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use std::io;
+    use ::http::Uri;
+    use super::super::sealed::{Connect, ConnectSvc};
+    use super::{Config, ConnectError, HttpConnector};
+    async fn connect<C>(
+        connector: C,
+        dst: Uri,
+    ) -> Result<<C::_Svc as ConnectSvc>::Connection, <C::_Svc as ConnectSvc>::Error>
+    where
+        C: Connect,
+    {
+        connector.connect(super::super::sealed::Internal, dst).await
+    }
+    #[tokio::test]
+    async fn test_errors_enforce_http() {
+        let dst = "https://example.domain/foo/bar?baz".parse().unwrap();
+        let connector = HttpConnector::new();
+        let err = connect(connector, dst).await.unwrap_err();
+        assert_eq!(&* err.msg, super::INVALID_NOT_HTTP);
+    }
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    fn get_local_ips() -> (Option<std::net::Ipv4Addr>, Option<std::net::Ipv6Addr>) {
+        use std::net::{IpAddr, TcpListener};
+        let mut ip_v4 = None;
+        let mut ip_v6 = None;
+        let ips = pnet_datalink::interfaces()
+            .into_iter()
+            .flat_map(|i| i.ips.into_iter().map(|n| n.ip()));
+        for ip in ips {
+            match ip {
+                IpAddr::V4(ip) if TcpListener::bind((ip, 0)).is_ok() => ip_v4 = Some(ip),
+                IpAddr::V6(ip) if TcpListener::bind((ip, 0)).is_ok() => ip_v6 = Some(ip),
+                _ => {}
+            }
+            if ip_v4.is_some() && ip_v6.is_some() {
+                break;
+            }
+        }
+        (ip_v4, ip_v6)
+    }
+    #[tokio::test]
+    async fn test_errors_missing_scheme() {
+        let dst = "example.domain".parse().unwrap();
+        let mut connector = HttpConnector::new();
+        connector.enforce_http(false);
+        let err = connect(connector, dst).await.unwrap_err();
+        assert_eq!(&* err.msg, super::INVALID_MISSING_SCHEME);
+    }
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    #[tokio::test]
+    async fn local_address() {
+        use std::net::{IpAddr, TcpListener};
+        let _ = pretty_env_logger::try_init();
+        let (bind_ip_v4, bind_ip_v6) = get_local_ips();
+        let server4 = TcpListener::bind("127.0.0.1:0").unwrap();
+        let port = server4.local_addr().unwrap().port();
+        let server6 = TcpListener::bind(&format!("[::1]:{}", port)).unwrap();
+        let assert_client_ip = |dst: String, server: TcpListener, expected_ip: IpAddr| async move {
+            let mut connector = HttpConnector::new();
+            match (bind_ip_v4, bind_ip_v6) {
+                (Some(v4), Some(v6)) => connector.set_local_addresses(v4, v6),
+                (Some(v4), None) => connector.set_local_address(Some(v4.into())),
+                (None, Some(v6)) => connector.set_local_address(Some(v6.into())),
+                _ => unreachable!(),
+            }
+            connect(connector, dst.parse().unwrap()).await.unwrap();
+            let (_, client_addr) = server.accept().unwrap();
+            assert_eq!(client_addr.ip(), expected_ip);
+        };
+        if let Some(ip) = bind_ip_v4 {
+            assert_client_ip(format!("http://127.0.0.1:{}", port), server4, ip.into())
+                .await;
+        }
+        if let Some(ip) = bind_ip_v6 {
+            assert_client_ip(format!("http://[::1]:{}", port), server6, ip.into()).await;
+        }
+    }
+    #[test]
+    #[cfg_attr(not(feature = "__internal_happy_eyeballs_tests"), ignore)]
+    fn client_happy_eyeballs() {
+        use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, TcpListener};
+        use std::time::{Duration, Instant};
+        use super::dns;
+        use super::ConnectingTcp;
+        let _ = pretty_env_logger::try_init();
+        let server4 = TcpListener::bind("127.0.0.1:0").unwrap();
+        let addr = server4.local_addr().unwrap();
+        let _server6 = TcpListener::bind(&format!("[::1]:{}", addr.port())).unwrap();
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        let local_timeout = Duration::default();
+        let unreachable_v4_timeout = measure_connect(unreachable_ipv4_addr()).1;
+        let unreachable_v6_timeout = measure_connect(unreachable_ipv6_addr()).1;
+        let fallback_timeout = std::cmp::max(
+            unreachable_v4_timeout,
+            unreachable_v6_timeout,
+        ) + Duration::from_millis(250);
+        let scenarios = &[
+            (&[local_ipv4_addr()][..], 4, local_timeout, false),
+            (&[local_ipv6_addr()][..], 6, local_timeout, false),
+            (&[local_ipv4_addr(), local_ipv6_addr()][..], 4, local_timeout, false),
+            (&[local_ipv6_addr(), local_ipv4_addr()][..], 6, local_timeout, false),
+            (
+                &[unreachable_ipv4_addr(), local_ipv4_addr()][..],
+                4,
+                unreachable_v4_timeout,
+                false,
+            ),
+            (
+                &[unreachable_ipv6_addr(), local_ipv6_addr()][..],
+                6,
+                unreachable_v6_timeout,
+                false,
+            ),
+            (
+                &[unreachable_ipv4_addr(), local_ipv4_addr(), local_ipv6_addr()][..],
+                4,
+                unreachable_v4_timeout,
+                false,
+            ),
+            (
+                &[unreachable_ipv6_addr(), local_ipv6_addr(), local_ipv4_addr()][..],
+                6,
+                unreachable_v6_timeout,
+                true,
+            ),
+            (
+                &[slow_ipv4_addr(), local_ipv4_addr(), local_ipv6_addr()][..],
+                6,
+                fallback_timeout,
+                false,
+            ),
+            (
+                &[slow_ipv6_addr(), local_ipv6_addr(), local_ipv4_addr()][..],
+                4,
+                fallback_timeout,
+                true,
+            ),
+            (
+                &[slow_ipv4_addr(), unreachable_ipv6_addr(), local_ipv6_addr()][..],
+                6,
+                fallback_timeout + unreachable_v6_timeout,
+                false,
+            ),
+            (
+                &[slow_ipv6_addr(), unreachable_ipv4_addr(), local_ipv4_addr()][..],
+                4,
+                fallback_timeout + unreachable_v4_timeout,
+                true,
+            ),
+        ];
+        let ipv6_accessible = measure_connect(slow_ipv6_addr()).0;
+        for &(hosts, family, timeout, needs_ipv6_access) in scenarios {
+            if needs_ipv6_access && !ipv6_accessible {
+                continue;
+            }
+            let (start, stream) = rt
+                .block_on(async move {
+                    let addrs = hosts
+                        .iter()
+                        .map(|host| (host.clone(), addr.port()).into())
+                        .collect();
+                    let cfg = Config {
+                        local_address_ipv4: None,
+                        local_address_ipv6: None,
+                        connect_timeout: None,
+                        keep_alive_timeout: None,
+                        happy_eyeballs_timeout: Some(fallback_timeout),
+                        nodelay: false,
+                        reuse_address: false,
+                        enforce_http: false,
+                        send_buffer_size: None,
+                        recv_buffer_size: None,
+                    };
+                    let connecting_tcp = ConnectingTcp::new(
+                        dns::SocketAddrs::new(addrs),
+                        &cfg,
+                    );
+                    let start = Instant::now();
+                    Ok::<
+                        _,
+                        ConnectError,
+                    >((start, ConnectingTcp::connect(connecting_tcp).await?))
+                })
+                .unwrap();
+            let res = if stream.peer_addr().unwrap().is_ipv4() { 4 } else { 6 };
+            let duration = start.elapsed();
+            let min_duration = if timeout >= Duration::from_millis(150) {
+                timeout - Duration::from_millis(150)
+            } else {
+                Duration::default()
+            };
+            let max_duration = timeout + Duration::from_millis(150);
+            assert_eq!(res, family);
+            assert!(duration >= min_duration);
+            assert!(duration <= max_duration);
+        }
+        fn local_ipv4_addr() -> IpAddr {
+            Ipv4Addr::new(127, 0, 0, 1).into()
+        }
+        fn local_ipv6_addr() -> IpAddr {
+            Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).into()
+        }
+        fn unreachable_ipv4_addr() -> IpAddr {
+            Ipv4Addr::new(127, 0, 0, 2).into()
+        }
+        fn unreachable_ipv6_addr() -> IpAddr {
+            Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 2).into()
+        }
+        fn slow_ipv4_addr() -> IpAddr {
+            Ipv4Addr::new(198, 18, 0, 25).into()
+        }
+        fn slow_ipv6_addr() -> IpAddr {
+            Ipv6Addr::new(2001, 2, 0, 0, 0, 0, 0, 254).into()
+        }
+        fn measure_connect(addr: IpAddr) -> (bool, Duration) {
+            let start = Instant::now();
+            let result = std::net::TcpStream::connect_timeout(
+                &(addr, 80).into(),
+                Duration::from_secs(1),
+            );
+            let reachable = result.is_ok()
+                || result.unwrap_err().kind() == io::ErrorKind::TimedOut;
+            let duration = start.elapsed();
+            (reachable, duration)
+        }
+    }
+}
diff --git a/hyper/src/client/connect/mod.rs b/hyper/src/client/connect/mod.rs
new file mode 100644
index 0000000..a134334
--- /dev/null
+++ b/hyper/src/client/connect/mod.rs
@@ -0,0 +1,343 @@
+//! Connectors used by the `Client`.
+//!
+//! This module contains:
+//!
+//! - A default [`HttpConnector`][] that does DNS resolution and establishes
+//!   connections over TCP.
+//! - Types to build custom connectors.
+//!
+//! # Connectors
+//!
+//! A "connector" is a [`Service`][] that takes a [`Uri`][] destination, and
+//! its `Response` is some type implementing [`AsyncRead`][], [`AsyncWrite`][],
+//! and [`Connection`][].
+//!
+//! ## Custom Connectors
+//!
+//! A simple connector that ignores the `Uri` destination and always returns
+//! a TCP connection to the same address could be written like this:
+//!
+//! ```rust,ignore
+//! let connector = tower::service_fn(|_dst| async {
+//!     tokio::net::TcpStream::connect("127.0.0.1:1337")
+//! })
+//! ```
+//!
+//! Or, fully written out:
+//!
+//! ```
+//! # #[cfg(feature = "runtime")]
+//! # mod rt {
+//! use std::{future::Future, net::SocketAddr, pin::Pin, task::{self, Poll}};
+//! use hyper::{service::Service, Uri};
+//! use tokio::net::TcpStream;
+//!
+//! #[derive(Clone)]
+//! struct LocalConnector;
+//!
+//! impl Service<Uri> for LocalConnector {
+//!     type Response = TcpStream;
+//!     type Error = std::io::Error;
+//!     // We can't "name" an `async` generated future.
+//!     type Future = Pin<Box<
+//!         dyn Future<Output = Result<Self::Response, Self::Error>> + Send
+//!     >>;
+//!
+//!     fn poll_ready(&mut self, _: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+//!         // This connector is always ready, but others might not be.
+//!         Poll::Ready(Ok(()))
+//!     }
+//!
+//!     fn call(&mut self, _: Uri) -> Self::Future {
+//!         Box::pin(TcpStream::connect(SocketAddr::from(([127, 0, 0, 1], 1337))))
+//!     }
+//! }
+//! # }
+//! ```
+//!
+//! It's worth noting that for `TcpStream`s, the [`HttpConnector`][] is a
+//! better starting place to extend from.
+//!
+//! Using either of the above connector examples, it can be used with the
+//! `Client` like this:
+//!
+//! ```
+//! # #[cfg(feature = "runtime")]
+//! # fn rt () {
+//! # let connector = hyper::client::HttpConnector::new();
+//! // let connector = ...
+//!
+//! let client = hyper::Client::builder()
+//!     .build::<_, hyper::Body>(connector);
+//! # }
+//! ```
+//!
+//!
+//! [`HttpConnector`]: HttpConnector
+//! [`Service`]: crate::service::Service
+//! [`Uri`]: ::http::Uri
+//! [`AsyncRead`]: tokio::io::AsyncRead
+//! [`AsyncWrite`]: tokio::io::AsyncWrite
+//! [`Connection`]: Connection
+use std::fmt;
+use ::http::Extensions;
+cfg_feature! {
+    #![feature = "tcp"] pub use self::http:: { HttpConnector, HttpInfo }; pub mod dns;
+    mod http;
+}
+cfg_feature! {
+    #![any(feature = "http1", feature = "http2")] pub use self::sealed::Connect;
+}
+/// Describes a type returned by a connector.
+pub trait Connection {
+    /// Return metadata describing the connection.
+    fn connected(&self) -> Connected;
+}
+/// Extra information about the connected transport.
+///
+/// This can be used to inform recipients about things like if ALPN
+/// was used, or if connected to an HTTP proxy.
+#[derive(Debug)]
+pub struct Connected {
+    pub(super) alpn: Alpn,
+    pub(super) is_proxied: bool,
+    pub(super) extra: Option<Extra>,
+}
+pub(super) struct Extra(Box<dyn ExtraInner>);
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum Alpn {
+    H2,
+    None,
+}
+impl Connected {
+    /// Create new `Connected` type with empty metadata.
+    pub(crate) fn new() -> Connected {
+        Connected {
+            alpn: Alpn::None,
+            is_proxied: false,
+            extra: None,
+        }
+    }
+    /// Set whether the connected transport is to an HTTP proxy.
+    ///
+    /// This setting will affect if HTTP/1 requests written on the transport
+    /// will have the request-target in absolute-form or origin-form:
+    ///
+    /// - When `proxy(false)`:
+    ///
+    /// ```http
+    /// GET /guide HTTP/1.1
+    /// ```
+    ///
+    /// - When `proxy(true)`:
+    ///
+    /// ```http
+    /// GET http://hyper.rs/guide HTTP/1.1
+    /// ```
+    ///
+    /// Default is `false`.
+    pub(crate) fn proxy(mut self, is_proxied: bool) -> Connected {
+        self.is_proxied = is_proxied;
+        self
+    }
+    /// Determines if the connected transport is to an HTTP proxy.
+    pub(crate) fn is_proxied(&self) -> bool {
+        self.is_proxied
+    }
+    /// Set extra connection information to be set in the extensions of every `Response`.
+    pub(crate) fn extra<T: Clone + Send + Sync + 'static>(
+        mut self,
+        extra: T,
+    ) -> Connected {
+        if let Some(prev) = self.extra {
+            self.extra = Some(Extra(Box::new(ExtraChain(prev.0, extra))));
+        } else {
+            self.extra = Some(Extra(Box::new(ExtraEnvelope(extra))));
+        }
+        self
+    }
+    /// Copies the extra connection information into an `Extensions` map.
+    pub(crate) fn get_extras(&self, extensions: &mut Extensions) {
+        if let Some(extra) = &self.extra {
+            extra.set(extensions);
+        }
+    }
+    /// Set that the connected transport negotiated HTTP/2 as its next protocol.
+    pub(crate) fn negotiated_h2(mut self) -> Connected {
+        self.alpn = Alpn::H2;
+        self
+    }
+    /// Determines if the connected transport negotiated HTTP/2 as its next protocol.
+    pub(crate) fn is_negotiated_h2(&self) -> bool {
+        self.alpn == Alpn::H2
+    }
+    #[cfg(feature = "http2")]
+    pub(super) fn clone(&self) -> Connected {
+        Connected {
+            alpn: self.alpn.clone(),
+            is_proxied: self.is_proxied,
+            extra: self.extra.clone(),
+        }
+    }
+}
+impl Extra {
+    pub(super) fn set(&self, res: &mut Extensions) {
+        self.0.set(res);
+    }
+}
+impl Clone for Extra {
+    fn clone(&self) -> Extra {
+        Extra(self.0.clone_box())
+    }
+}
+impl fmt::Debug for Extra {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Extra").finish()
+    }
+}
+trait ExtraInner: Send + Sync {
+    fn clone_box(&self) -> Box<dyn ExtraInner>;
+    fn set(&self, res: &mut Extensions);
+}
+#[derive(Clone)]
+struct ExtraEnvelope<T>(T);
+impl<T> ExtraInner for ExtraEnvelope<T>
+where
+    T: Clone + Send + Sync + 'static,
+{
+    fn clone_box(&self) -> Box<dyn ExtraInner> {
+        Box::new(self.clone())
+    }
+    fn set(&self, res: &mut Extensions) {
+        res.insert(self.0.clone());
+    }
+}
+struct ExtraChain<T>(Box<dyn ExtraInner>, T);
+impl<T: Clone> Clone for ExtraChain<T> {
+    fn clone(&self) -> Self {
+        ExtraChain(self.0.clone_box(), self.1.clone())
+    }
+}
+impl<T> ExtraInner for ExtraChain<T>
+where
+    T: Clone + Send + Sync + 'static,
+{
+    fn clone_box(&self) -> Box<dyn ExtraInner> {
+        Box::new(self.clone())
+    }
+    fn set(&self, res: &mut Extensions) {
+        self.0.set(res);
+        res.insert(self.1.clone());
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+pub(super) mod sealed {
+    use std::error::Error as StdError;
+    use ::http::Uri;
+    use tokio::io::{AsyncRead, AsyncWrite};
+    use super::Connection;
+    use crate::common::{Future, Unpin};
+    /// Connect to a destination, returning an IO transport.
+    ///
+    /// A connector receives a [`Uri`](::http::Uri) and returns a `Future` of the
+    /// ready connection.
+    ///
+    /// # Trait Alias
+    ///
+    /// This is really just an *alias* for the `tower::Service` trait, with
+    /// additional bounds set for convenience *inside* hyper. You don't actually
+    /// implement this trait, but `tower::Service<Uri>` instead.
+    pub trait Connect: Sealed + Sized {
+        #[doc(hidden)]
+        type _Svc: ConnectSvc;
+        #[doc(hidden)]
+        fn connect(
+            self,
+            internal_only: Internal,
+            dst: Uri,
+        ) -> <Self::_Svc as ConnectSvc>::Future;
+    }
+    pub trait ConnectSvc {
+        type Connection: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static;
+        type Error: Into<Box<dyn StdError + Send + Sync>>;
+        type Future: Future<Output = Result<Self::Connection, Self::Error>>
+            + Unpin
+            + Send
+            + 'static;
+        fn connect(self, internal_only: Internal, dst: Uri) -> Self::Future;
+    }
+    impl<S, T> Connect for S
+    where
+        S: tower_service::Service<Uri, Response = T> + Send + 'static,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        S::Future: Unpin + Send,
+        T: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
+    {
+        type _Svc = S;
+        fn connect(self, _: Internal, dst: Uri) -> crate::service::Oneshot<S, Uri> {
+            crate::service::oneshot(self, dst)
+        }
+    }
+    impl<S, T> ConnectSvc for S
+    where
+        S: tower_service::Service<Uri, Response = T> + Send + 'static,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        S::Future: Unpin + Send,
+        T: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
+    {
+        type Connection = T;
+        type Error = S::Error;
+        type Future = crate::service::Oneshot<S, Uri>;
+        fn connect(self, _: Internal, dst: Uri) -> Self::Future {
+            crate::service::oneshot(self, dst)
+        }
+    }
+    impl<S, T> Sealed for S
+    where
+        S: tower_service::Service<Uri, Response = T> + Send,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        S::Future: Unpin + Send,
+        T: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
+    {}
+    pub trait Sealed {}
+    #[allow(missing_debug_implementations)]
+    pub struct Internal;
+}
+#[cfg(test)]
+mod tests {
+    use super::Connected;
+    #[derive(Clone, Debug, PartialEq)]
+    struct Ex1(usize);
+    #[derive(Clone, Debug, PartialEq)]
+    struct Ex2(&'static str);
+    #[derive(Clone, Debug, PartialEq)]
+    struct Ex3(&'static str);
+    #[test]
+    fn test_connected_extra() {
+        let c1 = Connected::new().extra(Ex1(41));
+        let mut ex = ::http::Extensions::new();
+        assert_eq!(ex.get::< Ex1 > (), None);
+        c1.extra.as_ref().expect("c1 extra").set(&mut ex);
+        assert_eq!(ex.get::< Ex1 > (), Some(& Ex1(41)));
+    }
+    #[test]
+    fn test_connected_extra_chain() {
+        let c1 = Connected::new()
+            .extra(Ex1(45))
+            .extra(Ex2("zoom"))
+            .extra(Ex3("pew pew"));
+        let mut ex1 = ::http::Extensions::new();
+        assert_eq!(ex1.get::< Ex1 > (), None);
+        assert_eq!(ex1.get::< Ex2 > (), None);
+        assert_eq!(ex1.get::< Ex3 > (), None);
+        c1.extra.as_ref().expect("c1 extra").set(&mut ex1);
+        assert_eq!(ex1.get::< Ex1 > (), Some(& Ex1(45)));
+        assert_eq!(ex1.get::< Ex2 > (), Some(& Ex2("zoom")));
+        assert_eq!(ex1.get::< Ex3 > (), Some(& Ex3("pew pew")));
+        let c2 = Connected::new().extra(Ex1(33)).extra(Ex2("hiccup")).extra(Ex1(99));
+        let mut ex2 = ::http::Extensions::new();
+        c2.extra.as_ref().expect("c2 extra").set(&mut ex2);
+        assert_eq!(ex2.get::< Ex1 > (), Some(& Ex1(99)));
+        assert_eq!(ex2.get::< Ex2 > (), Some(& Ex2("hiccup")));
+    }
+}
diff --git a/hyper/src/client/dispatch.rs b/hyper/src/client/dispatch.rs
new file mode 100644
index 0000000..0d70dbc
--- /dev/null
+++ b/hyper/src/client/dispatch.rs
@@ -0,0 +1,436 @@
+#[cfg(feature = "http2")]
+use std::future::Future;
+
+use futures_util::FutureExt;
+use tokio::sync::{mpsc, oneshot};
+
+#[cfg(feature = "http2")]
+use crate::common::Pin;
+use crate::common::{task, Poll};
+
+pub(crate) type RetryPromise<T, U> = oneshot::Receiver<Result<U, (crate::Error, Option<T>)>>;
+pub(crate) type Promise<T> = oneshot::Receiver<Result<T, crate::Error>>;
+
+pub(crate) fn channel<T, U>() -> (Sender<T, U>, Receiver<T, U>) {
+    let (tx, rx) = mpsc::unbounded_channel();
+    let (giver, taker) = want::new();
+    let tx = Sender {
+        buffered_once: false,
+        giver,
+        inner: tx,
+    };
+    let rx = Receiver { inner: rx, taker };
+    (tx, rx)
+}
+
+/// A bounded sender of requests and callbacks for when responses are ready.
+///
+/// While the inner sender is unbounded, the Giver is used to determine
+/// if the Receiver is ready for another request.
+pub(crate) struct Sender<T, U> {
+    /// One message is always allowed, even if the Receiver hasn't asked
+    /// for it yet. This boolean keeps track of whether we've sent one
+    /// without notice.
+    buffered_once: bool,
+    /// The Giver helps watch that the the Receiver side has been polled
+    /// when the queue is empty. This helps us know when a request and
+    /// response have been fully processed, and a connection is ready
+    /// for more.
+    giver: want::Giver,
+    /// Actually bounded by the Giver, plus `buffered_once`.
+    inner: mpsc::UnboundedSender<Envelope<T, U>>,
+}
+
+/// An unbounded version.
+///
+/// Cannot poll the Giver, but can still use it to determine if the Receiver
+/// has been dropped. However, this version can be cloned.
+#[cfg(feature = "http2")]
+pub(crate) struct UnboundedSender<T, U> {
+    /// Only used for `is_closed`, since mpsc::UnboundedSender cannot be checked.
+    giver: want::SharedGiver,
+    inner: mpsc::UnboundedSender<Envelope<T, U>>,
+}
+
+impl<T, U> Sender<T, U> {
+    pub(crate) fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        self.giver
+            .poll_want(cx)
+            .map_err(|_| crate::Error::new_closed())
+    }
+
+    pub(crate) fn is_ready(&self) -> bool {
+        self.giver.is_wanting()
+    }
+
+    pub(crate) fn is_closed(&self) -> bool {
+        self.giver.is_canceled()
+    }
+
+    fn can_send(&mut self) -> bool {
+        if self.giver.give() || !self.buffered_once {
+            // If the receiver is ready *now*, then of course we can send.
+            //
+            // If the receiver isn't ready yet, but we don't have anything
+            // in the channel yet, then allow one message.
+            self.buffered_once = true;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, T> {
+        if !self.can_send() {
+            return Err(val);
+        }
+        let (tx, rx) = oneshot::channel();
+        self.inner
+            .send(Envelope(Some((val, Callback::Retry(Some(tx))))))
+            .map(move |_| rx)
+            .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+    }
+
+    pub(crate) fn send(&mut self, val: T) -> Result<Promise<U>, T> {
+        if !self.can_send() {
+            return Err(val);
+        }
+        let (tx, rx) = oneshot::channel();
+        self.inner
+            .send(Envelope(Some((val, Callback::NoRetry(Some(tx))))))
+            .map(move |_| rx)
+            .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+    }
+
+    #[cfg(feature = "http2")]
+    pub(crate) fn unbound(self) -> UnboundedSender<T, U> {
+        UnboundedSender {
+            giver: self.giver.shared(),
+            inner: self.inner,
+        }
+    }
+}
+
+#[cfg(feature = "http2")]
+impl<T, U> UnboundedSender<T, U> {
+    pub(crate) fn is_ready(&self) -> bool {
+        !self.giver.is_canceled()
+    }
+
+    pub(crate) fn is_closed(&self) -> bool {
+        self.giver.is_canceled()
+    }
+
+    pub(crate) fn try_send(&mut self, val: T) -> Result<RetryPromise<T, U>, T> {
+        let (tx, rx) = oneshot::channel();
+        self.inner
+            .send(Envelope(Some((val, Callback::Retry(Some(tx))))))
+            .map(move |_| rx)
+            .map_err(|mut e| (e.0).0.take().expect("envelope not dropped").0)
+    }
+}
+
+#[cfg(feature = "http2")]
+impl<T, U> Clone for UnboundedSender<T, U> {
+    fn clone(&self) -> Self {
+        UnboundedSender {
+            giver: self.giver.clone(),
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+pub(crate) struct Receiver<T, U> {
+    inner: mpsc::UnboundedReceiver<Envelope<T, U>>,
+    taker: want::Taker,
+}
+
+impl<T, U> Receiver<T, U> {
+    pub(crate) fn poll_recv(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<(T, Callback<T, U>)>> {
+        match self.inner.poll_recv(cx) {
+            Poll::Ready(item) => {
+                Poll::Ready(item.map(|mut env| env.0.take().expect("envelope not dropped")))
+            }
+            Poll::Pending => {
+                self.taker.want();
+                Poll::Pending
+            }
+        }
+    }
+
+    #[cfg(feature = "http1")]
+    pub(crate) fn close(&mut self) {
+        self.taker.cancel();
+        self.inner.close();
+    }
+
+    #[cfg(feature = "http1")]
+    pub(crate) fn try_recv(&mut self) -> Option<(T, Callback<T, U>)> {
+        match self.inner.recv().now_or_never() {
+            Some(Some(mut env)) => env.0.take(),
+            _ => None,
+        }
+    }
+}
+
+impl<T, U> Drop for Receiver<T, U> {
+    fn drop(&mut self) {
+        // Notify the giver about the closure first, before dropping
+        // the mpsc::Receiver.
+        self.taker.cancel();
+    }
+}
+
+struct Envelope<T, U>(Option<(T, Callback<T, U>)>);
+
+impl<T, U> Drop for Envelope<T, U> {
+    fn drop(&mut self) {
+        if let Some((val, cb)) = self.0.take() {
+            cb.send(Err((
+                crate::Error::new_canceled().with("connection closed"),
+                Some(val),
+            )));
+        }
+    }
+}
+
+pub(crate) enum Callback<T, U> {
+    Retry(Option<oneshot::Sender<Result<U, (crate::Error, Option<T>)>>>),
+    NoRetry(Option<oneshot::Sender<Result<U, crate::Error>>>),
+}
+
+impl<T, U> Drop for Callback<T, U> {
+    fn drop(&mut self) {
+        // FIXME(nox): What errors do we want here?
+        let error = crate::Error::new_user_dispatch_gone().with(if std::thread::panicking() {
+            "user code panicked"
+        } else {
+            "runtime dropped the dispatch task"
+        });
+
+        match self {
+            Callback::Retry(tx) => {
+                if let Some(tx) = tx.take() {
+                    let _ = tx.send(Err((error, None)));
+                }
+            }
+            Callback::NoRetry(tx) => {
+                if let Some(tx) = tx.take() {
+                    let _ = tx.send(Err(error));
+                }
+            }
+        }
+    }
+}
+
+impl<T, U> Callback<T, U> {
+    #[cfg(feature = "http2")]
+    pub(crate) fn is_canceled(&self) -> bool {
+        match *self {
+            Callback::Retry(Some(ref tx)) => tx.is_closed(),
+            Callback::NoRetry(Some(ref tx)) => tx.is_closed(),
+            _ => unreachable!(),
+        }
+    }
+
+    pub(crate) fn poll_canceled(&mut self, cx: &mut task::Context<'_>) -> Poll<()> {
+        match *self {
+            Callback::Retry(Some(ref mut tx)) => tx.poll_closed(cx),
+            Callback::NoRetry(Some(ref mut tx)) => tx.poll_closed(cx),
+            _ => unreachable!(),
+        }
+    }
+
+    pub(crate) fn send(mut self, val: Result<U, (crate::Error, Option<T>)>) {
+        match self {
+            Callback::Retry(ref mut tx) => {
+                let _ = tx.take().unwrap().send(val);
+            }
+            Callback::NoRetry(ref mut tx) => {
+                let _ = tx.take().unwrap().send(val.map_err(|e| e.0));
+            }
+        }
+    }
+
+    #[cfg(feature = "http2")]
+    pub(crate) async fn send_when(
+        self,
+        mut when: impl Future<Output = Result<U, (crate::Error, Option<T>)>> + Unpin,
+    ) {
+        use futures_util::future;
+        use tracing::trace;
+
+        let mut cb = Some(self);
+
+        // "select" on this callback being canceled, and the future completing
+        future::poll_fn(move |cx| {
+            match Pin::new(&mut when).poll(cx) {
+                Poll::Ready(Ok(res)) => {
+                    cb.take().expect("polled after complete").send(Ok(res));
+                    Poll::Ready(())
+                }
+                Poll::Pending => {
+                    // check if the callback is canceled
+                    ready!(cb.as_mut().unwrap().poll_canceled(cx));
+                    trace!("send_when canceled");
+                    Poll::Ready(())
+                }
+                Poll::Ready(Err(err)) => {
+                    cb.take().expect("polled after complete").send(Err(err));
+                    Poll::Ready(())
+                }
+            }
+        })
+        .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "nightly")]
+    extern crate test;
+
+    use std::future::Future;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+
+    use super::{channel, Callback, Receiver};
+
+    #[derive(Debug)]
+    struct Custom(i32);
+
+    impl<T, U> Future for Receiver<T, U> {
+        type Output = Option<(T, Callback<T, U>)>;
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            self.poll_recv(cx)
+        }
+    }
+
+    /// Helper to check if the future is ready after polling once.
+    struct PollOnce<'a, F>(&'a mut F);
+
+    impl<F, T> Future for PollOnce<'_, F>
+    where
+        F: Future<Output = T> + Unpin,
+    {
+        type Output = Option<()>;
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            match Pin::new(&mut self.0).poll(cx) {
+                Poll::Ready(_) => Poll::Ready(Some(())),
+                Poll::Pending => Poll::Ready(None),
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn drop_receiver_sends_cancel_errors() {
+        let _ = pretty_env_logger::try_init();
+
+        let (mut tx, mut rx) = channel::<Custom, ()>();
+
+        // must poll once for try_send to succeed
+        assert!(PollOnce(&mut rx).await.is_none(), "rx empty");
+
+        let promise = tx.try_send(Custom(43)).unwrap();
+        drop(rx);
+
+        let fulfilled = promise.await;
+        let err = fulfilled
+            .expect("fulfilled")
+            .expect_err("promise should error");
+        match (err.0.kind(), err.1) {
+            (&crate::error::Kind::Canceled, Some(_)) => (),
+            e => panic!("expected Error::Cancel(_), found {:?}", e),
+        }
+    }
+
+    #[tokio::test]
+    async fn sender_checks_for_want_on_send() {
+        let (mut tx, mut rx) = channel::<Custom, ()>();
+
+        // one is allowed to buffer, second is rejected
+        let _ = tx.try_send(Custom(1)).expect("1 buffered");
+        tx.try_send(Custom(2)).expect_err("2 not ready");
+
+        assert!(PollOnce(&mut rx).await.is_some(), "rx once");
+
+        // Even though 1 has been popped, only 1 could be buffered for the
+        // lifetime of the channel.
+        tx.try_send(Custom(2)).expect_err("2 still not ready");
+
+        assert!(PollOnce(&mut rx).await.is_none(), "rx empty");
+
+        let _ = tx.try_send(Custom(2)).expect("2 ready");
+    }
+
+    #[cfg(feature = "http2")]
+    #[test]
+    fn unbounded_sender_doesnt_bound_on_want() {
+        let (tx, rx) = channel::<Custom, ()>();
+        let mut tx = tx.unbound();
+
+        let _ = tx.try_send(Custom(1)).unwrap();
+        let _ = tx.try_send(Custom(2)).unwrap();
+        let _ = tx.try_send(Custom(3)).unwrap();
+
+        drop(rx);
+
+        let _ = tx.try_send(Custom(4)).unwrap_err();
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn giver_queue_throughput(b: &mut test::Bencher) {
+        use crate::{Body, Request, Response};
+
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        let (mut tx, mut rx) = channel::<Request<Body>, Response<Body>>();
+
+        b.iter(move || {
+            let _ = tx.send(Request::default()).unwrap();
+            rt.block_on(async {
+                loop {
+                    let poll_once = PollOnce(&mut rx);
+                    let opt = poll_once.await;
+                    if opt.is_none() {
+                        break;
+                    }
+                }
+            });
+        })
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn giver_queue_not_ready(b: &mut test::Bencher) {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        let (_tx, mut rx) = channel::<i32, ()>();
+        b.iter(move || {
+            rt.block_on(async {
+                let poll_once = PollOnce(&mut rx);
+                assert!(poll_once.await.is_none());
+            });
+        })
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn giver_queue_cancel(b: &mut test::Bencher) {
+        let (_tx, mut rx) = channel::<i32, ()>();
+
+        b.iter(move || {
+            rx.taker.cancel();
+        })
+    }
+}
diff --git a/hyper/src/client/mod.rs b/hyper/src/client/mod.rs
new file mode 100644
index 0000000..b7afae8
--- /dev/null
+++ b/hyper/src/client/mod.rs
@@ -0,0 +1,59 @@
+//! HTTP Client
+//!
+//! There are two levels of APIs provided for construct HTTP clients:
+//!
+//! - The higher-level [`Client`](Client) type.
+//! - The lower-level [`conn`](conn) module.
+//!
+//! # Client
+//!
+//! The [`Client`](Client) is the main way to send HTTP requests to a server.
+//! The default `Client` provides these things on top of the lower-level API:
+//!
+//! - A default **connector**, able to resolve hostnames and connect to
+//!   destinations over plain-text TCP.
+//! - A **pool** of existing connections, allowing better performance when
+//!   making multiple requests to the same hostname.
+//! - Automatic setting of the `Host` header, based on the request `Uri`.
+//! - Automatic request **retries** when a pooled connection is closed by the
+//!   server before any bytes have been written.
+//!
+//! Many of these features can configured, by making use of
+//! [`Client::builder`](Client::builder).
+//!
+//! ## Example
+//!
+//! For a small example program simply fetching a URL, take a look at the
+//! [full client example](https://github.com/hyperium/hyper/blob/master/examples/client.rs).
+//!
+//! ```
+//! # #[cfg(all(feature = "tcp", feature = "client", any(feature = "http1", feature = "http2")))]
+//! # async fn fetch_httpbin() -> hyper::Result<()> {
+//! use hyper::{body::HttpBody as _, Client, Uri};
+//!
+//! let client = Client::new();
+//!
+//! // Make a GET /ip to 'http://httpbin.org'
+//! let res = client.get(Uri::from_static("http://httpbin.org/ip")).await?;
+//!
+//! // And then, if the request gets a response...
+//! println!("status: {}", res.status());
+//!
+//! // Concatenate the body stream into a single buffer...
+//! let buf = hyper::body::to_bytes(res).await?;
+//!
+//! println!("body: {:?}", buf);
+//! # Ok(())
+//! # }
+//! # fn main () {}
+//! ```
+#[cfg(feature = "tcp")]
+pub(crate) use self::connect::HttpConnector;
+pub(crate) mod connect;
+#[cfg(all(test, feature = "runtime"))]
+mod tests;
+cfg_feature! {
+    #![any(feature = "http1", feature = "http2")] pub use self::client:: { Builder,
+    Client, ResponseFuture }; mod client; pub mod conn; pub (super) mod dispatch; mod
+    pool; pub mod service;
+}
diff --git a/hyper/src/client/pool.rs b/hyper/src/client/pool.rs
new file mode 100644
index 0000000..b9772d6
--- /dev/null
+++ b/hyper/src/client/pool.rs
@@ -0,0 +1,1044 @@
+use std::collections::{HashMap, HashSet, VecDeque};
+use std::error::Error as StdError;
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+use std::sync::{Arc, Mutex, Weak};
+
+#[cfg(not(feature = "runtime"))]
+use std::time::{Duration, Instant};
+
+use futures_channel::oneshot;
+#[cfg(feature = "runtime")]
+use tokio::time::{Duration, Instant, Interval};
+use tracing::{debug, trace};
+
+use super::client::Ver;
+use crate::common::{exec::Exec, task, Future, Pin, Poll, Unpin};
+
+// FIXME: allow() required due to `impl Trait` leaking types to this lint
+#[allow(missing_debug_implementations)]
+pub(super) struct Pool<T> {
+    // If the pool is disabled, this is None.
+    inner: Option<Arc<Mutex<PoolInner<T>>>>,
+}
+
+// Before using a pooled connection, make sure the sender is not dead.
+//
+// This is a trait to allow the `client::pool::tests` to work for `i32`.
+//
+// See https://github.com/hyperium/hyper/issues/1429
+pub(super) trait Poolable: Unpin + Send + Sized + 'static {
+    fn is_open(&self) -> bool;
+    /// Reserve this connection.
+    ///
+    /// Allows for HTTP/2 to return a shared reservation.
+    fn reserve(self) -> Reservation<Self>;
+    fn can_share(&self) -> bool;
+}
+
+/// When checking out a pooled connection, it might be that the connection
+/// only supports a single reservation, or it might be usable for many.
+///
+/// Specifically, HTTP/1 requires a unique reservation, but HTTP/2 can be
+/// used for multiple requests.
+// FIXME: allow() required due to `impl Trait` leaking types to this lint
+#[allow(missing_debug_implementations)]
+pub(super) enum Reservation<T> {
+    /// This connection could be used multiple times, the first one will be
+    /// reinserted into the `idle` pool, and the second will be given to
+    /// the `Checkout`.
+    #[cfg(feature = "http2")]
+    Shared(T, T),
+    /// This connection requires unique access. It will be returned after
+    /// use is complete.
+    Unique(T),
+}
+
+/// Simple type alias in case the key type needs to be adjusted.
+pub(super) type Key = (http::uri::Scheme, http::uri::Authority); //Arc<String>;
+
+struct PoolInner<T> {
+    // A flag that a connection is being established, and the connection
+    // should be shared. This prevents making multiple HTTP/2 connections
+    // to the same host.
+    connecting: HashSet<Key>,
+    // These are internal Conns sitting in the event loop in the KeepAlive
+    // state, waiting to receive a new Request to send on the socket.
+    idle: HashMap<Key, Vec<Idle<T>>>,
+    max_idle_per_host: usize,
+    // These are outstanding Checkouts that are waiting for a socket to be
+    // able to send a Request one. This is used when "racing" for a new
+    // connection.
+    //
+    // The Client starts 2 tasks, 1 to connect a new socket, and 1 to wait
+    // for the Pool to receive an idle Conn. When a Conn becomes idle,
+    // this list is checked for any parked Checkouts, and tries to notify
+    // them that the Conn could be used instead of waiting for a brand new
+    // connection.
+    waiters: HashMap<Key, VecDeque<oneshot::Sender<T>>>,
+    // A oneshot channel is used to allow the interval to be notified when
+    // the Pool completely drops. That way, the interval can cancel immediately.
+    #[cfg(feature = "runtime")]
+    idle_interval_ref: Option<oneshot::Sender<crate::common::Never>>,
+    #[cfg(feature = "runtime")]
+    exec: Exec,
+    timeout: Option<Duration>,
+}
+
+// This is because `Weak::new()` *allocates* space for `T`, even if it
+// doesn't need it!
+struct WeakOpt<T>(Option<Weak<T>>);
+
+#[derive(Clone, Copy, Debug)]
+pub(super) struct Config {
+    pub(super) idle_timeout: Option<Duration>,
+    pub(super) max_idle_per_host: usize,
+}
+
+impl Config {
+    pub(super) fn is_enabled(&self) -> bool {
+        self.max_idle_per_host > 0
+    }
+}
+
+impl<T> Pool<T> {
+    pub(super) fn new(config: Config, __exec: &Exec) -> Pool<T> {
+        let inner = if config.is_enabled() {
+            Some(Arc::new(Mutex::new(PoolInner {
+                connecting: HashSet::new(),
+                idle: HashMap::new(),
+                #[cfg(feature = "runtime")]
+                idle_interval_ref: None,
+                max_idle_per_host: config.max_idle_per_host,
+                waiters: HashMap::new(),
+                #[cfg(feature = "runtime")]
+                exec: __exec.clone(),
+                timeout: config.idle_timeout,
+            })))
+        } else {
+            None
+        };
+
+        Pool { inner }
+    }
+
+    fn is_enabled(&self) -> bool {
+        self.inner.is_some()
+    }
+
+    #[cfg(test)]
+    pub(super) fn no_timer(&self) {
+        // Prevent an actual interval from being created for this pool...
+        #[cfg(feature = "runtime")]
+        {
+            let mut inner = self.inner.as_ref().unwrap().lock().unwrap();
+            assert!(inner.idle_interval_ref.is_none(), "timer already spawned");
+            let (tx, _) = oneshot::channel();
+            inner.idle_interval_ref = Some(tx);
+        }
+    }
+}
+
+impl<T: Poolable> Pool<T> {
+    /// Returns a `Checkout` which is a future that resolves if an idle
+    /// connection becomes available.
+    pub(super) fn checkout(&self, key: Key) -> Checkout<T> {
+        Checkout {
+            key,
+            pool: self.clone(),
+            waiter: None,
+        }
+    }
+
+    /// Ensure that there is only ever 1 connecting task for HTTP/2
+    /// connections. This does nothing for HTTP/1.
+    pub(super) fn connecting(&self, key: &Key, ver: Ver) -> Option<Connecting<T>> {
+        if ver == Ver::Http2 {
+            if let Some(ref enabled) = self.inner {
+                let mut inner = enabled.lock().unwrap();
+                return if inner.connecting.insert(key.clone()) {
+                    let connecting = Connecting {
+                        key: key.clone(),
+                        pool: WeakOpt::downgrade(enabled),
+                    };
+                    Some(connecting)
+                } else {
+                    trace!("HTTP/2 connecting already in progress for {:?}", key);
+                    None
+                };
+            }
+        }
+
+        // else
+        Some(Connecting {
+            key: key.clone(),
+            // in HTTP/1's case, there is never a lock, so we don't
+            // need to do anything in Drop.
+            pool: WeakOpt::none(),
+        })
+    }
+
+    #[cfg(test)]
+    fn locked(&self) -> std::sync::MutexGuard<'_, PoolInner<T>> {
+        self.inner.as_ref().expect("enabled").lock().expect("lock")
+    }
+
+    /* Used in client/tests.rs...
+    #[cfg(feature = "runtime")]
+    #[cfg(test)]
+    pub(super) fn h1_key(&self, s: &str) -> Key {
+        Arc::new(s.to_string())
+    }
+
+    #[cfg(feature = "runtime")]
+    #[cfg(test)]
+    pub(super) fn idle_count(&self, key: &Key) -> usize {
+        self
+            .locked()
+            .idle
+            .get(key)
+            .map(|list| list.len())
+            .unwrap_or(0)
+    }
+    */
+
+    pub(super) fn pooled(
+        &self,
+        #[cfg_attr(not(feature = "http2"), allow(unused_mut))] mut connecting: Connecting<T>,
+        value: T,
+    ) -> Pooled<T> {
+        let (value, pool_ref) = if let Some(ref enabled) = self.inner {
+            match value.reserve() {
+                #[cfg(feature = "http2")]
+                Reservation::Shared(to_insert, to_return) => {
+                    let mut inner = enabled.lock().unwrap();
+                    inner.put(connecting.key.clone(), to_insert, enabled);
+                    // Do this here instead of Drop for Connecting because we
+                    // already have a lock, no need to lock the mutex twice.
+                    inner.connected(&connecting.key);
+                    // prevent the Drop of Connecting from repeating inner.connected()
+                    connecting.pool = WeakOpt::none();
+
+                    // Shared reservations don't need a reference to the pool,
+                    // since the pool always keeps a copy.
+                    (to_return, WeakOpt::none())
+                }
+                Reservation::Unique(value) => {
+                    // Unique reservations must take a reference to the pool
+                    // since they hope to reinsert once the reservation is
+                    // completed
+                    (value, WeakOpt::downgrade(enabled))
+                }
+            }
+        } else {
+            // If pool is not enabled, skip all the things...
+
+            // The Connecting should have had no pool ref
+            debug_assert!(connecting.pool.upgrade().is_none());
+
+            (value, WeakOpt::none())
+        };
+        Pooled {
+            key: connecting.key.clone(),
+            is_reused: false,
+            pool: pool_ref,
+            value: Some(value),
+        }
+    }
+
+    fn reuse(&self, key: &Key, value: T) -> Pooled<T> {
+        debug!("reuse idle connection for {:?}", key);
+        // TODO: unhack this
+        // In Pool::pooled(), which is used for inserting brand new connections,
+        // there's some code that adjusts the pool reference taken depending
+        // on if the Reservation can be shared or is unique. By the time
+        // reuse() is called, the reservation has already been made, and
+        // we just have the final value, without knowledge of if this is
+        // unique or shared. So, the hack is to just assume Ver::Http2 means
+        // shared... :(
+        let mut pool_ref = WeakOpt::none();
+        if !value.can_share() {
+            if let Some(ref enabled) = self.inner {
+                pool_ref = WeakOpt::downgrade(enabled);
+            }
+        }
+
+        Pooled {
+            is_reused: true,
+            key: key.clone(),
+            pool: pool_ref,
+            value: Some(value),
+        }
+    }
+}
+
+/// Pop off this list, looking for a usable connection that hasn't expired.
+struct IdlePopper<'a, T> {
+    key: &'a Key,
+    list: &'a mut Vec<Idle<T>>,
+}
+
+impl<'a, T: Poolable + 'a> IdlePopper<'a, T> {
+    fn pop(self, expiration: &Expiration) -> Option<Idle<T>> {
+        while let Some(entry) = self.list.pop() {
+            // If the connection has been closed, or is older than our idle
+            // timeout, simply drop it and keep looking...
+            if !entry.value.is_open() {
+                trace!("removing closed connection for {:?}", self.key);
+                continue;
+            }
+            // TODO: Actually, since the `idle` list is pushed to the end always,
+            // that would imply that if *this* entry is expired, then anything
+            // "earlier" in the list would *have* to be expired also... Right?
+            //
+            // In that case, we could just break out of the loop and drop the
+            // whole list...
+            if expiration.expires(entry.idle_at) {
+                trace!("removing expired connection for {:?}", self.key);
+                continue;
+            }
+
+            let value = match entry.value.reserve() {
+                #[cfg(feature = "http2")]
+                Reservation::Shared(to_reinsert, to_checkout) => {
+                    self.list.push(Idle {
+                        idle_at: Instant::now(),
+                        value: to_reinsert,
+                    });
+                    to_checkout
+                }
+                Reservation::Unique(unique) => unique,
+            };
+
+            return Some(Idle {
+                idle_at: entry.idle_at,
+                value,
+            });
+        }
+
+        None
+    }
+}
+
+impl<T: Poolable> PoolInner<T> {
+    fn put(&mut self, key: Key, value: T, __pool_ref: &Arc<Mutex<PoolInner<T>>>) {
+        if value.can_share() && self.idle.contains_key(&key) {
+            trace!("put; existing idle HTTP/2 connection for {:?}", key);
+            return;
+        }
+        trace!("put; add idle connection for {:?}", key);
+        let mut remove_waiters = false;
+        let mut value = Some(value);
+        if let Some(waiters) = self.waiters.get_mut(&key) {
+            while let Some(tx) = waiters.pop_front() {
+                if !tx.is_canceled() {
+                    let reserved = value.take().expect("value already sent");
+                    let reserved = match reserved.reserve() {
+                        #[cfg(feature = "http2")]
+                        Reservation::Shared(to_keep, to_send) => {
+                            value = Some(to_keep);
+                            to_send
+                        }
+                        Reservation::Unique(uniq) => uniq,
+                    };
+                    match tx.send(reserved) {
+                        Ok(()) => {
+                            if value.is_none() {
+                                break;
+                            } else {
+                                continue;
+                            }
+                        }
+                        Err(e) => {
+                            value = Some(e);
+                        }
+                    }
+                }
+
+                trace!("put; removing canceled waiter for {:?}", key);
+            }
+            remove_waiters = waiters.is_empty();
+        }
+        if remove_waiters {
+            self.waiters.remove(&key);
+        }
+
+        match value {
+            Some(value) => {
+                // borrow-check scope...
+                {
+                    let idle_list = self.idle.entry(key.clone()).or_insert_with(Vec::new);
+                    if self.max_idle_per_host <= idle_list.len() {
+                        trace!("max idle per host for {:?}, dropping connection", key);
+                        return;
+                    }
+
+                    debug!("pooling idle connection for {:?}", key);
+                    idle_list.push(Idle {
+                        value,
+                        idle_at: Instant::now(),
+                    });
+                }
+
+                #[cfg(feature = "runtime")]
+                {
+                    self.spawn_idle_interval(__pool_ref);
+                }
+            }
+            None => trace!("put; found waiter for {:?}", key),
+        }
+    }
+
+    /// A `Connecting` task is complete. Not necessarily successfully,
+    /// but the lock is going away, so clean up.
+    fn connected(&mut self, key: &Key) {
+        let existed = self.connecting.remove(key);
+        debug_assert!(existed, "Connecting dropped, key not in pool.connecting");
+        // cancel any waiters. if there are any, it's because
+        // this Connecting task didn't complete successfully.
+        // those waiters would never receive a connection.
+        self.waiters.remove(key);
+    }
+
+    #[cfg(feature = "runtime")]
+    fn spawn_idle_interval(&mut self, pool_ref: &Arc<Mutex<PoolInner<T>>>) {
+        let (dur, rx) = {
+            if self.idle_interval_ref.is_some() {
+                return;
+            }
+
+            if let Some(dur) = self.timeout {
+                let (tx, rx) = oneshot::channel();
+                self.idle_interval_ref = Some(tx);
+                (dur, rx)
+            } else {
+                return;
+            }
+        };
+
+        let interval = IdleTask {
+            interval: tokio::time::interval(dur),
+            pool: WeakOpt::downgrade(pool_ref),
+            pool_drop_notifier: rx,
+        };
+
+        self.exec.execute(interval);
+    }
+}
+
+impl<T> PoolInner<T> {
+    /// Any `FutureResponse`s that were created will have made a `Checkout`,
+    /// and possibly inserted into the pool that it is waiting for an idle
+    /// connection. If a user ever dropped that future, we need to clean out
+    /// those parked senders.
+    fn clean_waiters(&mut self, key: &Key) {
+        let mut remove_waiters = false;
+        if let Some(waiters) = self.waiters.get_mut(key) {
+            waiters.retain(|tx| !tx.is_canceled());
+            remove_waiters = waiters.is_empty();
+        }
+        if remove_waiters {
+            self.waiters.remove(key);
+        }
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl<T: Poolable> PoolInner<T> {
+    /// This should *only* be called by the IdleTask
+    fn clear_expired(&mut self) {
+        let dur = self.timeout.expect("interval assumes timeout");
+
+        let now = Instant::now();
+        //self.last_idle_check_at = now;
+
+        self.idle.retain(|key, values| {
+            values.retain(|entry| {
+                if !entry.value.is_open() {
+                    trace!("idle interval evicting closed for {:?}", key);
+                    return false;
+                }
+
+                // Avoid `Instant::sub` to avoid issues like rust-lang/rust#86470.
+                if now.saturating_duration_since(entry.idle_at) > dur {
+                    trace!("idle interval evicting expired for {:?}", key);
+                    return false;
+                }
+
+                // Otherwise, keep this value...
+                true
+            });
+
+            // returning false evicts this key/val
+            !values.is_empty()
+        });
+    }
+}
+
+impl<T> Clone for Pool<T> {
+    fn clone(&self) -> Pool<T> {
+        Pool {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+/// A wrapped poolable value that tries to reinsert to the Pool on Drop.
+// Note: The bounds `T: Poolable` is needed for the Drop impl.
+pub(super) struct Pooled<T: Poolable> {
+    value: Option<T>,
+    is_reused: bool,
+    key: Key,
+    pool: WeakOpt<Mutex<PoolInner<T>>>,
+}
+
+impl<T: Poolable> Pooled<T> {
+    pub(super) fn is_reused(&self) -> bool {
+        self.is_reused
+    }
+
+    pub(super) fn is_pool_enabled(&self) -> bool {
+        self.pool.0.is_some()
+    }
+
+    fn as_ref(&self) -> &T {
+        self.value.as_ref().expect("not dropped")
+    }
+
+    fn as_mut(&mut self) -> &mut T {
+        self.value.as_mut().expect("not dropped")
+    }
+}
+
+impl<T: Poolable> Deref for Pooled<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        self.as_ref()
+    }
+}
+
+impl<T: Poolable> DerefMut for Pooled<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.as_mut()
+    }
+}
+
+impl<T: Poolable> Drop for Pooled<T> {
+    fn drop(&mut self) {
+        if let Some(value) = self.value.take() {
+            if !value.is_open() {
+                // If we *already* know the connection is done here,
+                // it shouldn't be re-inserted back into the pool.
+                return;
+            }
+
+            if let Some(pool) = self.pool.upgrade() {
+                if let Ok(mut inner) = pool.lock() {
+                    inner.put(self.key.clone(), value, &pool);
+                }
+            } else if !value.can_share() {
+                trace!("pool dropped, dropping pooled ({:?})", self.key);
+            }
+            // Ver::Http2 is already in the Pool (or dead), so we wouldn't
+            // have an actual reference to the Pool.
+        }
+    }
+}
+
+impl<T: Poolable> fmt::Debug for Pooled<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Pooled").field("key", &self.key).finish()
+    }
+}
+
+struct Idle<T> {
+    idle_at: Instant,
+    value: T,
+}
+
+// FIXME: allow() required due to `impl Trait` leaking types to this lint
+#[allow(missing_debug_implementations)]
+pub(super) struct Checkout<T> {
+    key: Key,
+    pool: Pool<T>,
+    waiter: Option<oneshot::Receiver<T>>,
+}
+
+#[derive(Debug)]
+pub(super) struct CheckoutIsClosedError;
+
+impl StdError for CheckoutIsClosedError {}
+
+impl fmt::Display for CheckoutIsClosedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("checked out connection was closed")
+    }
+}
+
+impl<T: Poolable> Checkout<T> {
+    fn poll_waiter(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<crate::Result<Pooled<T>>>> {
+        if let Some(mut rx) = self.waiter.take() {
+            match Pin::new(&mut rx).poll(cx) {
+                Poll::Ready(Ok(value)) => {
+                    if value.is_open() {
+                        Poll::Ready(Some(Ok(self.pool.reuse(&self.key, value))))
+                    } else {
+                        Poll::Ready(Some(Err(
+                            crate::Error::new_canceled().with(CheckoutIsClosedError)
+                        )))
+                    }
+                }
+                Poll::Pending => {
+                    self.waiter = Some(rx);
+                    Poll::Pending
+                }
+                Poll::Ready(Err(_canceled)) => Poll::Ready(Some(Err(
+                    crate::Error::new_canceled().with("request has been canceled")
+                ))),
+            }
+        } else {
+            Poll::Ready(None)
+        }
+    }
+
+    fn checkout(&mut self, cx: &mut task::Context<'_>) -> Option<Pooled<T>> {
+        let entry = {
+            let mut inner = self.pool.inner.as_ref()?.lock().unwrap();
+            let expiration = Expiration::new(inner.timeout);
+            let maybe_entry = inner.idle.get_mut(&self.key).and_then(|list| {
+                trace!("take? {:?}: expiration = {:?}", self.key, expiration.0);
+                // A block to end the mutable borrow on list,
+                // so the map below can check is_empty()
+                {
+                    let popper = IdlePopper {
+                        key: &self.key,
+                        list,
+                    };
+                    popper.pop(&expiration)
+                }
+                .map(|e| (e, list.is_empty()))
+            });
+
+            let (entry, empty) = if let Some((e, empty)) = maybe_entry {
+                (Some(e), empty)
+            } else {
+                // No entry found means nuke the list for sure.
+                (None, true)
+            };
+            if empty {
+                //TODO: This could be done with the HashMap::entry API instead.
+                inner.idle.remove(&self.key);
+            }
+
+            if entry.is_none() && self.waiter.is_none() {
+                let (tx, mut rx) = oneshot::channel();
+                trace!("checkout waiting for idle connection: {:?}", self.key);
+                inner
+                    .waiters
+                    .entry(self.key.clone())
+                    .or_insert_with(VecDeque::new)
+                    .push_back(tx);
+
+                // register the waker with this oneshot
+                assert!(Pin::new(&mut rx).poll(cx).is_pending());
+                self.waiter = Some(rx);
+            }
+
+            entry
+        };
+
+        entry.map(|e| self.pool.reuse(&self.key, e.value))
+    }
+}
+
+impl<T: Poolable> Future for Checkout<T> {
+    type Output = crate::Result<Pooled<T>>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        if let Some(pooled) = ready!(self.poll_waiter(cx)?) {
+            return Poll::Ready(Ok(pooled));
+        }
+
+        if let Some(pooled) = self.checkout(cx) {
+            Poll::Ready(Ok(pooled))
+        } else if !self.pool.is_enabled() {
+            Poll::Ready(Err(crate::Error::new_canceled().with("pool is disabled")))
+        } else {
+            // There's a new waiter, already registered in self.checkout()
+            debug_assert!(self.waiter.is_some());
+            Poll::Pending
+        }
+    }
+}
+
+impl<T> Drop for Checkout<T> {
+    fn drop(&mut self) {
+        if self.waiter.take().is_some() {
+            trace!("checkout dropped for {:?}", self.key);
+            if let Some(Ok(mut inner)) = self.pool.inner.as_ref().map(|i| i.lock()) {
+                inner.clean_waiters(&self.key);
+            }
+        }
+    }
+}
+
+// FIXME: allow() required due to `impl Trait` leaking types to this lint
+#[allow(missing_debug_implementations)]
+pub(super) struct Connecting<T: Poolable> {
+    key: Key,
+    pool: WeakOpt<Mutex<PoolInner<T>>>,
+}
+
+impl<T: Poolable> Connecting<T> {
+    pub(super) fn alpn_h2(self, pool: &Pool<T>) -> Option<Self> {
+        debug_assert!(
+            self.pool.0.is_none(),
+            "Connecting::alpn_h2 but already Http2"
+        );
+
+        pool.connecting(&self.key, Ver::Http2)
+    }
+}
+
+impl<T: Poolable> Drop for Connecting<T> {
+    fn drop(&mut self) {
+        if let Some(pool) = self.pool.upgrade() {
+            // No need to panic on drop, that could abort!
+            if let Ok(mut inner) = pool.lock() {
+                inner.connected(&self.key);
+            }
+        }
+    }
+}
+
+struct Expiration(Option<Duration>);
+
+impl Expiration {
+    fn new(dur: Option<Duration>) -> Expiration {
+        Expiration(dur)
+    }
+
+    fn expires(&self, instant: Instant) -> bool {
+        match self.0 {
+            // Avoid `Instant::elapsed` to avoid issues like rust-lang/rust#86470.
+            Some(timeout) => Instant::now().saturating_duration_since(instant) > timeout,
+            None => false,
+        }
+    }
+}
+
+#[cfg(feature = "runtime")]
+pin_project_lite::pin_project! {
+    struct IdleTask<T> {
+        #[pin]
+        interval: Interval,
+        pool: WeakOpt<Mutex<PoolInner<T>>>,
+        // This allows the IdleTask to be notified as soon as the entire
+        // Pool is fully dropped, and shutdown. This channel is never sent on,
+        // but Err(Canceled) will be received when the Pool is dropped.
+        #[pin]
+        pool_drop_notifier: oneshot::Receiver<crate::common::Never>,
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl<T: Poolable + 'static> Future for IdleTask<T> {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+        loop {
+            match this.pool_drop_notifier.as_mut().poll(cx) {
+                Poll::Ready(Ok(n)) => match n {},
+                Poll::Pending => (),
+                Poll::Ready(Err(_canceled)) => {
+                    trace!("pool closed, canceling idle interval");
+                    return Poll::Ready(());
+                }
+            }
+
+            ready!(this.interval.as_mut().poll_tick(cx));
+
+            if let Some(inner) = this.pool.upgrade() {
+                if let Ok(mut inner) = inner.lock() {
+                    trace!("idle interval checking for expired");
+                    inner.clear_expired();
+                    continue;
+                }
+            }
+            return Poll::Ready(());
+        }
+    }
+}
+
+impl<T> WeakOpt<T> {
+    fn none() -> Self {
+        WeakOpt(None)
+    }
+
+    fn downgrade(arc: &Arc<T>) -> Self {
+        WeakOpt(Some(Arc::downgrade(arc)))
+    }
+
+    fn upgrade(&self) -> Option<Arc<T>> {
+        self.0.as_ref().and_then(Weak::upgrade)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+    use std::time::Duration;
+
+    use super::{Connecting, Key, Pool, Poolable, Reservation, WeakOpt};
+    use crate::common::{exec::Exec, task, Future, Pin};
+
+    /// Test unique reservations.
+    #[derive(Debug, PartialEq, Eq)]
+    struct Uniq<T>(T);
+
+    impl<T: Send + 'static + Unpin> Poolable for Uniq<T> {
+        fn is_open(&self) -> bool {
+            true
+        }
+
+        fn reserve(self) -> Reservation<Self> {
+            Reservation::Unique(self)
+        }
+
+        fn can_share(&self) -> bool {
+            false
+        }
+    }
+
+    fn c<T: Poolable>(key: Key) -> Connecting<T> {
+        Connecting {
+            key,
+            pool: WeakOpt::none(),
+        }
+    }
+
+    fn host_key(s: &str) -> Key {
+        (http::uri::Scheme::HTTP, s.parse().expect("host key"))
+    }
+
+    fn pool_no_timer<T>() -> Pool<T> {
+        pool_max_idle_no_timer(::std::usize::MAX)
+    }
+
+    fn pool_max_idle_no_timer<T>(max_idle: usize) -> Pool<T> {
+        let pool = Pool::new(
+            super::Config {
+                idle_timeout: Some(Duration::from_millis(100)),
+                max_idle_per_host: max_idle,
+            },
+            &Exec::Default,
+        );
+        pool.no_timer();
+        pool
+    }
+
+    #[tokio::test]
+    async fn test_pool_checkout_smoke() {
+        let pool = pool_no_timer();
+        let key = host_key("foo");
+        let pooled = pool.pooled(c(key.clone()), Uniq(41));
+
+        drop(pooled);
+
+        match pool.checkout(key).await {
+            Ok(pooled) => assert_eq!(*pooled, Uniq(41)),
+            Err(_) => panic!("not ready"),
+        };
+    }
+
+    /// Helper to check if the future is ready after polling once.
+    struct PollOnce<'a, F>(&'a mut F);
+
+    impl<F, T, U> Future for PollOnce<'_, F>
+    where
+        F: Future<Output = Result<T, U>> + Unpin,
+    {
+        type Output = Option<()>;
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+            match Pin::new(&mut self.0).poll(cx) {
+                Poll::Ready(Ok(_)) => Poll::Ready(Some(())),
+                Poll::Ready(Err(_)) => Poll::Ready(Some(())),
+                Poll::Pending => Poll::Ready(None),
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_pool_checkout_returns_none_if_expired() {
+        let pool = pool_no_timer();
+        let key = host_key("foo");
+        let pooled = pool.pooled(c(key.clone()), Uniq(41));
+
+        drop(pooled);
+        tokio::time::sleep(pool.locked().timeout.unwrap()).await;
+        let mut checkout = pool.checkout(key);
+        let poll_once = PollOnce(&mut checkout);
+        let is_not_ready = poll_once.await.is_none();
+        assert!(is_not_ready);
+    }
+
+    #[cfg(feature = "runtime")]
+    #[tokio::test]
+    async fn test_pool_checkout_removes_expired() {
+        let pool = pool_no_timer();
+        let key = host_key("foo");
+
+        pool.pooled(c(key.clone()), Uniq(41));
+        pool.pooled(c(key.clone()), Uniq(5));
+        pool.pooled(c(key.clone()), Uniq(99));
+
+        assert_eq!(
+            pool.locked().idle.get(&key).map(|entries| entries.len()),
+            Some(3)
+        );
+        tokio::time::sleep(pool.locked().timeout.unwrap()).await;
+
+        let mut checkout = pool.checkout(key.clone());
+        let poll_once = PollOnce(&mut checkout);
+        // checkout.await should clean out the expired
+        poll_once.await;
+        assert!(pool.locked().idle.get(&key).is_none());
+    }
+
+    #[test]
+    fn test_pool_max_idle_per_host() {
+        let pool = pool_max_idle_no_timer(2);
+        let key = host_key("foo");
+
+        pool.pooled(c(key.clone()), Uniq(41));
+        pool.pooled(c(key.clone()), Uniq(5));
+        pool.pooled(c(key.clone()), Uniq(99));
+
+        // pooled and dropped 3, max_idle should only allow 2
+        assert_eq!(
+            pool.locked().idle.get(&key).map(|entries| entries.len()),
+            Some(2)
+        );
+    }
+
+    #[cfg(feature = "runtime")]
+    #[tokio::test]
+    async fn test_pool_timer_removes_expired() {
+        let _ = pretty_env_logger::try_init();
+        tokio::time::pause();
+
+        let pool = Pool::new(
+            super::Config {
+                idle_timeout: Some(Duration::from_millis(10)),
+                max_idle_per_host: std::usize::MAX,
+            },
+            &Exec::Default,
+        );
+
+        let key = host_key("foo");
+
+        pool.pooled(c(key.clone()), Uniq(41));
+        pool.pooled(c(key.clone()), Uniq(5));
+        pool.pooled(c(key.clone()), Uniq(99));
+
+        assert_eq!(
+            pool.locked().idle.get(&key).map(|entries| entries.len()),
+            Some(3)
+        );
+
+        // Let the timer tick passed the expiration...
+        tokio::time::advance(Duration::from_millis(30)).await;
+        // Yield so the Interval can reap...
+        tokio::task::yield_now().await;
+
+        assert!(pool.locked().idle.get(&key).is_none());
+    }
+
+    #[tokio::test]
+    async fn test_pool_checkout_task_unparked() {
+        use futures_util::future::join;
+        use futures_util::FutureExt;
+
+        let pool = pool_no_timer();
+        let key = host_key("foo");
+        let pooled = pool.pooled(c(key.clone()), Uniq(41));
+
+        let checkout = join(pool.checkout(key), async {
+            // the checkout future will park first,
+            // and then this lazy future will be polled, which will insert
+            // the pooled back into the pool
+            //
+            // this test makes sure that doing so will unpark the checkout
+            drop(pooled);
+        })
+        .map(|(entry, _)| entry);
+
+        assert_eq!(*checkout.await.unwrap(), Uniq(41));
+    }
+
+    #[tokio::test]
+    async fn test_pool_checkout_drop_cleans_up_waiters() {
+        let pool = pool_no_timer::<Uniq<i32>>();
+        let key = host_key("foo");
+
+        let mut checkout1 = pool.checkout(key.clone());
+        let mut checkout2 = pool.checkout(key.clone());
+
+        let poll_once1 = PollOnce(&mut checkout1);
+        let poll_once2 = PollOnce(&mut checkout2);
+
+        // first poll needed to get into Pool's parked
+        poll_once1.await;
+        assert_eq!(pool.locked().waiters.get(&key).unwrap().len(), 1);
+        poll_once2.await;
+        assert_eq!(pool.locked().waiters.get(&key).unwrap().len(), 2);
+
+        // on drop, clean up Pool
+        drop(checkout1);
+        assert_eq!(pool.locked().waiters.get(&key).unwrap().len(), 1);
+
+        drop(checkout2);
+        assert!(pool.locked().waiters.get(&key).is_none());
+    }
+
+    #[derive(Debug)]
+    struct CanClose {
+        #[allow(unused)]
+        val: i32,
+        closed: bool,
+    }
+
+    impl Poolable for CanClose {
+        fn is_open(&self) -> bool {
+            !self.closed
+        }
+
+        fn reserve(self) -> Reservation<Self> {
+            Reservation::Unique(self)
+        }
+
+        fn can_share(&self) -> bool {
+            false
+        }
+    }
+
+    #[test]
+    fn pooled_drop_if_closed_doesnt_reinsert() {
+        let pool = pool_no_timer();
+        let key = host_key("foo");
+        pool.pooled(
+            c(key.clone()),
+            CanClose {
+                val: 57,
+                closed: true,
+            },
+        );
+
+        assert!(!pool.locked().idle.contains_key(&key));
+    }
+}
diff --git a/hyper/src/client/service.rs b/hyper/src/client/service.rs
new file mode 100644
index 0000000..25fb403
--- /dev/null
+++ b/hyper/src/client/service.rs
@@ -0,0 +1,87 @@
+//! Utilities used to interact with the Tower ecosystem.
+//!
+//! This module provides `Connect` which hook-ins into the Tower ecosystem.
+use std::error::Error as StdError;
+use std::future::Future;
+use std::marker::PhantomData;
+use tracing::debug;
+use super::conn::{Builder, SendRequest};
+use crate::{
+    body::HttpBody, common::{task, Pin, Poll},
+    service::{MakeConnection, Service},
+};
+/// Creates a connection via `SendRequest`.
+///
+/// This accepts a `hyper::client::conn::Builder` and provides
+/// a `MakeService` implementation to create connections from some
+/// target `T`.
+#[derive(Debug)]
+pub(crate) struct Connect<C, B, T> {
+    inner: C,
+    builder: Builder,
+    _pd: PhantomData<fn(T, B)>,
+}
+impl<C, B, T> Connect<C, B, T> {
+    /// Create a new `Connect` with some inner connector `C` and a connection
+    /// builder.
+    pub(crate) fn new(inner: C, builder: Builder) -> Self {
+        Self {
+            inner,
+            builder,
+            _pd: PhantomData,
+        }
+    }
+}
+impl<C, B, T> Service<T> for Connect<C, B, T>
+where
+    C: MakeConnection<T>,
+    C::Connection: Unpin + Send + 'static,
+    C::Future: Send + 'static,
+    C::Error: Into<Box<dyn StdError + Send + Sync>> + Send,
+    B: HttpBody + Unpin + Send + 'static,
+    B::Data: Send + Unpin,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Response = SendRequest<B>;
+    type Error = crate::Error;
+    type Future = Pin<
+        Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send + 'static>,
+    >;
+    fn poll_ready(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        self.inner
+            .poll_ready(cx)
+            .map_err(|e| crate::Error::new(crate::error::Kind::Connect).with(e.into()))
+    }
+    fn call(&mut self, req: T) -> Self::Future {
+        let builder = self.builder.clone();
+        let io = self.inner.make_connection(req);
+        let fut = async move {
+            match io.await {
+                Ok(io) => {
+                    match builder.handshake(io).await {
+                        Ok((sr, conn)) => {
+                            builder
+                                .exec
+                                .execute(async move {
+                                    if let Err(e) = conn.await {
+                                        debug!("connection error: {:?}", e);
+                                    }
+                                });
+                            Ok(sr)
+                        }
+                        Err(e) => Err(e),
+                    }
+                }
+                Err(e) => {
+                    let err = crate::Error::new(crate::error::Kind::Connect)
+                        .with(e.into());
+                    Err(err)
+                }
+            }
+        };
+        Box::pin(fut)
+    }
+}
diff --git a/hyper/src/client/tests.rs b/hyper/src/client/tests.rs
new file mode 100644
index 0000000..0a281a6
--- /dev/null
+++ b/hyper/src/client/tests.rs
@@ -0,0 +1,286 @@
+use std::io;
+
+use futures_util::future;
+use tokio::net::TcpStream;
+
+use super::Client;
+
+#[tokio::test]
+async fn client_connect_uri_argument() {
+    let connector = tower::service_fn(|dst: http::Uri| {
+        assert_eq!(dst.scheme(), Some(&http::uri::Scheme::HTTP));
+        assert_eq!(dst.host(), Some("example.local"));
+        assert_eq!(dst.port(), None);
+        assert_eq!(dst.path(), "/", "path should be removed");
+
+        future::err::<TcpStream, _>(io::Error::new(io::ErrorKind::Other, "expect me"))
+    });
+
+    let client = Client::builder().build::<_, crate::Body>(connector);
+    let _ = client
+        .get("http://example.local/and/a/path".parse().unwrap())
+        .await
+        .expect_err("response should fail");
+}
+
+/*
+// FIXME: re-implement tests with `async/await`
+#[test]
+fn retryable_request() {
+    let _ = pretty_env_logger::try_init();
+
+    let mut rt = Runtime::new().expect("new rt");
+    let mut connector = MockConnector::new();
+
+    let sock1 = connector.mock("http://mock.local");
+    let sock2 = connector.mock("http://mock.local");
+
+    let client = Client::builder()
+        .build::<_, crate::Body>(connector);
+
+    client.pool.no_timer();
+
+    {
+
+        let req = Request::builder()
+            .uri("http://mock.local/a")
+            .body(Default::default())
+            .unwrap();
+        let res1 = client.request(req);
+        let srv1 = poll_fn(|| {
+            try_ready!(sock1.read(&mut [0u8; 512]));
+            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+            Ok(Async::Ready(()))
+        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+        rt.block_on(res1.join(srv1)).expect("res1");
+    }
+    drop(sock1);
+
+    let req = Request::builder()
+        .uri("http://mock.local/b")
+        .body(Default::default())
+        .unwrap();
+    let res2 = client.request(req)
+        .map(|res| {
+            assert_eq!(res.status().as_u16(), 222);
+        });
+    let srv2 = poll_fn(|| {
+        try_ready!(sock2.read(&mut [0u8; 512]));
+        try_ready!(sock2.write(b"HTTP/1.1 222 OK\r\nContent-Length: 0\r\n\r\n"));
+        Ok(Async::Ready(()))
+    }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));
+
+    rt.block_on(res2.join(srv2)).expect("res2");
+}
+
+#[test]
+fn conn_reset_after_write() {
+    let _ = pretty_env_logger::try_init();
+
+    let mut rt = Runtime::new().expect("new rt");
+    let mut connector = MockConnector::new();
+
+    let sock1 = connector.mock("http://mock.local");
+
+    let client = Client::builder()
+        .build::<_, crate::Body>(connector);
+
+    client.pool.no_timer();
+
+    {
+        let req = Request::builder()
+            .uri("http://mock.local/a")
+            .body(Default::default())
+            .unwrap();
+        let res1 = client.request(req);
+        let srv1 = poll_fn(|| {
+            try_ready!(sock1.read(&mut [0u8; 512]));
+            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+            Ok(Async::Ready(()))
+        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+        rt.block_on(res1.join(srv1)).expect("res1");
+    }
+
+    let req = Request::builder()
+        .uri("http://mock.local/a")
+        .body(Default::default())
+        .unwrap();
+    let res2 = client.request(req);
+    let mut sock1 = Some(sock1);
+    let srv2 = poll_fn(|| {
+        // We purposefully keep the socket open until the client
+        // has written the second request, and THEN disconnect.
+        //
+        // Not because we expect servers to be jerks, but to trigger
+        // state where we write on an assumedly good connection, and
+        // only reset the close AFTER we wrote bytes.
+        try_ready!(sock1.as_mut().unwrap().read(&mut [0u8; 512]));
+        sock1.take();
+        Ok(Async::Ready(()))
+    }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));
+    let err = rt.block_on(res2.join(srv2)).expect_err("res2");
+    assert!(err.is_incomplete_message(), "{:?}", err);
+}
+
+#[test]
+fn checkout_win_allows_connect_future_to_be_pooled() {
+    let _ = pretty_env_logger::try_init();
+
+    let mut rt = Runtime::new().expect("new rt");
+    let mut connector = MockConnector::new();
+
+
+    let (tx, rx) = oneshot::channel::<()>();
+    let sock1 = connector.mock("http://mock.local");
+    let sock2 = connector.mock_fut("http://mock.local", rx);
+
+    let client = Client::builder()
+        .build::<_, crate::Body>(connector);
+
+    client.pool.no_timer();
+
+    let uri = "http://mock.local/a".parse::<crate::Uri>().expect("uri parse");
+
+    // First request just sets us up to have a connection able to be put
+    // back in the pool. *However*, it doesn't insert immediately. The
+    // body has 1 pending byte, and we will only drain in request 2, once
+    // the connect future has been started.
+    let mut body = {
+        let res1 = client.get(uri.clone())
+            .map(|res| res.into_body().concat2());
+        let srv1 = poll_fn(|| {
+            try_ready!(sock1.read(&mut [0u8; 512]));
+            // Chunked is used so as to force 2 body reads.
+            try_ready!(sock1.write(b"\
+                HTTP/1.1 200 OK\r\n\
+                transfer-encoding: chunked\r\n\
+                \r\n\
+                1\r\nx\r\n\
+                0\r\n\r\n\
+            "));
+            Ok(Async::Ready(()))
+        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+
+        rt.block_on(res1.join(srv1)).expect("res1").0
+    };
+
+
+    // The second request triggers the only mocked connect future, but then
+    // the drained body allows the first socket to go back to the pool,
+    // "winning" the checkout race.
+    {
+        let res2 = client.get(uri.clone());
+        let drain = poll_fn(move || {
+            body.poll()
+        });
+        let srv2 = poll_fn(|| {
+            try_ready!(sock1.read(&mut [0u8; 512]));
+            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nx"));
+            Ok(Async::Ready(()))
+        }).map_err(|e: std::io::Error| panic!("srv2 poll_fn error: {}", e));
+
+        rt.block_on(res2.join(drain).join(srv2)).expect("res2");
+    }
+
+    // "Release" the mocked connect future, and let the runtime spin once so
+    // it's all setup...
+    {
+        let mut tx = Some(tx);
+        let client = &client;
+        let key = client.pool.h1_key("http://mock.local");
+        let mut tick_cnt = 0;
+        let fut = poll_fn(move || {
+            tx.take();
+
+            if client.pool.idle_count(&key) == 0 {
+                tick_cnt += 1;
+                assert!(tick_cnt < 10, "ticked too many times waiting for idle");
+                trace!("no idle yet; tick count: {}", tick_cnt);
+                ::futures::task::current().notify();
+                Ok(Async::NotReady)
+            } else {
+                Ok::<_, ()>(Async::Ready(()))
+            }
+        });
+        rt.block_on(fut).unwrap();
+    }
+
+    // Third request just tests out that the "loser" connection was pooled. If
+    // it isn't, this will panic since the MockConnector doesn't have any more
+    // mocks to give out.
+    {
+        let res3 = client.get(uri);
+        let srv3 = poll_fn(|| {
+            try_ready!(sock2.read(&mut [0u8; 512]));
+            try_ready!(sock2.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+            Ok(Async::Ready(()))
+        }).map_err(|e: std::io::Error| panic!("srv3 poll_fn error: {}", e));
+
+        rt.block_on(res3.join(srv3)).expect("res3");
+    }
+}
+
+#[cfg(feature = "nightly")]
+#[bench]
+fn bench_http1_get_0b(b: &mut test::Bencher) {
+    let _ = pretty_env_logger::try_init();
+
+    let mut rt = Runtime::new().expect("new rt");
+    let mut connector = MockConnector::new();
+
+
+    let client = Client::builder()
+        .build::<_, crate::Body>(connector.clone());
+
+    client.pool.no_timer();
+
+    let uri = Uri::from_static("http://mock.local/a");
+
+    b.iter(move || {
+        let sock1 = connector.mock("http://mock.local");
+        let res1 = client
+            .get(uri.clone())
+            .and_then(|res| {
+                res.into_body().for_each(|_| Ok(()))
+            });
+        let srv1 = poll_fn(|| {
+            try_ready!(sock1.read(&mut [0u8; 512]));
+            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"));
+            Ok(Async::Ready(()))
+        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+        rt.block_on(res1.join(srv1)).expect("res1");
+    });
+}
+
+#[cfg(feature = "nightly")]
+#[bench]
+fn bench_http1_get_10b(b: &mut test::Bencher) {
+    let _ = pretty_env_logger::try_init();
+
+    let mut rt = Runtime::new().expect("new rt");
+    let mut connector = MockConnector::new();
+
+
+    let client = Client::builder()
+        .build::<_, crate::Body>(connector.clone());
+
+    client.pool.no_timer();
+
+    let uri = Uri::from_static("http://mock.local/a");
+
+    b.iter(move || {
+        let sock1 = connector.mock("http://mock.local");
+        let res1 = client
+            .get(uri.clone())
+            .and_then(|res| {
+                res.into_body().for_each(|_| Ok(()))
+            });
+        let srv1 = poll_fn(|| {
+            try_ready!(sock1.read(&mut [0u8; 512]));
+            try_ready!(sock1.write(b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\n0123456789"));
+            Ok(Async::Ready(()))
+        }).map_err(|e: std::io::Error| panic!("srv1 poll_fn error: {}", e));
+        rt.block_on(res1.join(srv1)).expect("res1");
+    });
+}
+*/
diff --git a/hyper/src/common/buf.rs b/hyper/src/common/buf.rs
new file mode 100644
index 0000000..64e9333
--- /dev/null
+++ b/hyper/src/common/buf.rs
@@ -0,0 +1,151 @@
+use std::collections::VecDeque;
+use std::io::IoSlice;
+
+use bytes::{Buf, BufMut, Bytes, BytesMut};
+
+pub(crate) struct BufList<T> {
+    bufs: VecDeque<T>,
+}
+
+impl<T: Buf> BufList<T> {
+    pub(crate) fn new() -> BufList<T> {
+        BufList {
+            bufs: VecDeque::new(),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn push(&mut self, buf: T) {
+        debug_assert!(buf.has_remaining());
+        self.bufs.push_back(buf);
+    }
+
+    #[inline]
+    #[cfg(feature = "http1")]
+    pub(crate) fn bufs_cnt(&self) -> usize {
+        self.bufs.len()
+    }
+}
+
+impl<T: Buf> Buf for BufList<T> {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.bufs.iter().map(|buf| buf.remaining()).sum()
+    }
+
+    #[inline]
+    fn chunk(&self) -> &[u8] {
+        self.bufs.front().map(Buf::chunk).unwrap_or_default()
+    }
+
+    #[inline]
+    fn advance(&mut self, mut cnt: usize) {
+        while cnt > 0 {
+            {
+                let front = &mut self.bufs[0];
+                let rem = front.remaining();
+                if rem > cnt {
+                    front.advance(cnt);
+                    return;
+                } else {
+                    front.advance(rem);
+                    cnt -= rem;
+                }
+            }
+            self.bufs.pop_front();
+        }
+    }
+
+    #[inline]
+    fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
+        if dst.is_empty() {
+            return 0;
+        }
+        let mut vecs = 0;
+        for buf in &self.bufs {
+            vecs += buf.chunks_vectored(&mut dst[vecs..]);
+            if vecs == dst.len() {
+                break;
+            }
+        }
+        vecs
+    }
+
+    #[inline]
+    fn copy_to_bytes(&mut self, len: usize) -> Bytes {
+        // Our inner buffer may have an optimized version of copy_to_bytes, and if the whole
+        // request can be fulfilled by the front buffer, we can take advantage.
+        match self.bufs.front_mut() {
+            Some(front) if front.remaining() == len => {
+                let b = front.copy_to_bytes(len);
+                self.bufs.pop_front();
+                b
+            }
+            Some(front) if front.remaining() > len => front.copy_to_bytes(len),
+            _ => {
+                assert!(len <= self.remaining(), "`len` greater than remaining");
+                let mut bm = BytesMut::with_capacity(len);
+                bm.put(self.take(len));
+                bm.freeze()
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ptr;
+
+    use super::*;
+
+    fn hello_world_buf() -> BufList<Bytes> {
+        BufList {
+            bufs: vec![Bytes::from("Hello"), Bytes::from(" "), Bytes::from("World")].into(),
+        }
+    }
+
+    #[test]
+    fn to_bytes_shorter() {
+        let mut bufs = hello_world_buf();
+        let old_ptr = bufs.chunk().as_ptr();
+        let start = bufs.copy_to_bytes(4);
+        assert_eq!(start, "Hell");
+        assert!(ptr::eq(old_ptr, start.as_ptr()));
+        assert_eq!(bufs.chunk(), b"o");
+        assert!(ptr::eq(old_ptr.wrapping_add(4), bufs.chunk().as_ptr()));
+        assert_eq!(bufs.remaining(), 7);
+    }
+
+    #[test]
+    fn to_bytes_eq() {
+        let mut bufs = hello_world_buf();
+        let old_ptr = bufs.chunk().as_ptr();
+        let start = bufs.copy_to_bytes(5);
+        assert_eq!(start, "Hello");
+        assert!(ptr::eq(old_ptr, start.as_ptr()));
+        assert_eq!(bufs.chunk(), b" ");
+        assert_eq!(bufs.remaining(), 6);
+    }
+
+    #[test]
+    fn to_bytes_longer() {
+        let mut bufs = hello_world_buf();
+        let start = bufs.copy_to_bytes(7);
+        assert_eq!(start, "Hello W");
+        assert_eq!(bufs.remaining(), 4);
+    }
+
+    #[test]
+    fn one_long_buf_to_bytes() {
+        let mut buf = BufList::new();
+        buf.push(b"Hello World" as &[_]);
+        assert_eq!(buf.copy_to_bytes(5), "Hello");
+        assert_eq!(buf.chunk(), b" World");
+    }
+
+    #[test]
+    #[should_panic(expected = "`len` greater than remaining")]
+    fn buf_to_bytes_too_many() {
+        hello_world_buf().copy_to_bytes(42);
+    }
+}
diff --git a/hyper/src/common/date.rs b/hyper/src/common/date.rs
new file mode 100644
index 0000000..a436fc0
--- /dev/null
+++ b/hyper/src/common/date.rs
@@ -0,0 +1,124 @@
+use std::cell::RefCell;
+use std::fmt::{self, Write};
+use std::str;
+use std::time::{Duration, SystemTime};
+
+#[cfg(feature = "http2")]
+use http::header::HeaderValue;
+use httpdate::HttpDate;
+
+// "Sun, 06 Nov 1994 08:49:37 GMT".len()
+pub(crate) const DATE_VALUE_LENGTH: usize = 29;
+
+#[cfg(feature = "http1")]
+pub(crate) fn extend(dst: &mut Vec<u8>) {
+    CACHED.with(|cache| {
+        dst.extend_from_slice(cache.borrow().buffer());
+    })
+}
+
+#[cfg(feature = "http1")]
+pub(crate) fn update() {
+    CACHED.with(|cache| {
+        cache.borrow_mut().check();
+    })
+}
+
+#[cfg(feature = "http2")]
+pub(crate) fn update_and_header_value() -> HeaderValue {
+    CACHED.with(|cache| {
+        let mut cache = cache.borrow_mut();
+        cache.check();
+        HeaderValue::from_bytes(cache.buffer()).expect("Date format should be valid HeaderValue")
+    })
+}
+
+struct CachedDate {
+    bytes: [u8; DATE_VALUE_LENGTH],
+    pos: usize,
+    next_update: SystemTime,
+}
+
+thread_local!(static CACHED: RefCell<CachedDate> = RefCell::new(CachedDate::new()));
+
+impl CachedDate {
+    fn new() -> Self {
+        let mut cache = CachedDate {
+            bytes: [0; DATE_VALUE_LENGTH],
+            pos: 0,
+            next_update: SystemTime::now(),
+        };
+        cache.update(cache.next_update);
+        cache
+    }
+
+    fn buffer(&self) -> &[u8] {
+        &self.bytes[..]
+    }
+
+    fn check(&mut self) {
+        let now = SystemTime::now();
+        if now > self.next_update {
+            self.update(now);
+        }
+    }
+
+    fn update(&mut self, now: SystemTime) {
+        self.render(now);
+        self.next_update = now + Duration::new(1, 0);
+    }
+
+    fn render(&mut self, now: SystemTime) {
+        self.pos = 0;
+        let _ = write!(self, "{}", HttpDate::from(now));
+        debug_assert!(self.pos == DATE_VALUE_LENGTH);
+    }
+}
+
+impl fmt::Write for CachedDate {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let len = s.len();
+        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
+        self.pos += len;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(feature = "nightly")]
+    use test::Bencher;
+
+    #[test]
+    fn test_date_len() {
+        assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_date_check(b: &mut Bencher) {
+        let mut date = CachedDate::new();
+        // cache the first update
+        date.check();
+
+        b.iter(|| {
+            date.check();
+        });
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_date_render(b: &mut Bencher) {
+        let mut date = CachedDate::new();
+        let now = SystemTime::now();
+        date.render(now);
+        b.bytes = date.buffer().len() as u64;
+
+        b.iter(|| {
+            date.render(now);
+            test::black_box(&date);
+        });
+    }
+}
diff --git a/hyper/src/common/drain.rs b/hyper/src/common/drain.rs
new file mode 100644
index 0000000..174da87
--- /dev/null
+++ b/hyper/src/common/drain.rs
@@ -0,0 +1,217 @@
+use std::mem;
+
+use pin_project_lite::pin_project;
+use tokio::sync::watch;
+
+use super::{task, Future, Pin, Poll};
+
+pub(crate) fn channel() -> (Signal, Watch) {
+    let (tx, rx) = watch::channel(());
+    (Signal { tx }, Watch { rx })
+}
+
+pub(crate) struct Signal {
+    tx: watch::Sender<()>,
+}
+
+pub(crate) struct Draining(Pin<Box<dyn Future<Output = ()> + Send + Sync>>);
+
+#[derive(Clone)]
+pub(crate) struct Watch {
+    rx: watch::Receiver<()>,
+}
+
+pin_project! {
+    #[allow(missing_debug_implementations)]
+    pub struct Watching<F, FN> {
+        #[pin]
+        future: F,
+        state: State<FN>,
+        watch: Pin<Box<dyn Future<Output = ()> + Send + Sync>>,
+        _rx: watch::Receiver<()>,
+    }
+}
+
+enum State<F> {
+    Watch(F),
+    Draining,
+}
+
+impl Signal {
+    pub(crate) fn drain(self) -> Draining {
+        let _ = self.tx.send(());
+        Draining(Box::pin(async move { self.tx.closed().await }))
+    }
+}
+
+impl Future for Draining {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.as_mut().0).poll(cx)
+    }
+}
+
+impl Watch {
+    pub(crate) fn watch<F, FN>(self, future: F, on_drain: FN) -> Watching<F, FN>
+    where
+        F: Future,
+        FN: FnOnce(Pin<&mut F>),
+    {
+        let Self { mut rx } = self;
+        let _rx = rx.clone();
+        Watching {
+            future,
+            state: State::Watch(on_drain),
+            watch: Box::pin(async move {
+                let _ = rx.changed().await;
+            }),
+            // Keep the receiver alive until the future completes, so that
+            // dropping it can signal that draining has completed.
+            _rx,
+        }
+    }
+}
+
+impl<F, FN> Future for Watching<F, FN>
+where
+    F: Future,
+    FN: FnOnce(Pin<&mut F>),
+{
+    type Output = F::Output;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut me = self.project();
+        loop {
+            match mem::replace(me.state, State::Draining) {
+                State::Watch(on_drain) => {
+                    match Pin::new(&mut me.watch).poll(cx) {
+                        Poll::Ready(()) => {
+                            // Drain has been triggered!
+                            on_drain(me.future.as_mut());
+                        }
+                        Poll::Pending => {
+                            *me.state = State::Watch(on_drain);
+                            return me.future.poll(cx);
+                        }
+                    }
+                }
+                State::Draining => return me.future.poll(cx),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct TestMe {
+        draining: bool,
+        finished: bool,
+        poll_cnt: usize,
+    }
+
+    impl Future for TestMe {
+        type Output = ();
+
+        fn poll(mut self: Pin<&mut Self>, _: &mut task::Context<'_>) -> Poll<Self::Output> {
+            self.poll_cnt += 1;
+            if self.finished {
+                Poll::Ready(())
+            } else {
+                Poll::Pending
+            }
+        }
+    }
+
+    #[test]
+    fn watch() {
+        let mut mock = tokio_test::task::spawn(());
+        mock.enter(|cx, _| {
+            let (tx, rx) = channel();
+            let fut = TestMe {
+                draining: false,
+                finished: false,
+                poll_cnt: 0,
+            };
+
+            let mut watch = rx.watch(fut, |mut fut| {
+                fut.draining = true;
+            });
+
+            assert_eq!(watch.future.poll_cnt, 0);
+
+            // First poll should poll the inner future
+            assert!(Pin::new(&mut watch).poll(cx).is_pending());
+            assert_eq!(watch.future.poll_cnt, 1);
+
+            // Second poll should poll the inner future again
+            assert!(Pin::new(&mut watch).poll(cx).is_pending());
+            assert_eq!(watch.future.poll_cnt, 2);
+
+            let mut draining = tx.drain();
+            // Drain signaled, but needs another poll to be noticed.
+            assert!(!watch.future.draining);
+            assert_eq!(watch.future.poll_cnt, 2);
+
+            // Now, poll after drain has been signaled.
+            assert!(Pin::new(&mut watch).poll(cx).is_pending());
+            assert_eq!(watch.future.poll_cnt, 3);
+            assert!(watch.future.draining);
+
+            // Draining is not ready until watcher completes
+            assert!(Pin::new(&mut draining).poll(cx).is_pending());
+
+            // Finishing up the watch future
+            watch.future.finished = true;
+            assert!(Pin::new(&mut watch).poll(cx).is_ready());
+            assert_eq!(watch.future.poll_cnt, 4);
+            drop(watch);
+
+            assert!(Pin::new(&mut draining).poll(cx).is_ready());
+        })
+    }
+
+    #[test]
+    fn watch_clones() {
+        let mut mock = tokio_test::task::spawn(());
+        mock.enter(|cx, _| {
+            let (tx, rx) = channel();
+
+            let fut1 = TestMe {
+                draining: false,
+                finished: false,
+                poll_cnt: 0,
+            };
+            let fut2 = TestMe {
+                draining: false,
+                finished: false,
+                poll_cnt: 0,
+            };
+
+            let watch1 = rx.clone().watch(fut1, |mut fut| {
+                fut.draining = true;
+            });
+            let watch2 = rx.watch(fut2, |mut fut| {
+                fut.draining = true;
+            });
+
+            let mut draining = tx.drain();
+
+            // Still 2 outstanding watchers
+            assert!(Pin::new(&mut draining).poll(cx).is_pending());
+
+            // drop 1 for whatever reason
+            drop(watch1);
+
+            // Still not ready, 1 other watcher still pending
+            assert!(Pin::new(&mut draining).poll(cx).is_pending());
+
+            drop(watch2);
+
+            // Now all watchers are gone, draining is complete
+            assert!(Pin::new(&mut draining).poll(cx).is_ready());
+        });
+    }
+}
diff --git a/hyper/src/common/exec.rs b/hyper/src/common/exec.rs
new file mode 100644
index 0000000..b2f8f37
--- /dev/null
+++ b/hyper/src/common/exec.rs
@@ -0,0 +1,116 @@
+use std::fmt;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+use crate::body::Body;
+#[cfg(feature = "server")]
+use crate::body::HttpBody;
+#[cfg(all(feature = "http2", feature = "server"))]
+use crate::proto::h2::server::H2Stream;
+use crate::rt::Executor;
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+use crate::server::server::{new_svc::NewSvcTask, Watcher};
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+use crate::service::HttpService;
+#[cfg(feature = "server")]
+pub trait ConnStreamExec<F, B: HttpBody>: Clone {
+    fn execute_h2stream(&mut self, fut: H2Stream<F, B>);
+}
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+pub trait NewSvcExec<I, N, S: HttpService<Body>, E, W: Watcher<I, S, E>>: Clone {
+    fn execute_new_svc(&mut self, fut: NewSvcTask<I, N, S, E, W>);
+}
+pub(crate) type BoxSendFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
+#[derive(Clone)]
+pub enum Exec {
+    Default,
+    Executor(Arc<dyn Executor<BoxSendFuture> + Send + Sync>),
+}
+impl Exec {
+    pub(crate) fn execute<F>(&self, fut: F)
+    where
+        F: Future<Output = ()> + Send + 'static,
+    {
+        match *self {
+            Exec::Default => {
+                #[cfg(feature = "tcp")]
+                {
+                    tokio::task::spawn(fut);
+                }
+                #[cfg(not(feature = "tcp"))] { panic!("executor must be set") }
+            }
+            Exec::Executor(ref e) => {
+                e.execute(Box::pin(fut));
+            }
+        }
+    }
+}
+impl fmt::Debug for Exec {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Exec").finish()
+    }
+}
+#[cfg(feature = "server")]
+impl<F, B> ConnStreamExec<F, B> for Exec
+where
+    H2Stream<F, B>: Future<Output = ()> + Send + 'static,
+    B: HttpBody,
+{
+    fn execute_h2stream(&mut self, fut: H2Stream<F, B>) {
+        self.execute(fut)
+    }
+}
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+impl<I, N, S, E, W> NewSvcExec<I, N, S, E, W> for Exec
+where
+    NewSvcTask<I, N, S, E, W>: Future<Output = ()> + Send + 'static,
+    S: HttpService<Body>,
+    W: Watcher<I, S, E>,
+{
+    fn execute_new_svc(&mut self, fut: NewSvcTask<I, N, S, E, W>) {
+        loop {}
+    }
+}
+#[cfg(feature = "server")]
+impl<E, F, B> ConnStreamExec<F, B> for E
+where
+    E: Executor<H2Stream<F, B>> + Clone,
+    H2Stream<F, B>: Future<Output = ()>,
+    B: HttpBody,
+{
+    fn execute_h2stream(&mut self, fut: H2Stream<F, B>) {
+        self.execute(fut)
+    }
+}
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+impl<I, N, S, E, W> NewSvcExec<I, N, S, E, W> for E
+where
+    E: Executor<NewSvcTask<I, N, S, E, W>> + Clone,
+    NewSvcTask<I, N, S, E, W>: Future<Output = ()>,
+    S: HttpService<Body>,
+    W: Watcher<I, S, E>,
+{
+    fn execute_new_svc(&mut self, fut: NewSvcTask<I, N, S, E, W>) {
+        loop {}
+    }
+}
+#[cfg(not(feature = "http2"))]
+#[allow(missing_debug_implementations)]
+pub(crate) struct H2Stream<F, B>(std::marker::PhantomData<(F, B)>);
+#[cfg(not(feature = "http2"))]
+impl<F, B, E> Future for H2Stream<F, B>
+where
+    F: Future<Output = Result<http::Response<B>, E>>,
+    B: crate::body::HttpBody,
+    B::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    E: Into<Box<dyn std::error::Error + Send + Sync>>,
+{
+    type Output = ();
+    fn poll(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Self::Output> {
+        unreachable!()
+    }
+}
diff --git a/hyper/src/common/io/mod.rs b/hyper/src/common/io/mod.rs
new file mode 100644
index 0000000..2e6d506
--- /dev/null
+++ b/hyper/src/common/io/mod.rs
@@ -0,0 +1,3 @@
+mod rewind;
+
+pub(crate) use self::rewind::Rewind;
diff --git a/hyper/src/common/io/rewind.rs b/hyper/src/common/io/rewind.rs
new file mode 100644
index 0000000..0afef5f
--- /dev/null
+++ b/hyper/src/common/io/rewind.rs
@@ -0,0 +1,155 @@
+use std::marker::Unpin;
+use std::{cmp, io};
+
+use bytes::{Buf, Bytes};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+
+use crate::common::{task, Pin, Poll};
+
+/// Combine a buffer with an IO, rewinding reads to use the buffer.
+#[derive(Debug)]
+pub(crate) struct Rewind<T> {
+    pre: Option<Bytes>,
+    inner: T,
+}
+
+impl<T> Rewind<T> {
+    #[cfg(any(all(feature = "http2", feature = "server"), test))]
+    pub(crate) fn new(io: T) -> Self {
+        Rewind {
+            pre: None,
+            inner: io,
+        }
+    }
+
+    pub(crate) fn new_buffered(io: T, buf: Bytes) -> Self {
+        Rewind {
+            pre: Some(buf),
+            inner: io,
+        }
+    }
+
+    #[cfg(any(all(feature = "http1", feature = "http2", feature = "server"), test))]
+    pub(crate) fn rewind(&mut self, bs: Bytes) {
+        debug_assert!(self.pre.is_none());
+        self.pre = Some(bs);
+    }
+
+    pub(crate) fn into_inner(self) -> (T, Bytes) {
+        (self.inner, self.pre.unwrap_or_else(Bytes::new))
+    }
+
+    // pub(crate) fn get_mut(&mut self) -> &mut T {
+    //     &mut self.inner
+    // }
+}
+
+impl<T> AsyncRead for Rewind<T>
+where
+    T: AsyncRead + Unpin,
+{
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if let Some(mut prefix) = self.pre.take() {
+            // If there are no remaining bytes, let the bytes get dropped.
+            if !prefix.is_empty() {
+                let copy_len = cmp::min(prefix.len(), buf.remaining());
+                // TODO: There should be a way to do following two lines cleaner...
+                buf.put_slice(&prefix[..copy_len]);
+                prefix.advance(copy_len);
+                // Put back what's left
+                if !prefix.is_empty() {
+                    self.pre = Some(prefix);
+                }
+
+                return Poll::Ready(Ok(()));
+            }
+        }
+        Pin::new(&mut self.inner).poll_read(cx, buf)
+    }
+}
+
+impl<T> AsyncWrite for Rewind<T>
+where
+    T: AsyncWrite + Unpin,
+{
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.inner).poll_write(cx, buf)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.inner).poll_write_vectored(cx, bufs)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    // FIXME: re-implement tests with `async/await`, this import should
+    // trigger a warning to remind us
+    use super::Rewind;
+    use bytes::Bytes;
+    use tokio::io::AsyncReadExt;
+
+    #[tokio::test]
+    async fn partial_rewind() {
+        let underlying = [104, 101, 108, 108, 111];
+
+        let mock = tokio_test::io::Builder::new().read(&underlying).build();
+
+        let mut stream = Rewind::new(mock);
+
+        // Read off some bytes, ensure we filled o1
+        let mut buf = [0; 2];
+        stream.read_exact(&mut buf).await.expect("read1");
+
+        // Rewind the stream so that it is as if we never read in the first place.
+        stream.rewind(Bytes::copy_from_slice(&buf[..]));
+
+        let mut buf = [0; 5];
+        stream.read_exact(&mut buf).await.expect("read1");
+
+        // At this point we should have read everything that was in the MockStream
+        assert_eq!(&buf, &underlying);
+    }
+
+    #[tokio::test]
+    async fn full_rewind() {
+        let underlying = [104, 101, 108, 108, 111];
+
+        let mock = tokio_test::io::Builder::new().read(&underlying).build();
+
+        let mut stream = Rewind::new(mock);
+
+        let mut buf = [0; 5];
+        stream.read_exact(&mut buf).await.expect("read1");
+
+        // Rewind the stream so that it is as if we never read in the first place.
+        stream.rewind(Bytes::copy_from_slice(&buf[..]));
+
+        let mut buf = [0; 5];
+        stream.read_exact(&mut buf).await.expect("read1");
+    }
+}
diff --git a/hyper/src/common/lazy.rs b/hyper/src/common/lazy.rs
new file mode 100644
index 0000000..2722077
--- /dev/null
+++ b/hyper/src/common/lazy.rs
@@ -0,0 +1,76 @@
+use pin_project_lite::pin_project;
+
+use super::{task, Future, Pin, Poll};
+
+pub(crate) trait Started: Future {
+    fn started(&self) -> bool;
+}
+
+pub(crate) fn lazy<F, R>(func: F) -> Lazy<F, R>
+where
+    F: FnOnce() -> R,
+    R: Future + Unpin,
+{
+    Lazy {
+        inner: Inner::Init { func },
+    }
+}
+
+// FIXME: allow() required due to `impl Trait` leaking types to this lint
+pin_project! {
+    #[allow(missing_debug_implementations)]
+    pub(crate) struct Lazy<F, R> {
+        #[pin]
+        inner: Inner<F, R>,
+    }
+}
+
+pin_project! {
+    #[project = InnerProj]
+    #[project_replace = InnerProjReplace]
+    enum Inner<F, R> {
+        Init { func: F },
+        Fut { #[pin] fut: R },
+        Empty,
+    }
+}
+
+impl<F, R> Started for Lazy<F, R>
+where
+    F: FnOnce() -> R,
+    R: Future,
+{
+    fn started(&self) -> bool {
+        match self.inner {
+            Inner::Init { .. } => false,
+            Inner::Fut { .. } | Inner::Empty => true,
+        }
+    }
+}
+
+impl<F, R> Future for Lazy<F, R>
+where
+    F: FnOnce() -> R,
+    R: Future,
+{
+    type Output = R::Output;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+
+        if let InnerProj::Fut { fut } = this.inner.as_mut().project() {
+            return fut.poll(cx);
+        }
+
+        match this.inner.as_mut().project_replace(Inner::Empty) {
+            InnerProjReplace::Init { func } => {
+                this.inner.set(Inner::Fut { fut: func() });
+                if let InnerProj::Fut { fut } = this.inner.project() {
+                    return fut.poll(cx);
+                }
+                unreachable!()
+            }
+            _ => unreachable!("lazy state wrong"),
+        }
+    }
+}
diff --git a/hyper/src/common/mod.rs b/hyper/src/common/mod.rs
new file mode 100644
index 0000000..e38c6f5
--- /dev/null
+++ b/hyper/src/common/mod.rs
@@ -0,0 +1,39 @@
+macro_rules! ready {
+    ($e:expr) => {
+        match $e {
+            std::task::Poll::Ready(v) => v,
+            std::task::Poll::Pending => return std::task::Poll::Pending,
+        }
+    };
+}
+
+pub(crate) mod buf;
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+pub(crate) mod date;
+#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
+pub(crate) mod drain;
+#[cfg(any(feature = "http1", feature = "http2", feature = "server"))]
+pub(crate) mod exec;
+pub(crate) mod io;
+#[cfg(all(feature = "client", any(feature = "http1", feature = "http2")))]
+mod lazy;
+mod never;
+#[cfg(any(
+    feature = "stream",
+    all(feature = "client", any(feature = "http1", feature = "http2"))
+))]
+pub(crate) mod sync_wrapper;
+pub(crate) mod task;
+pub(crate) mod watch;
+
+#[cfg(all(feature = "client", any(feature = "http1", feature = "http2")))]
+pub(crate) use self::lazy::{lazy, Started as Lazy};
+#[cfg(any(feature = "http1", feature = "http2", feature = "runtime"))]
+pub(crate) use self::never::Never;
+pub(crate) use self::task::Poll;
+
+// group up types normally needed for `Future`
+cfg_proto! {
+    pub(crate) use std::marker::Unpin;
+}
+pub(crate) use std::{future::Future, pin::Pin};
diff --git a/hyper/src/common/never.rs b/hyper/src/common/never.rs
new file mode 100644
index 0000000..f143caf
--- /dev/null
+++ b/hyper/src/common/never.rs
@@ -0,0 +1,21 @@
+//! An uninhabitable type meaning it can never happen.
+//!
+//! To be replaced with `!` once it is stable.
+
+use std::error::Error;
+use std::fmt;
+
+#[derive(Debug)]
+pub(crate) enum Never {}
+
+impl fmt::Display for Never {
+    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {}
+    }
+}
+
+impl Error for Never {
+    fn description(&self) -> &str {
+        match *self {}
+    }
+}
diff --git a/hyper/src/common/sync_wrapper.rs b/hyper/src/common/sync_wrapper.rs
new file mode 100644
index 0000000..704d1a6
--- /dev/null
+++ b/hyper/src/common/sync_wrapper.rs
@@ -0,0 +1,110 @@
+/*
+ * This is a copy of the sync_wrapper crate.
+ */
+
+/// A mutual exclusion primitive that relies on static type information only
+///
+/// In some cases synchronization can be proven statically: whenever you hold an exclusive `&mut`
+/// reference, the Rust type system ensures that no other part of the program can hold another
+/// reference to the data. Therefore it is safe to access it even if the current thread obtained
+/// this reference via a channel. Whenever this is the case, the overhead of allocating and locking
+/// a [`Mutex`] can be avoided by using this static version.
+///
+/// One example where this is often applicable is [`Future`], which requires an exclusive reference
+/// for its [`poll`] method: While a given `Future` implementation may not be safe to access by
+/// multiple threads concurrently, the executor can only run the `Future` on one thread at any
+/// given time, making it [`Sync`] in practice as long as the implementation is `Send`. You can
+/// therefore use the sync wrapper to prove that your data structure is `Sync` even though it
+/// contains such a `Future`.
+///
+/// # Example
+///
+/// ```ignore
+/// use hyper::common::sync_wrapper::SyncWrapper;
+/// use std::future::Future;
+///
+/// struct MyThing {
+///     future: SyncWrapper<Box<dyn Future<Output = String> + Send>>,
+/// }
+///
+/// impl MyThing {
+///     // all accesses to `self.future` now require an exclusive reference or ownership
+/// }
+///
+/// fn assert_sync<T: Sync>() {}
+///
+/// assert_sync::<MyThing>();
+/// ```
+///
+/// [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html
+/// [`Future`]: https://doc.rust-lang.org/std/future/trait.Future.html
+/// [`poll`]: https://doc.rust-lang.org/std/future/trait.Future.html#method.poll
+/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
+#[repr(transparent)]
+pub(crate) struct SyncWrapper<T>(T);
+
+impl<T> SyncWrapper<T> {
+    /// Creates a new SyncWrapper containing the given value.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// use hyper::common::sync_wrapper::SyncWrapper;
+    ///
+    /// let wrapped = SyncWrapper::new(42);
+    /// ```
+    pub(crate) fn new(value: T) -> Self {
+        Self(value)
+    }
+
+    /// Acquires a reference to the protected value.
+    ///
+    /// This is safe because it requires an exclusive reference to the wrapper. Therefore this method
+    /// neither panics nor does it return an error. This is in contrast to [`Mutex::get_mut`] which
+    /// returns an error if another thread panicked while holding the lock. It is not recommended
+    /// to send an exclusive reference to a potentially damaged value to another thread for further
+    /// processing.
+    ///
+    /// [`Mutex::get_mut`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html#method.get_mut
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// use hyper::common::sync_wrapper::SyncWrapper;
+    ///
+    /// let mut wrapped = SyncWrapper::new(42);
+    /// let value = wrapped.get_mut();
+    /// *value = 0;
+    /// assert_eq!(*wrapped.get_mut(), 0);
+    /// ```
+    pub(crate) fn get_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+
+    /// Consumes this wrapper, returning the underlying data.
+    ///
+    /// This is safe because it requires ownership of the wrapper, aherefore this method will neither
+    /// panic nor does it return an error. This is in contrast to [`Mutex::into_inner`] which
+    /// returns an error if another thread panicked while holding the lock. It is not recommended
+    /// to send an exclusive reference to a potentially damaged value to another thread for further
+    /// processing.
+    ///
+    /// [`Mutex::into_inner`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html#method.into_inner
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// use hyper::common::sync_wrapper::SyncWrapper;
+    ///
+    /// let mut wrapped = SyncWrapper::new(42);
+    /// assert_eq!(wrapped.into_inner(), 42);
+    /// ```
+    #[allow(dead_code)]
+    pub(crate) fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+// this is safe because the only operations permitted on this data structure require exclusive
+// access or ownership
+unsafe impl<T: Send> Sync for SyncWrapper<T> {}
diff --git a/hyper/src/common/task.rs b/hyper/src/common/task.rs
new file mode 100644
index 0000000..ec70c95
--- /dev/null
+++ b/hyper/src/common/task.rs
@@ -0,0 +1,12 @@
+#[cfg(feature = "http1")]
+use super::Never;
+pub(crate) use std::task::{Context, Poll};
+
+/// A function to help "yield" a future, such that it is re-scheduled immediately.
+///
+/// Useful for spin counts, so a future doesn't hog too much time.
+#[cfg(feature = "http1")]
+pub(crate) fn yield_now(cx: &mut Context<'_>) -> Poll<Never> {
+    cx.waker().wake_by_ref();
+    Poll::Pending
+}
diff --git a/hyper/src/common/watch.rs b/hyper/src/common/watch.rs
new file mode 100644
index 0000000..ba17d55
--- /dev/null
+++ b/hyper/src/common/watch.rs
@@ -0,0 +1,73 @@
+//! An SPSC broadcast channel.
+//!
+//! - The value can only be a `usize`.
+//! - The consumer is only notified if the value is different.
+//! - The value `0` is reserved for closed.
+
+use futures_util::task::AtomicWaker;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
+use std::task;
+
+type Value = usize;
+
+pub(crate) const CLOSED: usize = 0;
+
+pub(crate) fn channel(initial: Value) -> (Sender, Receiver) {
+    debug_assert!(
+        initial != CLOSED,
+        "watch::channel initial state of 0 is reserved"
+    );
+
+    let shared = Arc::new(Shared {
+        value: AtomicUsize::new(initial),
+        waker: AtomicWaker::new(),
+    });
+
+    (
+        Sender {
+            shared: shared.clone(),
+        },
+        Receiver { shared },
+    )
+}
+
+pub(crate) struct Sender {
+    shared: Arc<Shared>,
+}
+
+pub(crate) struct Receiver {
+    shared: Arc<Shared>,
+}
+
+struct Shared {
+    value: AtomicUsize,
+    waker: AtomicWaker,
+}
+
+impl Sender {
+    pub(crate) fn send(&mut self, value: Value) {
+        if self.shared.value.swap(value, Ordering::SeqCst) != value {
+            self.shared.waker.wake();
+        }
+    }
+}
+
+impl Drop for Sender {
+    fn drop(&mut self) {
+        self.send(CLOSED);
+    }
+}
+
+impl Receiver {
+    pub(crate) fn load(&mut self, cx: &mut task::Context<'_>) -> Value {
+        self.shared.waker.register(cx.waker());
+        self.shared.value.load(Ordering::SeqCst)
+    }
+
+    pub(crate) fn peek(&self) -> Value {
+        self.shared.value.load(Ordering::Relaxed)
+    }
+}
diff --git a/hyper/src/error.rs b/hyper/src/error.rs
new file mode 100644
index 0000000..18c23c6
--- /dev/null
+++ b/hyper/src/error.rs
@@ -0,0 +1,558 @@
+//! Error and Result module.
+use std::error::Error as StdError;
+use std::fmt;
+/// Result type often returned from methods that can have hyper `Error`s.
+pub type Result<T> = std::result::Result<T, Error>;
+type Cause = Box<dyn StdError + Send + Sync>;
+/// Represents errors that can occur handling HTTP streams.
+pub struct Error {
+    inner: Box<ErrorImpl>,
+}
+struct ErrorImpl {
+    kind: Kind,
+    cause: Option<Cause>,
+}
+#[derive(Debug)]
+pub(super) enum Kind {
+    Parse(Parse),
+    User(User),
+    /// A message reached EOF, but is not complete.
+    #[allow(unused)]
+    IncompleteMessage,
+    /// A connection received a message (or bytes) when not waiting for one.
+    #[cfg(feature = "http1")]
+    UnexpectedMessage,
+    /// A pending item was dropped before ever being processed.
+    Canceled,
+    /// Indicates a channel (client or body sender) is closed.
+    ChannelClosed,
+    /// An `io::Error` that occurred while trying to read or write to a network stream.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    Io,
+    /// Error occurred while connecting.
+    #[allow(unused)]
+    Connect,
+    /// Error creating a TcpListener.
+    #[cfg(all(feature = "tcp", feature = "server"))]
+    Listen,
+    /// Error accepting on an Incoming stream.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "server")]
+    Accept,
+    /// User took too long to send headers
+    #[cfg(all(feature = "http1", feature = "server", feature = "runtime"))]
+    HeaderTimeout,
+    /// Error while reading a body from connection.
+    #[cfg(any(feature = "http1", feature = "http2", feature = "stream"))]
+    Body,
+    /// Error while writing a body to connection.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    BodyWrite,
+    /// Error calling AsyncWrite::shutdown()
+    #[cfg(feature = "http1")]
+    Shutdown,
+    /// A general error from h2.
+    #[cfg(feature = "http2")]
+    Http2,
+}
+#[derive(Debug)]
+pub(super) enum Parse {
+    Method,
+    Version,
+    #[cfg(feature = "http1")]
+    VersionH2,
+    Uri,
+    #[cfg_attr(not(all(feature = "http1", feature = "server")), allow(unused))]
+    UriTooLong,
+    Header(Header),
+    TooLarge,
+    Status,
+    #[cfg_attr(debug_assertions, allow(unused))]
+    Internal,
+}
+#[derive(Debug)]
+pub(super) enum Header {
+    Token,
+    #[cfg(feature = "http1")]
+    ContentLengthInvalid,
+    #[cfg(all(feature = "http1", feature = "server"))]
+    TransferEncodingInvalid,
+    #[cfg(feature = "http1")]
+    TransferEncodingUnexpected,
+}
+#[derive(Debug)]
+pub(super) enum User {
+    /// Error calling user's HttpBody::poll_data().
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    Body,
+    /// The user aborted writing of the outgoing body.
+    BodyWriteAborted,
+    /// Error calling user's MakeService.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "server")]
+    MakeService,
+    /// Error from future of user's Service.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    Service,
+    /// User tried to send a certain header in an unexpected context.
+    ///
+    /// For example, sending both `content-length` and `transfer-encoding`.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "server")]
+    UnexpectedHeader,
+    /// User tried to create a Request with bad version.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    UnsupportedVersion,
+    /// User tried to create a CONNECT Request with the Client.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    UnsupportedRequestMethod,
+    /// User tried to respond with a 1xx (not 101) response code.
+    #[cfg(feature = "http1")]
+    #[cfg(feature = "server")]
+    UnsupportedStatusCode,
+    /// User tried to send a Request with Client with non-absolute URI.
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    AbsoluteUriRequired,
+    /// User tried polling for an upgrade that doesn't exist.
+    NoUpgrade,
+    /// User polled for an upgrade, but low-level API is not using upgrades.
+    #[cfg(feature = "http1")]
+    ManualUpgrade,
+    /// User called `server::Connection::without_shutdown()` on an HTTP/2 conn.
+    #[cfg(feature = "server")]
+    WithoutShutdownNonHttp1,
+    /// The dispatch task is gone.
+    #[cfg(feature = "client")]
+    DispatchGone,
+    /// User aborted in an FFI callback.
+    #[cfg(feature = "ffi")]
+    AbortedByCallback,
+}
+#[derive(Debug)]
+pub(super) struct TimedOut;
+impl Error {
+    /// Returns true if this was an HTTP parse error.
+    pub(crate) fn is_parse(&self) -> bool {
+        matches!(self.inner.kind, Kind::Parse(_))
+    }
+    /// Returns true if this was an HTTP parse error caused by a message that was too large.
+    pub(crate) fn is_parse_too_large(&self) -> bool {
+        matches!(
+            self.inner.kind, Kind::Parse(Parse::TooLarge) |
+            Kind::Parse(Parse::UriTooLong)
+        )
+    }
+    /// Returns true if this was an HTTP parse error caused by an invalid response status code or
+    /// reason phrase.
+    pub(crate) fn is_parse_status(&self) -> bool {
+        matches!(self.inner.kind, Kind::Parse(Parse::Status))
+    }
+    /// Returns true if this error was caused by user code.
+    pub(crate) fn is_user(&self) -> bool {
+        matches!(self.inner.kind, Kind::User(_))
+    }
+    /// Returns true if this was about a `Request` that was canceled.
+    pub(crate) fn is_canceled(&self) -> bool {
+        matches!(self.inner.kind, Kind::Canceled)
+    }
+    /// Returns true if a sender's channel is closed.
+    pub(crate) fn is_closed(&self) -> bool {
+        matches!(self.inner.kind, Kind::ChannelClosed)
+    }
+    /// Returns true if this was an error from `Connect`.
+    pub(crate) fn is_connect(&self) -> bool {
+        matches!(self.inner.kind, Kind::Connect)
+    }
+    /// Returns true if the connection closed before a message could complete.
+    pub(crate) fn is_incomplete_message(&self) -> bool {
+        matches!(self.inner.kind, Kind::IncompleteMessage)
+    }
+    /// Returns true if the body write was aborted.
+    pub(crate) fn is_body_write_aborted(&self) -> bool {
+        matches!(self.inner.kind, Kind::User(User::BodyWriteAborted))
+    }
+    /// Returns true if the error was caused by a timeout.
+    pub(crate) fn is_timeout(&self) -> bool {
+        self.find_source::<TimedOut>().is_some()
+    }
+    /// Consumes the error, returning its cause.
+    pub(crate) fn into_cause(self) -> Option<Box<dyn StdError + Send + Sync>> {
+        self.inner.cause
+    }
+    pub(super) fn new(kind: Kind) -> Error {
+        Error {
+            inner: Box::new(ErrorImpl { kind, cause: None }),
+        }
+    }
+    pub(super) fn with<C: Into<Cause>>(mut self, cause: C) -> Error {
+        self.inner.cause = Some(cause.into());
+        self
+    }
+    #[cfg(any(all(feature = "http1", feature = "server"), feature = "ffi"))]
+    pub(super) fn kind(&self) -> &Kind {
+        &self.inner.kind
+    }
+    pub(crate) fn find_source<E: StdError + 'static>(&self) -> Option<&E> {
+        let mut cause = self.source();
+        while let Some(err) = cause {
+            if let Some(ref typed) = err.downcast_ref() {
+                return Some(typed);
+            }
+            cause = err.source();
+        }
+        None
+    }
+    #[cfg(feature = "http2")]
+    pub(super) fn h2_reason(&self) -> h2::Reason {
+        self.find_source::<h2::Error>()
+            .and_then(|h2_err| h2_err.reason())
+            .unwrap_or(h2::Reason::INTERNAL_ERROR)
+    }
+    pub(super) fn new_canceled() -> Error {
+        Error::new(Kind::Canceled)
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn new_incomplete() -> Error {
+        Error::new(Kind::IncompleteMessage)
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn new_too_large() -> Error {
+        Error::new(Kind::Parse(Parse::TooLarge))
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn new_version_h2() -> Error {
+        Error::new(Kind::Parse(Parse::VersionH2))
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn new_unexpected_message() -> Error {
+        Error::new(Kind::UnexpectedMessage)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    pub(super) fn new_io(cause: std::io::Error) -> Error {
+        Error::new(Kind::Io).with(cause)
+    }
+    #[cfg(all(feature = "server", feature = "tcp"))]
+    pub(super) fn new_listen<E: Into<Cause>>(cause: E) -> Error {
+        Error::new(Kind::Listen).with(cause)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "server")]
+    pub(super) fn new_accept<E: Into<Cause>>(cause: E) -> Error {
+        Error::new(Kind::Accept).with(cause)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    pub(super) fn new_connect<E: Into<Cause>>(cause: E) -> Error {
+        Error::new(Kind::Connect).with(cause)
+    }
+    pub(super) fn new_closed() -> Error {
+        Error::new(Kind::ChannelClosed)
+    }
+    #[cfg(any(feature = "http1", feature = "http2", feature = "stream"))]
+    pub(super) fn new_body<E: Into<Cause>>(cause: E) -> Error {
+        Error::new(Kind::Body).with(cause)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    pub(super) fn new_body_write<E: Into<Cause>>(cause: E) -> Error {
+        Error::new(Kind::BodyWrite).with(cause)
+    }
+    pub(super) fn new_body_write_aborted() -> Error {
+        Error::new(Kind::User(User::BodyWriteAborted))
+    }
+    fn new_user(user: User) -> Error {
+        Error::new(Kind::User(user))
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "server")]
+    pub(super) fn new_user_header() -> Error {
+        Error::new_user(User::UnexpectedHeader)
+    }
+    #[cfg(all(feature = "http1", feature = "server", feature = "runtime"))]
+    pub(super) fn new_header_timeout() -> Error {
+        Error::new(Kind::HeaderTimeout)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    pub(super) fn new_user_unsupported_version() -> Error {
+        Error::new_user(User::UnsupportedVersion)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    pub(super) fn new_user_unsupported_request_method() -> Error {
+        Error::new_user(User::UnsupportedRequestMethod)
+    }
+    #[cfg(feature = "http1")]
+    #[cfg(feature = "server")]
+    pub(super) fn new_user_unsupported_status_code() -> Error {
+        Error::new_user(User::UnsupportedStatusCode)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "client")]
+    pub(super) fn new_user_absolute_uri_required() -> Error {
+        Error::new_user(User::AbsoluteUriRequired)
+    }
+    pub(super) fn new_user_no_upgrade() -> Error {
+        Error::new_user(User::NoUpgrade)
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn new_user_manual_upgrade() -> Error {
+        Error::new_user(User::ManualUpgrade)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    #[cfg(feature = "server")]
+    pub(super) fn new_user_make_service<E: Into<Cause>>(cause: E) -> Error {
+        Error::new_user(User::MakeService).with(cause)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    pub(super) fn new_user_service<E: Into<Cause>>(cause: E) -> Error {
+        Error::new_user(User::Service).with(cause)
+    }
+    #[cfg(any(feature = "http1", feature = "http2"))]
+    pub(super) fn new_user_body<E: Into<Cause>>(cause: E) -> Error {
+        Error::new_user(User::Body).with(cause)
+    }
+    #[cfg(feature = "server")]
+    pub(super) fn new_without_shutdown_not_h1() -> Error {
+        Error::new(Kind::User(User::WithoutShutdownNonHttp1))
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn new_shutdown(cause: std::io::Error) -> Error {
+        Error::new(Kind::Shutdown).with(cause)
+    }
+    #[cfg(feature = "ffi")]
+    pub(super) fn new_user_aborted_by_callback() -> Error {
+        Error::new_user(User::AbortedByCallback)
+    }
+    #[cfg(feature = "client")]
+    pub(super) fn new_user_dispatch_gone() -> Error {
+        Error::new(Kind::User(User::DispatchGone))
+    }
+    #[cfg(feature = "http2")]
+    pub(super) fn new_h2(cause: ::h2::Error) -> Error {
+        if cause.is_io() {
+            Error::new_io(cause.into_io().expect("h2::Error::is_io"))
+        } else {
+            Error::new(Kind::Http2).with(cause)
+        }
+    }
+    /// The error's standalone message, without the message from the source.
+    pub(crate) fn message(&self) -> impl fmt::Display + '_ {
+        self.description()
+    }
+    fn description(&self) -> &str {
+        match self.inner.kind {
+            Kind::Parse(Parse::Method) => "invalid HTTP method parsed",
+            Kind::Parse(Parse::Version) => "invalid HTTP version parsed",
+            #[cfg(feature = "http1")]
+            Kind::Parse(Parse::VersionH2) => {
+                "invalid HTTP version parsed (found HTTP2 preface)"
+            }
+            Kind::Parse(Parse::Uri) => "invalid URI",
+            Kind::Parse(Parse::UriTooLong) => "URI too long",
+            Kind::Parse(Parse::Header(Header::Token)) => "invalid HTTP header parsed",
+            #[cfg(feature = "http1")]
+            Kind::Parse(Parse::Header(Header::ContentLengthInvalid)) => {
+                "invalid content-length parsed"
+            }
+            #[cfg(all(feature = "http1", feature = "server"))]
+            Kind::Parse(Parse::Header(Header::TransferEncodingInvalid)) => {
+                "invalid transfer-encoding parsed"
+            }
+            #[cfg(feature = "http1")]
+            Kind::Parse(Parse::Header(Header::TransferEncodingUnexpected)) => {
+                "unexpected transfer-encoding parsed"
+            }
+            Kind::Parse(Parse::TooLarge) => "message head is too large",
+            Kind::Parse(Parse::Status) => "invalid HTTP status-code parsed",
+            Kind::Parse(Parse::Internal) => {
+                "internal error inside Hyper and/or its dependencies, please report"
+            }
+            Kind::IncompleteMessage => "connection closed before message completed",
+            #[cfg(feature = "http1")]
+            Kind::UnexpectedMessage => "received unexpected message from connection",
+            Kind::ChannelClosed => "channel closed",
+            Kind::Connect => "error trying to connect",
+            Kind::Canceled => "operation was canceled",
+            #[cfg(all(feature = "server", feature = "tcp"))]
+            Kind::Listen => "error creating server listener",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "server")]
+            Kind::Accept => "error accepting connection",
+            #[cfg(all(feature = "http1", feature = "server", feature = "runtime"))]
+            Kind::HeaderTimeout => "read header from client timeout",
+            #[cfg(any(feature = "http1", feature = "http2", feature = "stream"))]
+            Kind::Body => "error reading a body from connection",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            Kind::BodyWrite => "error writing a body to connection",
+            #[cfg(feature = "http1")]
+            Kind::Shutdown => "error shutting down connection",
+            #[cfg(feature = "http2")]
+            Kind::Http2 => "http2 error",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            Kind::Io => "connection error",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            Kind::User(User::Body) => "error from user's HttpBody stream",
+            Kind::User(User::BodyWriteAborted) => "user body write aborted",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "server")]
+            Kind::User(User::MakeService) => "error from user's MakeService",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            Kind::User(User::Service) => "error from user's Service",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "server")]
+            Kind::User(User::UnexpectedHeader) => "user sent unexpected header",
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "client")]
+            Kind::User(User::UnsupportedVersion) => {
+                "request has unsupported HTTP version"
+            }
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "client")]
+            Kind::User(User::UnsupportedRequestMethod) => {
+                "request has unsupported HTTP method"
+            }
+            #[cfg(feature = "http1")]
+            #[cfg(feature = "server")]
+            Kind::User(User::UnsupportedStatusCode) => {
+                "response has 1xx status code, not supported by server"
+            }
+            #[cfg(any(feature = "http1", feature = "http2"))]
+            #[cfg(feature = "client")]
+            Kind::User(User::AbsoluteUriRequired) => "client requires absolute-form URIs",
+            Kind::User(User::NoUpgrade) => "no upgrade available",
+            #[cfg(feature = "http1")]
+            Kind::User(User::ManualUpgrade) => {
+                "upgrade expected but low level API in use"
+            }
+            #[cfg(feature = "server")]
+            Kind::User(User::WithoutShutdownNonHttp1) => {
+                "without_shutdown() called on a non-HTTP/1 connection"
+            }
+            #[cfg(feature = "client")]
+            Kind::User(User::DispatchGone) => "dispatch task is gone",
+            #[cfg(feature = "ffi")]
+            Kind::User(User::AbortedByCallback) => {
+                "operation aborted by an application callback"
+            }
+        }
+    }
+}
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut f = f.debug_tuple("hyper::Error");
+        f.field(&self.inner.kind);
+        if let Some(ref cause) = self.inner.cause {
+            f.field(cause);
+        }
+        f.finish()
+    }
+}
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(ref cause) = self.inner.cause {
+            write!(f, "{}: {}", self.description(), cause)
+        } else {
+            f.write_str(self.description())
+        }
+    }
+}
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.inner.cause.as_ref().map(|cause| &**cause as &(dyn StdError + 'static))
+    }
+}
+#[doc(hidden)]
+impl From<Parse> for Error {
+    fn from(err: Parse) -> Error {
+        Error::new(Kind::Parse(err))
+    }
+}
+#[cfg(feature = "http1")]
+impl Parse {
+    pub(crate) fn content_length_invalid() -> Self {
+        Parse::Header(Header::ContentLengthInvalid)
+    }
+    #[cfg(all(feature = "http1", feature = "server"))]
+    pub(crate) fn transfer_encoding_invalid() -> Self {
+        Parse::Header(Header::TransferEncodingInvalid)
+    }
+    pub(crate) fn transfer_encoding_unexpected() -> Self {
+        Parse::Header(Header::TransferEncodingUnexpected)
+    }
+}
+impl From<httparse::Error> for Parse {
+    fn from(err: httparse::Error) -> Parse {
+        match err {
+            httparse::Error::HeaderName
+            | httparse::Error::HeaderValue
+            | httparse::Error::NewLine
+            | httparse::Error::Token => Parse::Header(Header::Token),
+            httparse::Error::Status => Parse::Status,
+            httparse::Error::TooManyHeaders => Parse::TooLarge,
+            httparse::Error::Version => Parse::Version,
+        }
+    }
+}
+impl From<http::method::InvalidMethod> for Parse {
+    fn from(_: http::method::InvalidMethod) -> Parse {
+        Parse::Method
+    }
+}
+impl From<http::status::InvalidStatusCode> for Parse {
+    fn from(_: http::status::InvalidStatusCode) -> Parse {
+        Parse::Status
+    }
+}
+impl From<http::uri::InvalidUri> for Parse {
+    fn from(_: http::uri::InvalidUri) -> Parse {
+        Parse::Uri
+    }
+}
+impl From<http::uri::InvalidUriParts> for Parse {
+    fn from(_: http::uri::InvalidUriParts) -> Parse {
+        Parse::Uri
+    }
+}
+#[doc(hidden)]
+trait AssertSendSync: Send + Sync + 'static {}
+#[doc(hidden)]
+impl AssertSendSync for Error {}
+impl fmt::Display for TimedOut {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("operation timed out")
+    }
+}
+impl StdError for TimedOut {}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem;
+    #[test]
+    fn error_size_of() {
+        assert_eq!(mem::size_of::< Error > (), mem::size_of::< usize > ());
+    }
+    #[cfg(feature = "http2")]
+    #[test]
+    fn h2_reason_unknown() {
+        let closed = Error::new_closed();
+        assert_eq!(closed.h2_reason(), h2::Reason::INTERNAL_ERROR);
+    }
+    #[cfg(feature = "http2")]
+    #[test]
+    fn h2_reason_one_level() {
+        let body_err = Error::new_user_body(
+            h2::Error::from(h2::Reason::ENHANCE_YOUR_CALM),
+        );
+        assert_eq!(body_err.h2_reason(), h2::Reason::ENHANCE_YOUR_CALM);
+    }
+    #[cfg(feature = "http2")]
+    #[test]
+    fn h2_reason_nested() {
+        let recvd = Error::new_h2(h2::Error::from(h2::Reason::HTTP_1_1_REQUIRED));
+        let svc_err = Error::new_user_service(recvd);
+        assert_eq!(svc_err.h2_reason(), h2::Reason::HTTP_1_1_REQUIRED);
+    }
+}
diff --git a/hyper/src/ext.rs b/hyper/src/ext.rs
new file mode 100644
index 0000000..d8f56cf
--- /dev/null
+++ b/hyper/src/ext.rs
@@ -0,0 +1,204 @@
+//! HTTP extensions.
+use bytes::Bytes;
+#[cfg(any(feature = "http1", feature = "ffi"))]
+use http::header::HeaderName;
+#[cfg(feature = "http1")]
+use http::header::{IntoHeaderName, ValueIter};
+use http::HeaderMap;
+#[cfg(feature = "ffi")]
+use std::collections::HashMap;
+#[cfg(feature = "http2")]
+use std::fmt;
+#[cfg(any(feature = "http1", feature = "ffi"))]
+mod h1_reason_phrase;
+#[cfg(any(feature = "http1", feature = "ffi"))]
+pub(crate) use h1_reason_phrase::ReasonPhrase;
+#[cfg(feature = "http2")]
+/// Represents the `:protocol` pseudo-header used by
+/// the [Extended CONNECT Protocol].
+///
+/// [Extended CONNECT Protocol]: https://datatracker.ietf.org/doc/html/rfc8441#section-4
+#[derive(Clone, Eq, PartialEq)]
+pub(crate) struct Protocol {
+    inner: h2::ext::Protocol,
+}
+#[cfg(feature = "http2")]
+impl Protocol {
+    /// Converts a static string to a protocol name.
+    pub(crate) const fn from_static(value: &'static str) -> Self {
+        Self {
+            inner: h2::ext::Protocol::from_static(value),
+        }
+    }
+    /// Returns a str representation of the header.
+    pub(crate) fn as_str(&self) -> &str {
+        self.inner.as_str()
+    }
+    #[cfg(feature = "server")]
+    pub(crate) fn from_inner(inner: h2::ext::Protocol) -> Self {
+        Self { inner }
+    }
+    pub(crate) fn into_inner(self) -> h2::ext::Protocol {
+        self.inner
+    }
+}
+#[cfg(feature = "http2")]
+impl<'a> From<&'a str> for Protocol {
+    fn from(value: &'a str) -> Self {
+        Self {
+            inner: h2::ext::Protocol::from(value),
+        }
+    }
+}
+#[cfg(feature = "http2")]
+impl AsRef<[u8]> for Protocol {
+    fn as_ref(&self) -> &[u8] {
+        self.inner.as_ref()
+    }
+}
+#[cfg(feature = "http2")]
+impl fmt::Debug for Protocol {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+/// A map from header names to their original casing as received in an HTTP message.
+///
+/// If an HTTP/1 response `res` is parsed on a connection whose option
+/// [`http1_preserve_header_case`] was set to true and the response included
+/// the following headers:
+///
+/// ```ignore
+/// x-Bread: Baguette
+/// X-BREAD: Pain
+/// x-bread: Ficelle
+/// ```
+///
+/// Then `res.extensions().get::<HeaderCaseMap>()` will return a map with:
+///
+/// ```ignore
+/// HeaderCaseMap({
+///     "x-bread": ["x-Bread", "X-BREAD", "x-bread"],
+/// })
+/// ```
+///
+/// [`http1_preserve_header_case`]: /client/struct.Client.html#method.http1_preserve_header_case
+#[derive(Clone, Debug)]
+pub(crate) struct HeaderCaseMap(HeaderMap<Bytes>);
+#[cfg(feature = "http1")]
+impl HeaderCaseMap {
+    /// Returns a view of all spellings associated with that header name,
+    /// in the order they were found.
+    pub(crate) fn get_all<'a>(
+        &'a self,
+        name: &HeaderName,
+    ) -> impl Iterator<Item = impl AsRef<[u8]> + 'a> + 'a {
+        self.get_all_internal(name).into_iter()
+    }
+    /// Returns a view of all spellings associated with that header name,
+    /// in the order they were found.
+    pub(crate) fn get_all_internal<'a>(
+        &'a self,
+        name: &HeaderName,
+    ) -> ValueIter<'_, Bytes> {
+        self.0.get_all(name).into_iter()
+    }
+    pub(crate) fn default() -> Self {
+        Self(Default::default())
+    }
+    #[cfg(any(test, feature = "ffi"))]
+    pub(crate) fn insert(&mut self, name: HeaderName, orig: Bytes) {
+        self.0.insert(name, orig);
+    }
+    pub(crate) fn append<N>(&mut self, name: N, orig: Bytes)
+    where
+        N: IntoHeaderName,
+    {
+        self.0.append(name, orig);
+    }
+}
+#[cfg(feature = "ffi")]
+#[derive(Clone, Debug)]
+/// Hashmap<Headername, numheaders with that name>
+pub(crate) struct OriginalHeaderOrder {
+    /// Stores how many entries a Headername maps to. This is used
+    /// for accounting.
+    num_entries: HashMap<HeaderName, usize>,
+    /// Stores the ordering of the headers. ex: `vec[i] = (headerName, idx)`,
+    /// The vector is ordered such that the ith element
+    /// represents the ith header that came in off the line.
+    /// The `HeaderName` and `idx` are then used elsewhere to index into
+    /// the multi map that stores the header values.
+    entry_order: Vec<(HeaderName, usize)>,
+}
+#[cfg(all(feature = "http1", feature = "ffi"))]
+impl OriginalHeaderOrder {
+    pub(crate) fn default() -> Self {
+        OriginalHeaderOrder {
+            num_entries: HashMap::new(),
+            entry_order: Vec::new(),
+        }
+    }
+    pub(crate) fn insert(&mut self, name: HeaderName) {
+        if !self.num_entries.contains_key(&name) {
+            let idx = 0;
+            self.num_entries.insert(name.clone(), 1);
+            self.entry_order.push((name, idx));
+        }
+    }
+    pub(crate) fn append<N>(&mut self, name: N)
+    where
+        N: IntoHeaderName + Into<HeaderName> + Clone,
+    {
+        let name: HeaderName = name.into();
+        let idx;
+        if self.num_entries.contains_key(&name) {
+            idx = self.num_entries[&name];
+            *self.num_entries.get_mut(&name).unwrap() += 1;
+        } else {
+            idx = 0;
+            self.num_entries.insert(name.clone(), 1);
+        }
+        self.entry_order.push((name, idx));
+    }
+    /// This returns an iterator that provides header names and indexes
+    /// in the original order received.
+    ///
+    /// # Examples
+    /// ```no_run
+    /// use hyper::ext::OriginalHeaderOrder;
+    /// use hyper::header::{HeaderName, HeaderValue, HeaderMap};
+    ///
+    /// let mut h_order = OriginalHeaderOrder::default();
+    /// let mut h_map = Headermap::new();
+    ///
+    /// let name1 = b"Set-CookiE";
+    /// let value1 = b"a=b";
+    /// h_map.append(name1);
+    /// h_order.append(name1);
+    ///
+    /// let name2 = b"Content-Encoding";
+    /// let value2 = b"gzip";
+    /// h_map.append(name2, value2);
+    /// h_order.append(name2);
+    ///
+    /// let name3 = b"SET-COOKIE";
+    /// let value3 = b"c=d";
+    /// h_map.append(name3, value3);
+    /// h_order.append(name3)
+    ///
+    /// let mut iter = h_order.get_in_order()
+    ///
+    /// let (name, idx) = iter.next();
+    /// assert_eq!(b"a=b", h_map.get_all(name).nth(idx).unwrap());
+    ///
+    /// let (name, idx) = iter.next();
+    /// assert_eq!(b"gzip", h_map.get_all(name).nth(idx).unwrap());
+    ///
+    /// let (name, idx) = iter.next();
+    /// assert_eq!(b"c=d", h_map.get_all(name).nth(idx).unwrap());
+    /// ```
+    pub(crate) fn get_in_order(&self) -> impl Iterator<Item = &(HeaderName, usize)> {
+        self.entry_order.iter()
+    }
+}
diff --git a/hyper/src/ext/h1_reason_phrase.rs b/hyper/src/ext/h1_reason_phrase.rs
new file mode 100644
index 0000000..25bb878
--- /dev/null
+++ b/hyper/src/ext/h1_reason_phrase.rs
@@ -0,0 +1,182 @@
+use std::convert::TryFrom;
+use bytes::Bytes;
+/// A reason phrase in an HTTP/1 response.
+///
+/// # Clients
+///
+/// For clients, a `ReasonPhrase` will be present in the extensions of the `http::Response` returned
+/// for a request if the reason phrase is different from the canonical reason phrase for the
+/// response's status code. For example, if a server returns `HTTP/1.1 200 Awesome`, the
+/// `ReasonPhrase` will be present and contain `Awesome`, but if a server returns `HTTP/1.1 200 OK`,
+/// the response will not contain a `ReasonPhrase`.
+///
+/// ```no_run
+/// # #[cfg(all(feature = "tcp", feature = "client", feature = "http1"))]
+/// # async fn fake_fetch() -> hyper::Result<()> {
+/// use hyper::{Client, Uri};
+/// use hyper::ext::ReasonPhrase;
+///
+/// let res = Client::new().get(Uri::from_static("http://example.com/non_canonical_reason")).await?;
+///
+/// // Print out the non-canonical reason phrase, if it has one...
+/// if let Some(reason) = res.extensions().get::<ReasonPhrase>() {
+///     println!("non-canonical reason: {}", std::str::from_utf8(reason.as_bytes()).unwrap());
+/// }
+/// # Ok(())
+/// # }
+/// ```
+///
+/// # Servers
+///
+/// When a `ReasonPhrase` is present in the extensions of the `http::Response` written by a server,
+/// its contents will be written in place of the canonical reason phrase when responding via HTTP/1.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(crate) struct ReasonPhrase(Bytes);
+impl ReasonPhrase {
+    /// Gets the reason phrase as bytes.
+    pub(crate) fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+    /// Converts a static byte slice to a reason phrase.
+    pub(crate) fn from_static(reason: &'static [u8]) -> Self {
+        if find_invalid_byte(reason).is_some() {
+            panic!("invalid byte in static reason phrase");
+        }
+        Self(Bytes::from_static(reason))
+    }
+    /// Converts a `Bytes` directly into a `ReasonPhrase` without validating.
+    ///
+    /// Use with care; invalid bytes in a reason phrase can cause serious security problems if
+    /// emitted in a response.
+    pub(crate) unsafe fn from_bytes_unchecked(reason: Bytes) -> Self {
+        Self(reason)
+    }
+}
+impl TryFrom<&[u8]> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+    fn try_from(reason: &[u8]) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(reason) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(Bytes::copy_from_slice(reason)))
+        }
+    }
+}
+impl TryFrom<Vec<u8>> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+    fn try_from(reason: Vec<u8>) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(&reason) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(Bytes::from(reason)))
+        }
+    }
+}
+impl TryFrom<String> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+    fn try_from(reason: String) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(reason.as_bytes()) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(Bytes::from(reason)))
+        }
+    }
+}
+impl TryFrom<Bytes> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+    fn try_from(reason: Bytes) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(&reason) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(reason))
+        }
+    }
+}
+impl Into<Bytes> for ReasonPhrase {
+    fn into(self) -> Bytes {
+        self.0
+    }
+}
+impl AsRef<[u8]> for ReasonPhrase {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+/// Error indicating an invalid byte when constructing a `ReasonPhrase`.
+///
+/// See [the spec][spec] for details on allowed bytes.
+///
+/// [spec]: https://httpwg.org/http-core/draft-ietf-httpbis-messaging-latest.html#rfc.section.4.p.7
+#[derive(Debug)]
+pub(crate) struct InvalidReasonPhrase {
+    bad_byte: u8,
+}
+impl std::fmt::Display for InvalidReasonPhrase {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Invalid byte in reason phrase: {}", self.bad_byte)
+    }
+}
+impl std::error::Error for InvalidReasonPhrase {}
+const fn is_valid_byte(b: u8) -> bool {
+    const fn is_vchar(b: u8) -> bool {
+        0x21 <= b && b <= 0x7E
+    }
+    #[allow(unused_comparisons)]
+    const fn is_obs_text(b: u8) -> bool {
+        0x80 <= b && b <= 0xFF
+    }
+    b == b'\t' || b == b' ' || is_vchar(b) || is_obs_text(b)
+}
+const fn find_invalid_byte(bytes: &[u8]) -> Option<u8> {
+    let mut i = 0;
+    while i < bytes.len() {
+        let b = bytes[i];
+        if !is_valid_byte(b) {
+            return Some(b);
+        }
+        i += 1;
+    }
+    None
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn basic_valid() {
+        const PHRASE: &'static [u8] = b"OK";
+        assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
+        assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
+    }
+    #[test]
+    fn empty_valid() {
+        const PHRASE: &'static [u8] = b"";
+        assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
+        assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
+    }
+    #[test]
+    fn obs_text_valid() {
+        const PHRASE: &'static [u8] = b"hyp\xe9r";
+        assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
+        assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
+    }
+    const NEWLINE_PHRASE: &'static [u8] = b"hyp\ner";
+    #[test]
+    #[should_panic]
+    fn newline_invalid_panic() {
+        ReasonPhrase::from_static(NEWLINE_PHRASE);
+    }
+    #[test]
+    fn newline_invalid_err() {
+        assert!(ReasonPhrase::try_from(NEWLINE_PHRASE).is_err());
+    }
+    const CR_PHRASE: &'static [u8] = b"hyp\rer";
+    #[test]
+    #[should_panic]
+    fn cr_invalid_panic() {
+        ReasonPhrase::from_static(CR_PHRASE);
+    }
+    #[test]
+    fn cr_invalid_err() {
+        assert!(ReasonPhrase::try_from(CR_PHRASE).is_err());
+    }
+}
diff --git a/hyper/src/ffi/body.rs b/hyper/src/ffi/body.rs
new file mode 100644
index 0000000..e99cce0
--- /dev/null
+++ b/hyper/src/ffi/body.rs
@@ -0,0 +1,174 @@
+use std::ffi::c_void;
+use std::mem::ManuallyDrop;
+use std::ptr;
+use std::task::{Context, Poll};
+use http::HeaderMap;
+use libc::{c_int, size_t};
+use super::task::{hyper_context, hyper_task, hyper_task_return_type, AsTaskType};
+use super::{UserDataPointer, HYPER_ITER_CONTINUE};
+use crate::body::{Body, Bytes, HttpBody as _};
+/// A streaming HTTP body.
+pub(crate) struct hyper_body(pub(super) Body);
+/// A buffer of bytes that is sent or received on a `hyper_body`.
+pub(crate) struct hyper_buf(pub(crate) Bytes);
+pub(crate) struct UserBody {
+    data_func: hyper_body_data_callback,
+    userdata: *mut c_void,
+}
+type hyper_body_foreach_callback = extern "C" fn(*mut c_void, *const hyper_buf) -> c_int;
+type hyper_body_data_callback = extern "C" fn(
+    *mut c_void,
+    *mut hyper_context<'_>,
+    *mut *mut hyper_buf,
+) -> c_int;
+ffi_fn! {
+    #[doc = " Create a new \"empty\" body."] #[doc = ""] #[doc =
+    " If not configured, this body acts as an empty payload."] fn hyper_body_new() -> *
+    mut hyper_body { Box::into_raw(Box::new(hyper_body(Body::empty()))) } ?=
+    ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Free a `hyper_body *`."] fn hyper_body_free(body : * mut hyper_body) {
+    drop(non_null!(Box::from_raw(body) ?= ())); }
+}
+ffi_fn! {
+    #[doc = " Return a task that will poll the body for the next buffer of data."] #[doc
+    = ""] #[doc = " The task value may have different types depending on the outcome:"]
+    #[doc = ""] #[doc = " - `HYPER_TASK_BUF`: Success, and more data was received."]
+    #[doc = " - `HYPER_TASK_ERROR`: An error retrieving the data."] #[doc =
+    " - `HYPER_TASK_EMPTY`: The body has finished streaming data."] #[doc = ""] #[doc =
+    " This does not consume the `hyper_body *`, so it may be used to again."] #[doc =
+    " However, it MUST NOT be used or freed until the related task completes."] fn
+    hyper_body_data(body : * mut hyper_body) -> * mut hyper_task { let mut body =
+    ManuallyDrop::new(non_null!(Box::from_raw(body) ?= ptr::null_mut()));
+    Box::into_raw(hyper_task::boxed(async move { body.0.data().await.map(| res | res
+    .map(hyper_buf)) })) } ?= ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Return a task that will poll the body and execute the callback with each"]
+    #[doc = " body chunk that is received."] #[doc = ""] #[doc =
+    " The `hyper_buf` pointer is only a borrowed reference, it cannot live outside"]
+    #[doc = " the execution of the callback. You must make a copy to retain it."] #[doc =
+    ""] #[doc =
+    " The callback should return `HYPER_ITER_CONTINUE` to continue iterating"] #[doc =
+    " chunks as they are received, or `HYPER_ITER_BREAK` to cancel."] #[doc = ""] #[doc =
+    " This will consume the `hyper_body *`, you shouldn't use it anymore or free it."] fn
+    hyper_body_foreach(body : * mut hyper_body, func : hyper_body_foreach_callback,
+    userdata : * mut c_void) -> * mut hyper_task { let mut body =
+    non_null!(Box::from_raw(body) ?= ptr::null_mut()); let userdata =
+    UserDataPointer(userdata); Box::into_raw(hyper_task::boxed(async move { while let
+    Some(item) = body.0.data().await { let chunk = item ?; if HYPER_ITER_CONTINUE !=
+    func(userdata.0, & hyper_buf(chunk)) { return Err(crate
+    ::Error::new_user_aborted_by_callback()); } } Ok(()) })) } ?= ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Set userdata on this body, which will be passed to callback functions."] fn
+    hyper_body_set_userdata(body : * mut hyper_body, userdata : * mut c_void) { let b =
+    non_null!(& mut * body ?= ()); b.0.as_ffi_mut().userdata = userdata; }
+}
+ffi_fn! {
+    #[doc = " Set the data callback for this body."] #[doc = ""] #[doc =
+    " The callback is called each time hyper needs to send more data for the"] #[doc =
+    " body. It is passed the value from `hyper_body_set_userdata`."] #[doc = ""] #[doc =
+    " If there is data available, the `hyper_buf **` argument should be set"] #[doc =
+    " to a `hyper_buf *` containing the data, and `HYPER_POLL_READY` should"] #[doc =
+    " be returned."] #[doc = ""] #[doc =
+    " Returning `HYPER_POLL_READY` while the `hyper_buf **` argument points"] #[doc =
+    " to `NULL` will indicate the body has completed all data."] #[doc = ""] #[doc =
+    " If there is more data to send, but it isn't yet available, a"] #[doc =
+    " `hyper_waker` should be saved from the `hyper_context *` argument, and"] #[doc =
+    " `HYPER_POLL_PENDING` should be returned. You must wake the saved waker"] #[doc =
+    " to signal the task when data is available."] #[doc = ""] #[doc =
+    " If some error has occurred, you can return `HYPER_POLL_ERROR` to abort"] #[doc =
+    " the body."] fn hyper_body_set_data_func(body : * mut hyper_body, func :
+    hyper_body_data_callback) { let b = non_null! { & mut * body ?= () }; b.0
+    .as_ffi_mut().data_func = func; }
+}
+impl UserBody {
+    pub(crate) fn new() -> UserBody {
+        UserBody {
+            data_func: data_noop,
+            userdata: std::ptr::null_mut(),
+        }
+    }
+    pub(crate) fn poll_data(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<crate::Result<Bytes>>> {
+        let mut out = std::ptr::null_mut();
+        match (self.data_func)(self.userdata, hyper_context::wrap(cx), &mut out) {
+            super::task::HYPER_POLL_READY => {
+                if out.is_null() {
+                    Poll::Ready(None)
+                } else {
+                    let buf = unsafe { Box::from_raw(out) };
+                    Poll::Ready(Some(Ok(buf.0)))
+                }
+            }
+            super::task::HYPER_POLL_PENDING => Poll::Pending,
+            super::task::HYPER_POLL_ERROR => {
+                Poll::Ready(Some(Err(crate::Error::new_body_write_aborted())))
+            }
+            unexpected => {
+                Poll::Ready(
+                    Some(
+                        Err(
+                            crate::Error::new_body_write(
+                                format!(
+                                    "unexpected hyper_body_data_func return code {}", unexpected
+                                ),
+                            ),
+                        ),
+                    ),
+                )
+            }
+        }
+    }
+    pub(crate) fn poll_trailers(
+        &mut self,
+        _cx: &mut Context<'_>,
+    ) -> Poll<crate::Result<Option<HeaderMap>>> {
+        Poll::Ready(Ok(None))
+    }
+}
+/// cbindgen:ignore
+extern "C" fn data_noop(
+    _userdata: *mut c_void,
+    _: *mut hyper_context<'_>,
+    _: *mut *mut hyper_buf,
+) -> c_int {
+    super::task::HYPER_POLL_READY
+}
+unsafe impl Send for UserBody {}
+unsafe impl Sync for UserBody {}
+ffi_fn! {
+    #[doc = " Create a new `hyper_buf *` by copying the provided bytes."] #[doc = ""]
+    #[doc = " This makes an owned copy of the bytes, so the `buf` argument can be"] #[doc
+    = " freed or changed afterwards."] #[doc = ""] #[doc =
+    " This returns `NULL` if allocating a new buffer fails."] fn hyper_buf_copy(buf : *
+    const u8, len : size_t) -> * mut hyper_buf { let slice = unsafe {
+    std::slice::from_raw_parts(buf, len) };
+    Box::into_raw(Box::new(hyper_buf(Bytes::copy_from_slice(slice)))) } ?=
+    ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Get a pointer to the bytes in this buffer."] #[doc = ""] #[doc =
+    " This should be used in conjunction with `hyper_buf_len` to get the length"] #[doc =
+    " of the bytes data."] #[doc = ""] #[doc =
+    " This pointer is borrowed data, and not valid once the `hyper_buf` is"] #[doc =
+    " consumed/freed."] fn hyper_buf_bytes(buf : * const hyper_buf) -> * const u8 {
+    unsafe { (* buf).0.as_ptr() } } ?= ptr::null()
+}
+ffi_fn! {
+    #[doc = " Get the length of the bytes this buffer contains."] fn hyper_buf_len(buf :
+    * const hyper_buf) -> size_t { unsafe { (* buf).0.len() } }
+}
+ffi_fn! {
+    #[doc = " Free this buffer."] fn hyper_buf_free(buf : * mut hyper_buf) { drop(unsafe
+    { Box::from_raw(buf) }); }
+}
+unsafe impl AsTaskType for hyper_buf {
+    fn as_task_type(&self) -> hyper_task_return_type {
+        hyper_task_return_type::HYPER_TASK_BUF
+    }
+}
diff --git a/hyper/src/ffi/client.rs b/hyper/src/ffi/client.rs
new file mode 100644
index 0000000..add3d56
--- /dev/null
+++ b/hyper/src/ffi/client.rs
@@ -0,0 +1,111 @@
+use std::ptr;
+use std::sync::Arc;
+use libc::c_int;
+use crate::client::conn;
+use crate::rt::Executor as _;
+use super::error::hyper_code;
+use super::http_types::{hyper_request, hyper_response};
+use super::io::hyper_io;
+use super::task::{
+    hyper_executor, hyper_task, hyper_task_return_type, AsTaskType, WeakExec,
+};
+/// An options builder to configure an HTTP client connection.
+pub(crate) struct hyper_clientconn_options {
+    builder: conn::Builder,
+    /// Use a `Weak` to prevent cycles.
+    exec: WeakExec,
+}
+/// An HTTP client connection handle.
+///
+/// These are used to send a request on a single connection. It's possible to
+/// send multiple requests on a single connection, such as when HTTP/1
+/// keep-alive or HTTP/2 is used.
+pub(crate) struct hyper_clientconn {
+    tx: conn::SendRequest<crate::Body>,
+}
+ffi_fn! {
+    #[doc =
+    " Starts an HTTP client connection handshake using the provided IO transport"] #[doc
+    = " and options."] #[doc = ""] #[doc =
+    " Both the `io` and the `options` are consumed in this function call."] #[doc = ""]
+    #[doc = " The returned `hyper_task *` must be polled with an executor until the"]
+    #[doc = " handshake completes, at which point the value can be taken."] fn
+    hyper_clientconn_handshake(io : * mut hyper_io, options : * mut
+    hyper_clientconn_options) -> * mut hyper_task { let options = non_null! {
+    Box::from_raw(options) ?= ptr::null_mut() }; let io = non_null! { Box::from_raw(io)
+    ?= ptr::null_mut() }; Box::into_raw(hyper_task::boxed(async move { options.builder
+    .handshake::< _, crate ::Body > (io).await.map(| (tx, conn) | { options.exec
+    .execute(Box::pin(async move { let _ = conn.await; })); hyper_clientconn { tx } })
+    })) } ?= std::ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Send a request on the client connection."] #[doc = ""] #[doc =
+    " Returns a task that needs to be polled until it is ready. When ready, the"] #[doc =
+    " task yields a `hyper_response *`."] fn hyper_clientconn_send(conn : * mut
+    hyper_clientconn, req : * mut hyper_request) -> * mut hyper_task { let mut req =
+    non_null! { Box::from_raw(req) ?= ptr::null_mut() }; req.finalize_request(); let fut
+    = non_null! { & mut * conn ?= ptr::null_mut() } .tx.send_request(req.0); let fut =
+    async move { fut.await.map(hyper_response::wrap) };
+    Box::into_raw(hyper_task::boxed(fut)) } ?= std::ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Free a `hyper_clientconn *`."] fn hyper_clientconn_free(conn : * mut
+    hyper_clientconn) { drop(non_null! { Box::from_raw(conn) ?= () }); }
+}
+unsafe impl AsTaskType for hyper_clientconn {
+    fn as_task_type(&self) -> hyper_task_return_type {
+        hyper_task_return_type::HYPER_TASK_CLIENTCONN
+    }
+}
+ffi_fn! {
+    #[doc = " Creates a new set of HTTP clientconn options to be used in a handshake."]
+    fn hyper_clientconn_options_new() -> * mut hyper_clientconn_options { let builder =
+    conn::Builder::new(); Box::into_raw(Box::new(hyper_clientconn_options { builder, exec
+    : WeakExec::new(), })) } ?= std::ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Set the whether or not header case is preserved."] #[doc = ""] #[doc =
+    " Pass `0` to allow lowercase normalization (default), `1` to retain original case."]
+    fn hyper_clientconn_options_set_preserve_header_case(opts : * mut
+    hyper_clientconn_options, enabled : c_int) { let opts = non_null! { & mut * opts ?=
+    () }; opts.builder.http1_preserve_header_case(enabled != 0); }
+}
+ffi_fn! {
+    #[doc = " Set the whether or not header order is preserved."] #[doc = ""] #[doc =
+    " Pass `0` to allow reordering (default), `1` to retain original ordering."] fn
+    hyper_clientconn_options_set_preserve_header_order(opts : * mut
+    hyper_clientconn_options, enabled : c_int) { let opts = non_null! { & mut * opts ?=
+    () }; opts.builder.http1_preserve_header_order(enabled != 0); }
+}
+ffi_fn! {
+    #[doc = " Free a `hyper_clientconn_options *`."] fn
+    hyper_clientconn_options_free(opts : * mut hyper_clientconn_options) { drop(non_null!
+    { Box::from_raw(opts) ?= () }); }
+}
+ffi_fn! {
+    #[doc = " Set the client background task executor."] #[doc = ""] #[doc =
+    " This does not consume the `options` or the `exec`."] fn
+    hyper_clientconn_options_exec(opts : * mut hyper_clientconn_options, exec : * const
+    hyper_executor) { let opts = non_null! { & mut * opts ?= () }; let exec = non_null! {
+    Arc::from_raw(exec) ?= () }; let weak_exec = hyper_executor::downgrade(& exec);
+    std::mem::forget(exec); opts.builder.executor(weak_exec.clone()); opts.exec =
+    weak_exec; }
+}
+ffi_fn! {
+    #[doc = " Set the whether to use HTTP2."] #[doc = ""] #[doc =
+    " Pass `0` to disable, `1` to enable."] fn hyper_clientconn_options_http2(opts : *
+    mut hyper_clientconn_options, enabled : c_int) -> hyper_code { #[cfg(feature =
+    "http2")] { let opts = non_null! { & mut * opts ?= hyper_code::HYPERE_INVALID_ARG };
+    opts.builder.http2_only(enabled != 0); hyper_code::HYPERE_OK } #[cfg(not(feature =
+    "http2"))] { drop(opts); drop(enabled); hyper_code::HYPERE_FEATURE_NOT_ENABLED } }
+}
+ffi_fn! {
+    #[doc = " Set the whether to include a copy of the raw headers in responses"] #[doc =
+    " received on this connection."] #[doc = ""] #[doc =
+    " Pass `0` to disable, `1` to enable."] #[doc = ""] #[doc =
+    " If enabled, see `hyper_response_headers_raw()` for usage."] fn
+    hyper_clientconn_options_headers_raw(opts : * mut hyper_clientconn_options, enabled :
+    c_int) -> hyper_code { let opts = non_null! { & mut * opts ?=
+    hyper_code::HYPERE_INVALID_ARG }; opts.builder.http1_headers_raw(enabled != 0);
+    hyper_code::HYPERE_OK }
+}
diff --git a/hyper/src/ffi/error.rs b/hyper/src/ffi/error.rs
new file mode 100644
index 0000000..0ea630e
--- /dev/null
+++ b/hyper/src/ffi/error.rs
@@ -0,0 +1,63 @@
+use libc::size_t;
+/// A more detailed error object returned by some hyper functions.
+pub(crate) struct hyper_error(crate::Error);
+/// A return code for many of hyper's methods.
+#[repr(C)]
+pub(crate) enum hyper_code {
+    /// All is well.
+    HYPERE_OK,
+    /// General error, details in the `hyper_error *`.
+    HYPERE_ERROR,
+    /// A function argument was invalid.
+    HYPERE_INVALID_ARG,
+    /// The IO transport returned an EOF when one wasn't expected.
+    ///
+    /// This typically means an HTTP request or response was expected, but the
+    /// connection closed cleanly without sending (all of) it.
+    HYPERE_UNEXPECTED_EOF,
+    /// Aborted by a user supplied callback.
+    HYPERE_ABORTED_BY_CALLBACK,
+    /// An optional hyper feature was not enabled.
+    #[cfg_attr(feature = "http2", allow(unused))]
+    HYPERE_FEATURE_NOT_ENABLED,
+    /// The peer sent an HTTP message that could not be parsed.
+    HYPERE_INVALID_PEER_MESSAGE,
+}
+impl hyper_error {
+    fn code(&self) -> hyper_code {
+        use crate::error::Kind as ErrorKind;
+        use crate::error::User;
+        match self.0.kind() {
+            ErrorKind::Parse(_) => hyper_code::HYPERE_INVALID_PEER_MESSAGE,
+            ErrorKind::IncompleteMessage => hyper_code::HYPERE_UNEXPECTED_EOF,
+            ErrorKind::User(User::AbortedByCallback) => {
+                hyper_code::HYPERE_ABORTED_BY_CALLBACK
+            }
+            _ => hyper_code::HYPERE_ERROR,
+        }
+    }
+    fn print_to(&self, dst: &mut [u8]) -> usize {
+        use std::io::Write;
+        let mut dst = std::io::Cursor::new(dst);
+        let _ = write!(dst, "{}", & self.0);
+        dst.position() as usize
+    }
+}
+ffi_fn! {
+    #[doc = " Frees a `hyper_error`."] fn hyper_error_free(err : * mut hyper_error) {
+    drop(non_null!(Box::from_raw(err) ?= ())); }
+}
+ffi_fn! {
+    #[doc = " Get an equivalent `hyper_code` from this error."] fn hyper_error_code(err :
+    * const hyper_error) -> hyper_code { non_null!(&* err ?=
+    hyper_code::HYPERE_INVALID_ARG) .code() }
+}
+ffi_fn! {
+    #[doc = " Print the details of this error to a buffer."] #[doc = ""] #[doc =
+    " The `dst_len` value must be the maximum length that the buffer can"] #[doc =
+    " store."] #[doc = ""] #[doc =
+    " The return value is number of bytes that were written to `dst`."] fn
+    hyper_error_print(err : * const hyper_error, dst : * mut u8, dst_len : size_t) ->
+    size_t { let dst = unsafe { std::slice::from_raw_parts_mut(dst, dst_len) };
+    non_null!(&* err ?= 0) .print_to(dst) }
+}
diff --git a/hyper/src/ffi/http_types.rs b/hyper/src/ffi/http_types.rs
new file mode 100644
index 0000000..db1ba40
--- /dev/null
+++ b/hyper/src/ffi/http_types.rs
@@ -0,0 +1,443 @@
+use bytes::Bytes;
+use libc::{c_int, size_t};
+use std::ffi::c_void;
+use super::body::{hyper_body, hyper_buf};
+use super::error::hyper_code;
+use super::task::{hyper_task_return_type, AsTaskType};
+use super::{UserDataPointer, HYPER_ITER_CONTINUE};
+use crate::ext::{HeaderCaseMap, OriginalHeaderOrder, ReasonPhrase};
+use crate::header::{HeaderName, HeaderValue};
+use crate::{Body, HeaderMap, Method, Request, Response, Uri};
+/// An HTTP request.
+pub(crate) struct hyper_request(pub(super) Request<Body>);
+/// An HTTP response.
+pub(crate) struct hyper_response(pub(super) Response<Body>);
+/// An HTTP header map.
+///
+/// These can be part of a request or response.
+pub(crate) struct hyper_headers {
+    pub(super) headers: HeaderMap,
+    orig_casing: HeaderCaseMap,
+    orig_order: OriginalHeaderOrder,
+}
+pub(crate) struct RawHeaders(pub(crate) hyper_buf);
+pub(crate) struct OnInformational {
+    func: hyper_request_on_informational_callback,
+    data: UserDataPointer,
+}
+type hyper_request_on_informational_callback = extern "C" fn(
+    *mut c_void,
+    *mut hyper_response,
+);
+ffi_fn! {
+    #[doc = " Construct a new HTTP request."] fn hyper_request_new() -> * mut
+    hyper_request { Box::into_raw(Box::new(hyper_request(Request::new(Body::empty())))) }
+    ?= std::ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Free an HTTP request if not going to send it on a client."] fn
+    hyper_request_free(req : * mut hyper_request) { drop(non_null!(Box::from_raw(req) ?=
+    ())); }
+}
+ffi_fn! {
+    #[doc = " Set the HTTP Method of the request."] fn hyper_request_set_method(req : *
+    mut hyper_request, method : * const u8, method_len : size_t) -> hyper_code { let
+    bytes = unsafe { std::slice::from_raw_parts(method, method_len as usize) }; let req =
+    non_null!(& mut * req ?= hyper_code::HYPERE_INVALID_ARG); match
+    Method::from_bytes(bytes) { Ok(m) => { * req.0.method_mut() = m;
+    hyper_code::HYPERE_OK }, Err(_) => { hyper_code::HYPERE_INVALID_ARG } } }
+}
+ffi_fn! {
+    #[doc = " Set the URI of the request."] #[doc = ""] #[doc =
+    " The request's URI is best described as the `request-target` from the RFCs. So in HTTP/1,"]
+    #[doc =
+    " whatever is set will get sent as-is in the first line (GET $uri HTTP/1.1). It"]
+    #[doc =
+    " supports the 4 defined variants, origin-form, absolute-form, authority-form, and"]
+    #[doc = " asterisk-form."] #[doc = ""] #[doc =
+    " The underlying type was built to efficiently support HTTP/2 where the request-target is"]
+    #[doc =
+    " split over :scheme, :authority, and :path. As such, each part can be set explicitly, or the"]
+    #[doc =
+    " type can parse a single contiguous string and if a scheme is found, that slot is \"set\". If"]
+    #[doc =
+    " the string just starts with a path, only the path portion is set. All pseudo headers that"]
+    #[doc = " have been parsed/set are sent when the connection type is HTTP/2."] #[doc =
+    ""] #[doc = " To set each slot explicitly, use `hyper_request_set_uri_parts`."] fn
+    hyper_request_set_uri(req : * mut hyper_request, uri : * const u8, uri_len : size_t)
+    -> hyper_code { let bytes = unsafe { std::slice::from_raw_parts(uri, uri_len as
+    usize) }; let req = non_null!(& mut * req ?= hyper_code::HYPERE_INVALID_ARG); match
+    Uri::from_maybe_shared(bytes) { Ok(u) => { * req.0.uri_mut() = u;
+    hyper_code::HYPERE_OK }, Err(_) => { hyper_code::HYPERE_INVALID_ARG } } }
+}
+ffi_fn! {
+    #[doc = " Set the URI of the request with separate scheme, authority, and"] #[doc =
+    " path/query strings."] #[doc = ""] #[doc =
+    " Each of `scheme`, `authority`, and `path_and_query` should either be"] #[doc =
+    " null, to skip providing a component, or point to a UTF-8 encoded"] #[doc =
+    " string. If any string pointer argument is non-null, its corresponding"] #[doc =
+    " `len` parameter must be set to the string's length."] fn
+    hyper_request_set_uri_parts(req : * mut hyper_request, scheme : * const u8,
+    scheme_len : size_t, authority : * const u8, authority_len : size_t, path_and_query :
+    * const u8, path_and_query_len : size_t) -> hyper_code { let mut builder =
+    Uri::builder(); if ! scheme.is_null() { let scheme_bytes = unsafe {
+    std::slice::from_raw_parts(scheme, scheme_len as usize) }; builder = builder
+    .scheme(scheme_bytes); } if ! authority.is_null() { let authority_bytes = unsafe {
+    std::slice::from_raw_parts(authority, authority_len as usize) }; builder = builder
+    .authority(authority_bytes); } if ! path_and_query.is_null() { let
+    path_and_query_bytes = unsafe { std::slice::from_raw_parts(path_and_query,
+    path_and_query_len as usize) }; builder = builder
+    .path_and_query(path_and_query_bytes); } match builder.build() { Ok(u) => { * unsafe
+    { & mut * req } .0.uri_mut() = u; hyper_code::HYPERE_OK }, Err(_) => {
+    hyper_code::HYPERE_INVALID_ARG } } }
+}
+ffi_fn! {
+    #[doc = " Set the preferred HTTP version of the request."] #[doc = ""] #[doc =
+    " The version value should be one of the `HYPER_HTTP_VERSION_` constants."] #[doc =
+    ""] #[doc = " Note that this won't change the major HTTP version of the connection,"]
+    #[doc = " since that is determined at the handshake step."] fn
+    hyper_request_set_version(req : * mut hyper_request, version : c_int) -> hyper_code {
+    use http::Version; let req = non_null!(& mut * req ?=
+    hyper_code::HYPERE_INVALID_ARG); * req.0.version_mut() = match version {
+    super::HYPER_HTTP_VERSION_NONE => Version::HTTP_11, super::HYPER_HTTP_VERSION_1_0 =>
+    Version::HTTP_10, super::HYPER_HTTP_VERSION_1_1 => Version::HTTP_11,
+    super::HYPER_HTTP_VERSION_2 => Version::HTTP_2, _ => { return
+    hyper_code::HYPERE_INVALID_ARG; } }; hyper_code::HYPERE_OK }
+}
+ffi_fn! {
+    #[doc = " Gets a reference to the HTTP headers of this request"] #[doc = ""] #[doc =
+    " This is not an owned reference, so it should not be accessed after the"] #[doc =
+    " `hyper_request` has been consumed."] fn hyper_request_headers(req : * mut
+    hyper_request) -> * mut hyper_headers { hyper_headers::get_or_default(unsafe { & mut
+    * req } .0.extensions_mut()) } ?= std::ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Set the body of the request."] #[doc = ""] #[doc =
+    " The default is an empty body."] #[doc = ""] #[doc =
+    " This takes ownership of the `hyper_body *`, you must not use it or"] #[doc =
+    " free it after setting it on the request."] fn hyper_request_set_body(req : * mut
+    hyper_request, body : * mut hyper_body) -> hyper_code { let body =
+    non_null!(Box::from_raw(body) ?= hyper_code::HYPERE_INVALID_ARG); let req =
+    non_null!(& mut * req ?= hyper_code::HYPERE_INVALID_ARG); * req.0.body_mut() = body
+    .0; hyper_code::HYPERE_OK }
+}
+ffi_fn! {
+    #[doc = " Set an informational (1xx) response callback."] #[doc = ""] #[doc =
+    " The callback is called each time hyper receives an informational (1xx)"] #[doc =
+    " response for this request."] #[doc = ""] #[doc =
+    " The third argument is an opaque user data pointer, which is passed to"] #[doc =
+    " the callback each time."] #[doc = ""] #[doc =
+    " The callback is passed the `void *` data pointer, and a"] #[doc =
+    " `hyper_response *` which can be inspected as any other response. The"] #[doc =
+    " body of the response will always be empty."] #[doc = ""] #[doc =
+    " NOTE: The `hyper_response *` is just borrowed data, and will not"] #[doc =
+    " be valid after the callback finishes. You must copy any data you wish"] #[doc =
+    " to persist."] fn hyper_request_on_informational(req : * mut hyper_request, callback
+    : hyper_request_on_informational_callback, data : * mut c_void) -> hyper_code { let
+    ext = OnInformational { func : callback, data : UserDataPointer(data), }; let req =
+    non_null!(& mut * req ?= hyper_code::HYPERE_INVALID_ARG); req.0.extensions_mut()
+    .insert(ext); hyper_code::HYPERE_OK }
+}
+impl hyper_request {
+    pub(super) fn finalize_request(&mut self) {
+        if let Some(headers) = self.0.extensions_mut().remove::<hyper_headers>() {
+            *self.0.headers_mut() = headers.headers;
+            self.0.extensions_mut().insert(headers.orig_casing);
+            self.0.extensions_mut().insert(headers.orig_order);
+        }
+    }
+}
+ffi_fn! {
+    #[doc = " Free an HTTP response after using it."] fn hyper_response_free(resp : * mut
+    hyper_response) { drop(non_null!(Box::from_raw(resp) ?= ())); }
+}
+ffi_fn! {
+    #[doc = " Get the HTTP-Status code of this response."] #[doc = ""] #[doc =
+    " It will always be within the range of 100-599."] fn hyper_response_status(resp : *
+    const hyper_response) -> u16 { non_null!(&* resp ?= 0) .0.status().as_u16() }
+}
+ffi_fn! {
+    #[doc = " Get a pointer to the reason-phrase of this response."] #[doc = ""] #[doc =
+    " This buffer is not null-terminated."] #[doc = ""] #[doc =
+    " This buffer is owned by the response, and should not be used after"] #[doc =
+    " the response has been freed."] #[doc = ""] #[doc =
+    " Use `hyper_response_reason_phrase_len()` to get the length of this"] #[doc =
+    " buffer."] fn hyper_response_reason_phrase(resp : * const hyper_response) -> * const
+    u8 { non_null!(&* resp ?= std::ptr::null()) .reason_phrase().as_ptr() } ?=
+    std::ptr::null()
+}
+ffi_fn! {
+    #[doc = " Get the length of the reason-phrase of this response."] #[doc = ""] #[doc =
+    " Use `hyper_response_reason_phrase()` to get the buffer pointer."] fn
+    hyper_response_reason_phrase_len(resp : * const hyper_response) -> size_t {
+    non_null!(&* resp ?= 0) .reason_phrase().len() }
+}
+ffi_fn! {
+    #[doc = " Get a reference to the full raw headers of this response."] #[doc = ""]
+    #[doc = " You must have enabled `hyper_clientconn_options_headers_raw()`, or this"]
+    #[doc = " will return NULL."] #[doc = ""] #[doc =
+    " The returned `hyper_buf *` is just a reference, owned by the response."] #[doc =
+    " You need to make a copy if you wish to use it after freeing the"] #[doc =
+    " response."] #[doc = ""] #[doc =
+    " The buffer is not null-terminated, see the `hyper_buf` functions for"] #[doc =
+    " getting the bytes and length."] fn hyper_response_headers_raw(resp : * const
+    hyper_response) -> * const hyper_buf { let resp = non_null!(&* resp ?=
+    std::ptr::null()); match resp.0.extensions().get::< RawHeaders > () { Some(raw) => &
+    raw.0, None => std::ptr::null(), } } ?= std::ptr::null()
+}
+ffi_fn! {
+    #[doc = " Get the HTTP version used by this response."] #[doc = ""] #[doc =
+    " The returned value could be:"] #[doc = ""] #[doc = " - `HYPER_HTTP_VERSION_1_0`"]
+    #[doc = " - `HYPER_HTTP_VERSION_1_1`"] #[doc = " - `HYPER_HTTP_VERSION_2`"] #[doc =
+    " - `HYPER_HTTP_VERSION_NONE` if newer (or older)."] fn hyper_response_version(resp :
+    * const hyper_response) -> c_int { use http::Version; match non_null!(&* resp ?= 0)
+    .0.version() { Version::HTTP_10 => super::HYPER_HTTP_VERSION_1_0, Version::HTTP_11 =>
+    super::HYPER_HTTP_VERSION_1_1, Version::HTTP_2 => super::HYPER_HTTP_VERSION_2, _ =>
+    super::HYPER_HTTP_VERSION_NONE, } }
+}
+ffi_fn! {
+    #[doc = " Gets a reference to the HTTP headers of this response."] #[doc = ""] #[doc
+    = " This is not an owned reference, so it should not be accessed after the"] #[doc =
+    " `hyper_response` has been freed."] fn hyper_response_headers(resp : * mut
+    hyper_response) -> * mut hyper_headers { hyper_headers::get_or_default(unsafe { & mut
+    * resp } .0.extensions_mut()) } ?= std::ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Take ownership of the body of this response."] #[doc = ""] #[doc =
+    " It is safe to free the response even after taking ownership of its body."] fn
+    hyper_response_body(resp : * mut hyper_response) -> * mut hyper_body { let body =
+    std::mem::take(non_null!(& mut * resp ?= std::ptr::null_mut()) .0.body_mut());
+    Box::into_raw(Box::new(hyper_body(body))) } ?= std::ptr::null_mut()
+}
+impl hyper_response {
+    pub(super) fn wrap(mut resp: Response<Body>) -> hyper_response {
+        let headers = std::mem::take(resp.headers_mut());
+        let orig_casing = resp
+            .extensions_mut()
+            .remove::<HeaderCaseMap>()
+            .unwrap_or_else(HeaderCaseMap::default);
+        let orig_order = resp
+            .extensions_mut()
+            .remove::<OriginalHeaderOrder>()
+            .unwrap_or_else(OriginalHeaderOrder::default);
+        resp.extensions_mut()
+            .insert(hyper_headers {
+                headers,
+                orig_casing,
+                orig_order,
+            });
+        hyper_response(resp)
+    }
+    fn reason_phrase(&self) -> &[u8] {
+        if let Some(reason) = self.0.extensions().get::<ReasonPhrase>() {
+            return reason.as_bytes();
+        }
+        if let Some(reason) = self.0.status().canonical_reason() {
+            return reason.as_bytes();
+        }
+        &[]
+    }
+}
+unsafe impl AsTaskType for hyper_response {
+    fn as_task_type(&self) -> hyper_task_return_type {
+        hyper_task_return_type::HYPER_TASK_RESPONSE
+    }
+}
+type hyper_headers_foreach_callback = extern "C" fn(
+    *mut c_void,
+    *const u8,
+    size_t,
+    *const u8,
+    size_t,
+) -> c_int;
+impl hyper_headers {
+    pub(super) fn get_or_default(ext: &mut http::Extensions) -> &mut hyper_headers {
+        if let None = ext.get_mut::<hyper_headers>() {
+            ext.insert(hyper_headers::default());
+        }
+        ext.get_mut::<hyper_headers>().unwrap()
+    }
+}
+ffi_fn! {
+    #[doc = " Iterates the headers passing each name and value pair to the callback."]
+    #[doc = ""] #[doc = " The `userdata` pointer is also passed to the callback."] #[doc
+    = ""] #[doc =
+    " The callback should return `HYPER_ITER_CONTINUE` to keep iterating, or"] #[doc =
+    " `HYPER_ITER_BREAK` to stop."] fn hyper_headers_foreach(headers : * const
+    hyper_headers, func : hyper_headers_foreach_callback, userdata : * mut c_void) { let
+    headers = non_null!(&* headers ?= ()); let mut ordered_iter = headers.orig_order
+    .get_in_order().peekable(); if ordered_iter.peek().is_some() { for (name, idx) in
+    ordered_iter { let (name_ptr, name_len) = if let Some(orig_name) = headers
+    .orig_casing.get_all(name).nth(* idx) { (orig_name.as_ref().as_ptr(), orig_name
+    .as_ref().len()) } else { (name.as_str().as_bytes().as_ptr(), name.as_str()
+    .as_bytes().len(),) }; let val_ptr; let val_len; if let Some(value) = headers.headers
+    .get_all(name).iter().nth(* idx) { val_ptr = value.as_bytes().as_ptr(); val_len =
+    value.as_bytes().len(); } else { return; } if HYPER_ITER_CONTINUE != func(userdata,
+    name_ptr, name_len, val_ptr, val_len) { return; } } } else { for name in headers
+    .headers.keys() { let mut names = headers.orig_casing.get_all(name); for value in
+    headers.headers.get_all(name) { let (name_ptr, name_len) = if let Some(orig_name) =
+    names.next() { (orig_name.as_ref().as_ptr(), orig_name.as_ref().len()) } else { (name
+    .as_str().as_bytes().as_ptr(), name.as_str().as_bytes().len(),) }; let val_ptr =
+    value.as_bytes().as_ptr(); let val_len = value.as_bytes().len(); if
+    HYPER_ITER_CONTINUE != func(userdata, name_ptr, name_len, val_ptr, val_len) { return;
+    } } } } }
+}
+ffi_fn! {
+    #[doc = " Sets the header with the provided name to the provided value."] #[doc = ""]
+    #[doc = " This overwrites any previous value set for the header."] fn
+    hyper_headers_set(headers : * mut hyper_headers, name : * const u8, name_len :
+    size_t, value : * const u8, value_len : size_t) -> hyper_code { let headers =
+    non_null!(& mut * headers ?= hyper_code::HYPERE_INVALID_ARG); match unsafe {
+    raw_name_value(name, name_len, value, value_len) } { Ok((name, value, orig_name)) =>
+    { headers.headers.insert(& name, value); headers.orig_casing.insert(name.clone(),
+    orig_name.clone()); headers.orig_order.insert(name); hyper_code::HYPERE_OK }
+    Err(code) => code, } }
+}
+ffi_fn! {
+    #[doc = " Adds the provided value to the list of the provided name."] #[doc = ""]
+    #[doc = " If there were already existing values for the name, this will append the"]
+    #[doc = " new value to the internal list."] fn hyper_headers_add(headers : * mut
+    hyper_headers, name : * const u8, name_len : size_t, value : * const u8, value_len :
+    size_t) -> hyper_code { let headers = non_null!(& mut * headers ?=
+    hyper_code::HYPERE_INVALID_ARG); match unsafe { raw_name_value(name, name_len, value,
+    value_len) } { Ok((name, value, orig_name)) => { headers.headers.append(& name,
+    value); headers.orig_casing.append(& name, orig_name.clone()); headers.orig_order
+    .append(name); hyper_code::HYPERE_OK } Err(code) => code, } }
+}
+impl Default for hyper_headers {
+    fn default() -> Self {
+        Self {
+            headers: Default::default(),
+            orig_casing: HeaderCaseMap::default(),
+            orig_order: OriginalHeaderOrder::default(),
+        }
+    }
+}
+unsafe fn raw_name_value(
+    name: *const u8,
+    name_len: size_t,
+    value: *const u8,
+    value_len: size_t,
+) -> Result<(HeaderName, HeaderValue, Bytes), hyper_code> {
+    let name = std::slice::from_raw_parts(name, name_len);
+    let orig_name = Bytes::copy_from_slice(name);
+    let name = match HeaderName::from_bytes(name) {
+        Ok(name) => name,
+        Err(_) => return Err(hyper_code::HYPERE_INVALID_ARG),
+    };
+    let value = std::slice::from_raw_parts(value, value_len);
+    let value = match HeaderValue::from_bytes(value) {
+        Ok(val) => val,
+        Err(_) => return Err(hyper_code::HYPERE_INVALID_ARG),
+    };
+    Ok((name, value, orig_name))
+}
+impl OnInformational {
+    pub(crate) fn call(&mut self, resp: Response<Body>) {
+        let mut resp = hyper_response::wrap(resp);
+        (self.func)(self.data.0, &mut resp);
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_headers_foreach_cases_preserved() {
+        let mut headers = hyper_headers::default();
+        let name1 = b"Set-CookiE";
+        let value1 = b"a=b";
+        hyper_headers_add(
+            &mut headers,
+            name1.as_ptr(),
+            name1.len(),
+            value1.as_ptr(),
+            value1.len(),
+        );
+        let name2 = b"SET-COOKIE";
+        let value2 = b"c=d";
+        hyper_headers_add(
+            &mut headers,
+            name2.as_ptr(),
+            name2.len(),
+            value2.as_ptr(),
+            value2.len(),
+        );
+        let mut vec = Vec::<u8>::new();
+        hyper_headers_foreach(&headers, concat, &mut vec as *mut _ as *mut c_void);
+        assert_eq!(vec, b"Set-CookiE: a=b\r\nSET-COOKIE: c=d\r\n");
+        extern "C" fn concat(
+            vec: *mut c_void,
+            name: *const u8,
+            name_len: usize,
+            value: *const u8,
+            value_len: usize,
+        ) -> c_int {
+            unsafe {
+                let vec = &mut *(vec as *mut Vec<u8>);
+                let name = std::slice::from_raw_parts(name, name_len);
+                let value = std::slice::from_raw_parts(value, value_len);
+                vec.extend(name);
+                vec.extend(b": ");
+                vec.extend(value);
+                vec.extend(b"\r\n");
+            }
+            HYPER_ITER_CONTINUE
+        }
+    }
+    #[cfg(all(feature = "http1", feature = "ffi"))]
+    #[test]
+    fn test_headers_foreach_order_preserved() {
+        let mut headers = hyper_headers::default();
+        let name1 = b"Set-CookiE";
+        let value1 = b"a=b";
+        hyper_headers_add(
+            &mut headers,
+            name1.as_ptr(),
+            name1.len(),
+            value1.as_ptr(),
+            value1.len(),
+        );
+        let name2 = b"Content-Encoding";
+        let value2 = b"gzip";
+        hyper_headers_add(
+            &mut headers,
+            name2.as_ptr(),
+            name2.len(),
+            value2.as_ptr(),
+            value2.len(),
+        );
+        let name3 = b"SET-COOKIE";
+        let value3 = b"c=d";
+        hyper_headers_add(
+            &mut headers,
+            name3.as_ptr(),
+            name3.len(),
+            value3.as_ptr(),
+            value3.len(),
+        );
+        let mut vec = Vec::<u8>::new();
+        hyper_headers_foreach(&headers, concat, &mut vec as *mut _ as *mut c_void);
+        println!("{}", std::str::from_utf8(& vec).unwrap());
+        assert_eq!(
+            vec, b"Set-CookiE: a=b\r\nContent-Encoding: gzip\r\nSET-COOKIE: c=d\r\n"
+        );
+        extern "C" fn concat(
+            vec: *mut c_void,
+            name: *const u8,
+            name_len: usize,
+            value: *const u8,
+            value_len: usize,
+        ) -> c_int {
+            unsafe {
+                let vec = &mut *(vec as *mut Vec<u8>);
+                let name = std::slice::from_raw_parts(name, name_len);
+                let value = std::slice::from_raw_parts(value, value_len);
+                vec.extend(name);
+                vec.extend(b": ");
+                vec.extend(value);
+                vec.extend(b"\r\n");
+            }
+            HYPER_ITER_CONTINUE
+        }
+    }
+}
diff --git a/hyper/src/ffi/io.rs b/hyper/src/ffi/io.rs
new file mode 100644
index 0000000..f2eccc0
--- /dev/null
+++ b/hyper/src/ffi/io.rs
@@ -0,0 +1,153 @@
+use std::ffi::c_void;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use libc::size_t;
+use tokio::io::{AsyncRead, AsyncWrite};
+use super::task::hyper_context;
+/// Sentinel value to return from a read or write callback that the operation
+/// is pending.
+pub(crate) const HYPER_IO_PENDING: size_t = 0xFFFFFFFF;
+/// Sentinel value to return from a read or write callback that the operation
+/// has errored.
+pub(crate) const HYPER_IO_ERROR: size_t = 0xFFFFFFFE;
+type hyper_io_read_callback = extern "C" fn(
+    *mut c_void,
+    *mut hyper_context<'_>,
+    *mut u8,
+    size_t,
+) -> size_t;
+type hyper_io_write_callback = extern "C" fn(
+    *mut c_void,
+    *mut hyper_context<'_>,
+    *const u8,
+    size_t,
+) -> size_t;
+/// An IO object used to represent a socket or similar concept.
+pub(crate) struct hyper_io {
+    read: hyper_io_read_callback,
+    write: hyper_io_write_callback,
+    userdata: *mut c_void,
+}
+ffi_fn! {
+    #[doc = " Create a new IO type used to represent a transport."] #[doc = ""] #[doc =
+    " The read and write functions of this transport should be set with"] #[doc =
+    " `hyper_io_set_read` and `hyper_io_set_write`."] fn hyper_io_new() -> * mut hyper_io
+    { Box::into_raw(Box::new(hyper_io { read : read_noop, write : write_noop, userdata :
+    std::ptr::null_mut(), })) } ?= std::ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Free an unused `hyper_io *`."] #[doc = ""] #[doc =
+    " This is typically only useful if you aren't going to pass ownership"] #[doc =
+    " of the IO handle to hyper, such as with `hyper_clientconn_handshake()`."] fn
+    hyper_io_free(io : * mut hyper_io) { drop(non_null!(Box::from_raw(io) ?= ())); }
+}
+ffi_fn! {
+    #[doc = " Set the user data pointer for this IO to some value."] #[doc = ""] #[doc =
+    " This value is passed as an argument to the read and write callbacks."] fn
+    hyper_io_set_userdata(io : * mut hyper_io, data : * mut c_void) { non_null!(& mut *
+    io ?= ()) .userdata = data; }
+}
+ffi_fn! {
+    #[doc = " Set the read function for this IO transport."] #[doc = ""] #[doc =
+    " Data that is read from the transport should be put in the `buf` pointer,"] #[doc =
+    " up to `buf_len` bytes. The number of bytes read should be the return value."] #[doc
+    = ""] #[doc =
+    " It is undefined behavior to try to access the bytes in the `buf` pointer,"] #[doc =
+    " unless you have already written them yourself. It is also undefined behavior"]
+    #[doc =
+    " to return that more bytes have been written than actually set on the `buf`."] #[doc
+    = ""] #[doc =
+    " If there is no data currently available, a waker should be claimed from"] #[doc =
+    " the `ctx` and registered with whatever polling mechanism is used to signal"] #[doc
+    = " when data is available later on. The return value should be"] #[doc =
+    " `HYPER_IO_PENDING`."] #[doc = ""] #[doc =
+    " If there is an irrecoverable error reading data, then `HYPER_IO_ERROR`"] #[doc =
+    " should be the return value."] fn hyper_io_set_read(io : * mut hyper_io, func :
+    hyper_io_read_callback) { non_null!(& mut * io ?= ()) .read = func; }
+}
+ffi_fn! {
+    #[doc = " Set the write function for this IO transport."] #[doc = ""] #[doc =
+    " Data from the `buf` pointer should be written to the transport, up to"] #[doc =
+    " `buf_len` bytes. The number of bytes written should be the return value."] #[doc =
+    ""] #[doc = " If no data can currently be written, the `waker` should be cloned and"]
+    #[doc = " registered with whatever polling mechanism is used to signal when data"]
+    #[doc = " is available later on. The return value should be `HYPER_IO_PENDING`."]
+    #[doc = ""] #[doc = " Yeet."] #[doc = ""] #[doc =
+    " If there is an irrecoverable error reading data, then `HYPER_IO_ERROR`"] #[doc =
+    " should be the return value."] fn hyper_io_set_write(io : * mut hyper_io, func :
+    hyper_io_write_callback) { non_null!(& mut * io ?= ()) .write = func; }
+}
+/// cbindgen:ignore
+extern "C" fn read_noop(
+    _userdata: *mut c_void,
+    _: *mut hyper_context<'_>,
+    _buf: *mut u8,
+    _buf_len: size_t,
+) -> size_t {
+    0
+}
+/// cbindgen:ignore
+extern "C" fn write_noop(
+    _userdata: *mut c_void,
+    _: *mut hyper_context<'_>,
+    _buf: *const u8,
+    _buf_len: size_t,
+) -> size_t {
+    0
+}
+impl AsyncRead for hyper_io {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        let buf_ptr = unsafe { buf.unfilled_mut() }.as_mut_ptr() as *mut u8;
+        let buf_len = buf.remaining();
+        match (self.read)(self.userdata, hyper_context::wrap(cx), buf_ptr, buf_len) {
+            HYPER_IO_PENDING => Poll::Pending,
+            HYPER_IO_ERROR => {
+                Poll::Ready(
+                    Err(std::io::Error::new(std::io::ErrorKind::Other, "io error")),
+                )
+            }
+            ok => {
+                unsafe { buf.assume_init(ok) };
+                buf.advance(ok);
+                Poll::Ready(Ok(()))
+            }
+        }
+    }
+}
+impl AsyncWrite for hyper_io {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        let buf_ptr = buf.as_ptr();
+        let buf_len = buf.len();
+        match (self.write)(self.userdata, hyper_context::wrap(cx), buf_ptr, buf_len) {
+            HYPER_IO_PENDING => Poll::Pending,
+            HYPER_IO_ERROR => {
+                Poll::Ready(
+                    Err(std::io::Error::new(std::io::ErrorKind::Other, "io error")),
+                )
+            }
+            ok => Poll::Ready(Ok(ok)),
+        }
+    }
+    fn poll_flush(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+unsafe impl Send for hyper_io {}
+unsafe impl Sync for hyper_io {}
diff --git a/hyper/src/ffi/macros.rs b/hyper/src/ffi/macros.rs
new file mode 100644
index 0000000..022711b
--- /dev/null
+++ b/hyper/src/ffi/macros.rs
@@ -0,0 +1,53 @@
+macro_rules! ffi_fn {
+    ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) -> $ret:ty $body:block ?= $default:expr) => {
+        $(#[$doc])*
+        #[no_mangle]
+        pub extern fn $name($($arg: $arg_ty),*) -> $ret {
+            use std::panic::{self, AssertUnwindSafe};
+
+            match panic::catch_unwind(AssertUnwindSafe(move || $body)) {
+                Ok(v) => v,
+                Err(_) => {
+                    $default
+                }
+            }
+        }
+    };
+
+    ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) -> $ret:ty $body:block) => {
+        ffi_fn!($(#[$doc])* fn $name($($arg: $arg_ty),*) -> $ret $body ?= {
+            eprintln!("panic unwind caught, aborting");
+            std::process::abort()
+        });
+    };
+
+    ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) $body:block ?= $default:expr) => {
+        ffi_fn!($(#[$doc])* fn $name($($arg: $arg_ty),*) -> () $body ?= $default);
+    };
+
+    ($(#[$doc:meta])* fn $name:ident($($arg:ident: $arg_ty:ty),*) $body:block) => {
+        ffi_fn!($(#[$doc])* fn $name($($arg: $arg_ty),*) -> () $body);
+    };
+}
+
+macro_rules! non_null {
+    ($ptr:ident, $eval:expr, $err:expr) => {{
+        debug_assert!(!$ptr.is_null(), "{:?} must not be null", stringify!($ptr));
+        if $ptr.is_null() {
+            return $err;
+        }
+        unsafe { $eval }
+    }};
+    (&*$ptr:ident ?= $err:expr) => {{
+        non_null!($ptr, &*$ptr, $err)
+    }};
+    (&mut *$ptr:ident ?= $err:expr) => {{
+        non_null!($ptr, &mut *$ptr, $err)
+    }};
+    (Box::from_raw($ptr:ident) ?= $err:expr) => {{
+        non_null!($ptr, Box::from_raw($ptr), $err)
+    }};
+    (Arc::from_raw($ptr:ident) ?= $err:expr) => {{
+        non_null!($ptr, Arc::from_raw($ptr), $err)
+    }};
+}
diff --git a/hyper/src/ffi/mod.rs b/hyper/src/ffi/mod.rs
new file mode 100644
index 0000000..9b15efa
--- /dev/null
+++ b/hyper/src/ffi/mod.rs
@@ -0,0 +1,73 @@
+#![allow(non_camel_case_types)]
+#![allow(missing_debug_implementations)]
+#![allow(unreachable_pub)]
+//! # hyper C API
+//!
+//! This part of the documentation describes the C API for hyper. That is, how
+//! to *use* the hyper library in C code. This is **not** a regular Rust
+//! module, and thus it is not accessible in Rust.
+//!
+//! ## Unstable
+//!
+//! The C API of hyper is currently **unstable**, which means it's not part of
+//! the semver contract as the rest of the Rust API is. Because of that, it's
+//! only accessible if `--cfg hyper_unstable_ffi` is passed to `rustc` when
+//! compiling. The easiest way to do that is setting the `RUSTFLAGS`
+//! environment variable.
+//!
+//! ## Building
+//!
+//! The C API is part of the Rust library, but isn't compiled by default. Using
+//! `cargo`, it can be compiled with the following command:
+//!
+//! ```notrust
+//! RUSTFLAGS="--cfg hyper_unstable_ffi" cargo build --features client,http1,http2,ffi
+//! ```
+#[cfg(not(all(feature = "client", feature = "http1")))]
+compile_error!(
+    "The `ffi` feature currently requires the `client` and `http1` features."
+);
+#[cfg(not(hyper_unstable_ffi))]
+compile_error!(
+    "\
+    The `ffi` feature is unstable, and requires the \
+    `RUSTFLAGS='--cfg hyper_unstable_ffi'` environment variable to be set.\
+"
+);
+#[macro_use]
+mod macros;
+mod body;
+mod client;
+mod error;
+mod http_types;
+mod io;
+mod task;
+pub(crate) use self::body::*;
+pub(crate) use self::client::*;
+pub(crate) use self::error::*;
+pub(crate) use self::http_types::*;
+pub(crate) use self::io::*;
+pub(crate) use self::task::*;
+/// Return in iter functions to continue iterating.
+pub(crate) const HYPER_ITER_CONTINUE: libc::c_int = 0;
+/// Return in iter functions to stop iterating.
+#[allow(unused)]
+pub(crate) const HYPER_ITER_BREAK: libc::c_int = 1;
+/// An HTTP Version that is unspecified.
+pub(crate) const HYPER_HTTP_VERSION_NONE: libc::c_int = 0;
+/// The HTTP/1.0 version.
+pub(crate) const HYPER_HTTP_VERSION_1_0: libc::c_int = 10;
+/// The HTTP/1.1 version.
+pub(crate) const HYPER_HTTP_VERSION_1_1: libc::c_int = 11;
+/// The HTTP/2 version.
+pub(crate) const HYPER_HTTP_VERSION_2: libc::c_int = 20;
+struct UserDataPointer(*mut std::ffi::c_void);
+unsafe impl Send for UserDataPointer {}
+unsafe impl Sync for UserDataPointer {}
+/// cbindgen:ignore
+static VERSION_CSTR: &str = concat!(env!("CARGO_PKG_VERSION"), "\0");
+ffi_fn! {
+    #[doc = " Returns a static ASCII (null terminated) string of the hyper version."] fn
+    hyper_version() -> * const libc::c_char { VERSION_CSTR.as_ptr() as _ } ?=
+    std::ptr::null()
+}
diff --git a/hyper/src/ffi/task.rs b/hyper/src/ffi/task.rs
new file mode 100644
index 0000000..3734164
--- /dev/null
+++ b/hyper/src/ffi/task.rs
@@ -0,0 +1,296 @@
+use std::ffi::c_void;
+use std::future::Future;
+use std::pin::Pin;
+use std::ptr;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc, Mutex, Weak,
+};
+use std::task::{Context, Poll};
+use futures_util::stream::{FuturesUnordered, Stream};
+use libc::c_int;
+use super::error::hyper_code;
+use super::UserDataPointer;
+type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
+type BoxAny = Box<dyn AsTaskType + Send + Sync>;
+/// Return in a poll function to indicate it was ready.
+pub(crate) const HYPER_POLL_READY: c_int = 0;
+/// Return in a poll function to indicate it is still pending.
+///
+/// The passed in `hyper_waker` should be registered to wake up the task at
+/// some later point.
+pub(crate) const HYPER_POLL_PENDING: c_int = 1;
+/// Return in a poll function indicate an error.
+pub(crate) const HYPER_POLL_ERROR: c_int = 3;
+/// A task executor for `hyper_task`s.
+pub(crate) struct hyper_executor {
+    /// The executor of all task futures.
+    ///
+    /// There should never be contention on the mutex, as it is only locked
+    /// to drive the futures. However, we cannot guarantee proper usage from
+    /// `hyper_executor_poll()`, which in C could potentially be called inside
+    /// one of the stored futures. The mutex isn't re-entrant, so doing so
+    /// would result in a deadlock, but that's better than data corruption.
+    driver: Mutex<FuturesUnordered<TaskFuture>>,
+    /// The queue of futures that need to be pushed into the `driver`.
+    ///
+    /// This is has a separate mutex since `spawn` could be called from inside
+    /// a future, which would mean the driver's mutex is already locked.
+    spawn_queue: Mutex<Vec<TaskFuture>>,
+    /// This is used to track when a future calls `wake` while we are within
+    /// `hyper_executor::poll_next`.
+    is_woken: Arc<ExecWaker>,
+}
+#[derive(Clone)]
+pub(crate) struct WeakExec(Weak<hyper_executor>);
+struct ExecWaker(AtomicBool);
+/// An async task.
+pub(crate) struct hyper_task {
+    future: BoxFuture<BoxAny>,
+    output: Option<BoxAny>,
+    userdata: UserDataPointer,
+}
+struct TaskFuture {
+    task: Option<Box<hyper_task>>,
+}
+/// An async context for a task that contains the related waker.
+pub(crate) struct hyper_context<'a>(Context<'a>);
+/// A waker that is saved and used to waken a pending task.
+pub(crate) struct hyper_waker {
+    waker: std::task::Waker,
+}
+/// A descriptor for what type a `hyper_task` value is.
+#[repr(C)]
+pub(crate) enum hyper_task_return_type {
+    /// The value of this task is null (does not imply an error).
+    HYPER_TASK_EMPTY,
+    /// The value of this task is `hyper_error *`.
+    HYPER_TASK_ERROR,
+    /// The value of this task is `hyper_clientconn *`.
+    HYPER_TASK_CLIENTCONN,
+    /// The value of this task is `hyper_response *`.
+    HYPER_TASK_RESPONSE,
+    /// The value of this task is `hyper_buf *`.
+    HYPER_TASK_BUF,
+}
+pub(crate) unsafe trait AsTaskType {
+    fn as_task_type(&self) -> hyper_task_return_type;
+}
+pub(crate) trait IntoDynTaskType {
+    fn into_dyn_task_type(self) -> BoxAny;
+}
+impl hyper_executor {
+    fn new() -> Arc<hyper_executor> {
+        Arc::new(hyper_executor {
+            driver: Mutex::new(FuturesUnordered::new()),
+            spawn_queue: Mutex::new(Vec::new()),
+            is_woken: Arc::new(ExecWaker(AtomicBool::new(false))),
+        })
+    }
+    pub(crate) fn downgrade(exec: &Arc<hyper_executor>) -> WeakExec {
+        WeakExec(Arc::downgrade(exec))
+    }
+    fn spawn(&self, task: Box<hyper_task>) {
+        self.spawn_queue.lock().unwrap().push(TaskFuture { task: Some(task) });
+    }
+    fn poll_next(&self) -> Option<Box<hyper_task>> {
+        self.drain_queue();
+        let waker = futures_util::task::waker_ref(&self.is_woken);
+        let mut cx = Context::from_waker(&waker);
+        loop {
+            match Pin::new(&mut *self.driver.lock().unwrap()).poll_next(&mut cx) {
+                Poll::Ready(val) => return val,
+                Poll::Pending => {
+                    if self.drain_queue() {
+                        continue;
+                    }
+                    if self.is_woken.0.swap(false, Ordering::SeqCst) {
+                        continue;
+                    }
+                    return None;
+                }
+            }
+        }
+    }
+    fn drain_queue(&self) -> bool {
+        let mut queue = self.spawn_queue.lock().unwrap();
+        if queue.is_empty() {
+            return false;
+        }
+        let driver = self.driver.lock().unwrap();
+        for task in queue.drain(..) {
+            driver.push(task);
+        }
+        true
+    }
+}
+impl futures_util::task::ArcWake for ExecWaker {
+    fn wake_by_ref(me: &Arc<ExecWaker>) {
+        me.0.store(true, Ordering::SeqCst);
+    }
+}
+impl WeakExec {
+    pub(crate) fn new() -> Self {
+        WeakExec(Weak::new())
+    }
+}
+impl crate::rt::Executor<BoxFuture<()>> for WeakExec {
+    fn execute(&self, fut: BoxFuture<()>) {
+        if let Some(exec) = self.0.upgrade() {
+            exec.spawn(hyper_task::boxed(fut));
+        }
+    }
+}
+ffi_fn! {
+    #[doc = " Creates a new task executor."] fn hyper_executor_new() -> * const
+    hyper_executor { Arc::into_raw(hyper_executor::new()) } ?= ptr::null()
+}
+ffi_fn! {
+    #[doc = " Frees an executor and any incomplete tasks still part of it."] fn
+    hyper_executor_free(exec : * const hyper_executor) {
+    drop(non_null!(Arc::from_raw(exec) ?= ())); }
+}
+ffi_fn! {
+    #[doc = " Push a task onto the executor."] #[doc = ""] #[doc =
+    " The executor takes ownership of the task, it should not be accessed"] #[doc =
+    " again unless returned back to the user with `hyper_executor_poll`."] fn
+    hyper_executor_push(exec : * const hyper_executor, task : * mut hyper_task) ->
+    hyper_code { let exec = non_null!(&* exec ?= hyper_code::HYPERE_INVALID_ARG); let
+    task = non_null!(Box::from_raw(task) ?= hyper_code::HYPERE_INVALID_ARG); exec
+    .spawn(task); hyper_code::HYPERE_OK }
+}
+ffi_fn! {
+    #[doc =
+    " Polls the executor, trying to make progress on any tasks that have notified"] #[doc
+    = " that they are ready again."] #[doc = ""] #[doc =
+    " If ready, returns a task from the executor that has completed."] #[doc = ""] #[doc
+    = " If there are no ready tasks, this returns `NULL`."] fn hyper_executor_poll(exec :
+    * const hyper_executor) -> * mut hyper_task { let exec = non_null!(&* exec ?=
+    ptr::null_mut()); match exec.poll_next() { Some(task) => Box::into_raw(task), None =>
+    ptr::null_mut(), } } ?= ptr::null_mut()
+}
+impl hyper_task {
+    pub(crate) fn boxed<F>(fut: F) -> Box<hyper_task>
+    where
+        F: Future + Send + 'static,
+        F::Output: IntoDynTaskType + Send + Sync + 'static,
+    {
+        Box::new(hyper_task {
+            future: Box::pin(async move { fut.await.into_dyn_task_type() }),
+            output: None,
+            userdata: UserDataPointer(ptr::null_mut()),
+        })
+    }
+    fn output_type(&self) -> hyper_task_return_type {
+        match self.output {
+            None => hyper_task_return_type::HYPER_TASK_EMPTY,
+            Some(ref val) => val.as_task_type(),
+        }
+    }
+}
+impl Future for TaskFuture {
+    type Output = Box<hyper_task>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match Pin::new(&mut self.task.as_mut().unwrap().future).poll(cx) {
+            Poll::Ready(val) => {
+                let mut task = self.task.take().unwrap();
+                task.output = Some(val);
+                Poll::Ready(task)
+            }
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+ffi_fn! {
+    #[doc = " Free a task."] fn hyper_task_free(task : * mut hyper_task) {
+    drop(non_null!(Box::from_raw(task) ?= ())); }
+}
+ffi_fn! {
+    #[doc = " Takes the output value of this task."] #[doc = ""] #[doc =
+    " This must only be called once polling the task on an executor has finished"] #[doc
+    = " this task."] #[doc = ""] #[doc =
+    " Use `hyper_task_type` to determine the type of the `void *` return value."] fn
+    hyper_task_value(task : * mut hyper_task) -> * mut c_void { let task = non_null!(&
+    mut * task ?= ptr::null_mut()); if let Some(val) = task.output.take() { let p =
+    Box::into_raw(val) as * mut c_void; if p == std::ptr::NonNull::< c_void >::dangling()
+    .as_ptr() { ptr::null_mut() } else { p } } else { ptr::null_mut() } } ?=
+    ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Query the return type of this task."] fn hyper_task_type(task : * mut
+    hyper_task) -> hyper_task_return_type { non_null!(&* task ?=
+    hyper_task_return_type::HYPER_TASK_EMPTY) .output_type() }
+}
+ffi_fn! {
+    #[doc = " Set a user data pointer to be associated with this task."] #[doc = ""]
+    #[doc = " This value will be passed to task callbacks, and can be checked later"]
+    #[doc = " with `hyper_task_userdata`."] fn hyper_task_set_userdata(task : * mut
+    hyper_task, userdata : * mut c_void) { if task.is_null() { return; } unsafe { (*
+    task).userdata = UserDataPointer(userdata) }; }
+}
+ffi_fn! {
+    #[doc = " Retrieve the userdata that has been set via `hyper_task_set_userdata`."] fn
+    hyper_task_userdata(task : * mut hyper_task) -> * mut c_void { non_null!(&* task ?=
+    ptr::null_mut()) .userdata.0 } ?= ptr::null_mut()
+}
+unsafe impl AsTaskType for () {
+    fn as_task_type(&self) -> hyper_task_return_type {
+        hyper_task_return_type::HYPER_TASK_EMPTY
+    }
+}
+unsafe impl AsTaskType for crate::Error {
+    fn as_task_type(&self) -> hyper_task_return_type {
+        hyper_task_return_type::HYPER_TASK_ERROR
+    }
+}
+impl<T> IntoDynTaskType for T
+where
+    T: AsTaskType + Send + Sync + 'static,
+{
+    fn into_dyn_task_type(self) -> BoxAny {
+        Box::new(self)
+    }
+}
+impl<T> IntoDynTaskType for crate::Result<T>
+where
+    T: IntoDynTaskType + Send + Sync + 'static,
+{
+    fn into_dyn_task_type(self) -> BoxAny {
+        match self {
+            Ok(val) => val.into_dyn_task_type(),
+            Err(err) => Box::new(err),
+        }
+    }
+}
+impl<T> IntoDynTaskType for Option<T>
+where
+    T: IntoDynTaskType + Send + Sync + 'static,
+{
+    fn into_dyn_task_type(self) -> BoxAny {
+        match self {
+            Some(val) => val.into_dyn_task_type(),
+            None => ().into_dyn_task_type(),
+        }
+    }
+}
+impl hyper_context<'_> {
+    pub(crate) fn wrap<'a, 'b>(cx: &'a mut Context<'b>) -> &'a mut hyper_context<'b> {
+        unsafe { std::mem::transmute::<&mut Context<'_>, &mut hyper_context<'_>>(cx) }
+    }
+}
+ffi_fn! {
+    #[doc = " Copies a waker out of the task context."] fn hyper_context_waker(cx : * mut
+    hyper_context <'_ >) -> * mut hyper_waker { let waker = non_null!(& mut * cx ?=
+    ptr::null_mut()) .0.waker().clone(); Box::into_raw(Box::new(hyper_waker { waker })) }
+    ?= ptr::null_mut()
+}
+ffi_fn! {
+    #[doc = " Free a waker that hasn't been woken."] fn hyper_waker_free(waker : * mut
+    hyper_waker) { drop(non_null!(Box::from_raw(waker) ?= ())); }
+}
+ffi_fn! {
+    #[doc = " Wake up the task associated with a waker."] #[doc = ""] #[doc =
+    " NOTE: This consumes the waker. You should not use or free the waker afterwards."]
+    fn hyper_waker_wake(waker : * mut hyper_waker) { let waker =
+    non_null!(Box::from_raw(waker) ?= ()); waker.waker.wake(); }
+}
diff --git a/hyper/src/headers.rs b/hyper/src/headers.rs
new file mode 100644
index 0000000..8407be1
--- /dev/null
+++ b/hyper/src/headers.rs
@@ -0,0 +1,154 @@
+#[cfg(feature = "http1")]
+use bytes::BytesMut;
+use http::header::CONTENT_LENGTH;
+use http::header::{HeaderValue, ValueIter};
+use http::HeaderMap;
+#[cfg(all(feature = "http2", feature = "client"))]
+use http::Method;
+
+#[cfg(feature = "http1")]
+pub(super) fn connection_keep_alive(value: &HeaderValue) -> bool {
+    connection_has(value, "keep-alive")
+}
+
+#[cfg(feature = "http1")]
+pub(super) fn connection_close(value: &HeaderValue) -> bool {
+    connection_has(value, "close")
+}
+
+#[cfg(feature = "http1")]
+fn connection_has(value: &HeaderValue, needle: &str) -> bool {
+    if let Ok(s) = value.to_str() {
+        for val in s.split(',') {
+            if val.trim().eq_ignore_ascii_case(needle) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+#[cfg(all(feature = "http1", feature = "server"))]
+pub(super) fn content_length_parse(value: &HeaderValue) -> Option<u64> {
+    from_digits(value.as_bytes())
+}
+
+pub(super) fn content_length_parse_all(headers: &HeaderMap) -> Option<u64> {
+    content_length_parse_all_values(headers.get_all(CONTENT_LENGTH).into_iter())
+}
+
+pub(super) fn content_length_parse_all_values(values: ValueIter<'_, HeaderValue>) -> Option<u64> {
+    // If multiple Content-Length headers were sent, everything can still
+    // be alright if they all contain the same value, and all parse
+    // correctly. If not, then it's an error.
+
+    let mut content_length: Option<u64> = None;
+    for h in values {
+        if let Ok(line) = h.to_str() {
+            for v in line.split(',') {
+                if let Some(n) = from_digits(v.trim().as_bytes()) {
+                    if content_length.is_none() {
+                        content_length = Some(n)
+                    } else if content_length != Some(n) {
+                        return None;
+                    }
+                } else {
+                    return None
+                }
+            }
+        } else {
+            return None
+        }
+    }
+
+    return content_length
+}
+
+fn from_digits(bytes: &[u8]) -> Option<u64> {
+    // cannot use FromStr for u64, since it allows a signed prefix
+    let mut result = 0u64;
+    const RADIX: u64 = 10;
+
+    if bytes.is_empty() {
+        return None;
+    }
+
+    for &b in bytes {
+        // can't use char::to_digit, since we haven't verified these bytes
+        // are utf-8.
+        match b {
+            b'0'..=b'9' => {
+                result = result.checked_mul(RADIX)?;
+                result = result.checked_add((b - b'0') as u64)?;
+            },
+            _ => {
+                // not a DIGIT, get outta here!
+                return None;
+            }
+        }
+    }
+
+    Some(result)
+}
+
+#[cfg(all(feature = "http2", feature = "client"))]
+pub(super) fn method_has_defined_payload_semantics(method: &Method) -> bool {
+    match *method {
+        Method::GET | Method::HEAD | Method::DELETE | Method::CONNECT => false,
+        _ => true,
+    }
+}
+
+#[cfg(feature = "http2")]
+pub(super) fn set_content_length_if_missing(headers: &mut HeaderMap, len: u64) {
+    headers
+        .entry(CONTENT_LENGTH)
+        .or_insert_with(|| HeaderValue::from(len));
+}
+
+#[cfg(feature = "http1")]
+pub(super) fn transfer_encoding_is_chunked(headers: &HeaderMap) -> bool {
+    is_chunked(headers.get_all(http::header::TRANSFER_ENCODING).into_iter())
+}
+
+#[cfg(feature = "http1")]
+pub(super) fn is_chunked(mut encodings: ValueIter<'_, HeaderValue>) -> bool {
+    // chunked must always be the last encoding, according to spec
+    if let Some(line) = encodings.next_back() {
+        return is_chunked_(line);
+    }
+
+    false
+}
+
+#[cfg(feature = "http1")]
+pub(super) fn is_chunked_(value: &HeaderValue) -> bool {
+    // chunked must always be the last encoding, according to spec
+    if let Ok(s) = value.to_str() {
+        if let Some(encoding) = s.rsplit(',').next() {
+            return encoding.trim().eq_ignore_ascii_case("chunked");
+        }
+    }
+
+    false
+}
+
+#[cfg(feature = "http1")]
+pub(super) fn add_chunked(mut entry: http::header::OccupiedEntry<'_, HeaderValue>) {
+    const CHUNKED: &str = "chunked";
+
+    if let Some(line) = entry.iter_mut().next_back() {
+        // + 2 for ", "
+        let new_cap = line.as_bytes().len() + CHUNKED.len() + 2;
+        let mut buf = BytesMut::with_capacity(new_cap);
+        buf.extend_from_slice(line.as_bytes());
+        buf.extend_from_slice(b", ");
+        buf.extend_from_slice(CHUNKED.as_bytes());
+
+        *line = HeaderValue::from_maybe_shared(buf.freeze())
+            .expect("original header value plus ascii is valid");
+        return;
+    }
+
+    entry.insert(HeaderValue::from_static(CHUNKED));
+}
diff --git a/hyper/src/lib.rs b/hyper/src/lib.rs
new file mode 100644
index 0000000..d5e12b5
--- /dev/null
+++ b/hyper/src/lib.rs
@@ -0,0 +1,90 @@
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![cfg_attr(test, deny(rust_2018_idioms))]
+#![cfg_attr(all(test, feature = "full"), deny(unreachable_pub))]
+#![cfg_attr(all(test, feature = "full"), deny(warnings))]
+#![cfg_attr(all(test, feature = "nightly"), feature(test))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+//! # hyper
+//!
+//! hyper is a **fast** and **correct** HTTP implementation written in and for Rust.
+//!
+//! ## Features
+//!
+//! - HTTP/1 and HTTP/2
+//! - Asynchronous design
+//! - Leading in performance
+//! - Tested and **correct**
+//! - Extensive production use
+//! - [Client](client/index.html) and [Server](server/index.html) APIs
+//!
+//! If just starting out, **check out the [Guides](https://hyper.rs/guides)
+//! first.**
+//!
+//! ## "Low-level"
+//!
+//! hyper is a lower-level HTTP library, meant to be a building block
+//! for libraries and applications.
+//!
+//! If looking for just a convenient HTTP client, consider the
+//! [reqwest](https://crates.io/crates/reqwest) crate.
+//!
+//! # Optional Features
+//!
+//! hyper uses a set of [feature flags] to reduce the amount of compiled code.
+//! It is possible to just enable certain features over others. By default,
+//! hyper does not enable any features but allows one to enable a subset for
+//! their use case. Below is a list of the available feature flags. You may
+//! also notice above each function, struct and trait there is listed one or
+//! more feature flags that are required for that item to be used.
+//!
+//! If you are new to hyper it is possible to enable the `full` feature flag
+//! which will enable all public APIs. Beware though that this will pull in
+//! many extra dependencies that you may not need.
+//!
+//! The following optional features are available:
+//!
+//! - `http1`: Enables HTTP/1 support.
+//! - `http2`: Enables HTTP/2 support.
+//! - `client`: Enables the HTTP `client`.
+//! - `server`: Enables the HTTP `server`.
+//! - `runtime`: Enables convenient integration with `tokio`, providing
+//!   connectors and acceptors for TCP, and a default executor.
+//! - `tcp`: Enables convenient implementations over TCP (using tokio).
+//! - `stream`: Provides `futures::Stream` capabilities.
+//!
+//! [feature flags]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section
+#[doc(hidden)]
+pub use http;
+#[cfg(all(test, feature = "nightly"))]
+extern crate test;
+pub use crate::http::{header, Method, Request, Response, StatusCode, Uri, Version};
+#[doc(no_inline)]
+pub use crate::http::HeaderMap;
+pub use crate::body::Body;
+pub use crate::error::{Error, Result};
+#[macro_use]
+mod cfg;
+#[macro_use]
+mod common;
+pub mod body;
+mod error;
+pub(crate) mod ext;
+#[cfg(test)]
+mod mock;
+pub(crate) mod rt;
+pub mod service;
+pub(crate) mod upgrade;
+#[cfg(feature = "ffi")]
+pub(crate) mod ffi;
+cfg_proto! {
+    mod headers; mod proto;
+}
+cfg_feature! {
+    #![feature = "client"] pub mod client; #[cfg(any(feature = "http1", feature =
+    "http2"))] #[doc(no_inline)] pub use crate ::client::Client;
+}
+cfg_feature! {
+    #![feature = "server"] pub mod server; #[doc(no_inline)] pub use crate
+    ::server::Server;
+}
diff --git a/hyper/src/mock.rs b/hyper/src/mock.rs
new file mode 100644
index 0000000..1dd57de
--- /dev/null
+++ b/hyper/src/mock.rs
@@ -0,0 +1,235 @@
+// FIXME: re-implement tests with `async/await`
+/*
+#[cfg(feature = "runtime")]
+use std::collections::HashMap;
+use std::cmp;
+use std::io::{self, Read, Write};
+#[cfg(feature = "runtime")]
+use std::sync::{Arc, Mutex};
+
+use bytes::Buf;
+use futures::{Async, Poll};
+#[cfg(feature = "runtime")]
+use futures::Future;
+use futures::task::{self, Task};
+use tokio_io::{AsyncRead, AsyncWrite};
+
+#[cfg(feature = "runtime")]
+use crate::client::connect::{Connect, Connected, Destination};
+
+
+
+#[cfg(feature = "runtime")]
+pub struct Duplex {
+    inner: Arc<Mutex<DuplexInner>>,
+}
+
+#[cfg(feature = "runtime")]
+struct DuplexInner {
+    handle_read_task: Option<Task>,
+    read: AsyncIo<MockCursor>,
+    write: AsyncIo<MockCursor>,
+}
+
+#[cfg(feature = "runtime")]
+impl Duplex {
+    pub(crate) fn channel() -> (Duplex, DuplexHandle) {
+        let mut inner = DuplexInner {
+            handle_read_task: None,
+            read: AsyncIo::new_buf(Vec::new(), 0),
+            write: AsyncIo::new_buf(Vec::new(), std::usize::MAX),
+        };
+
+        inner.read.park_tasks(true);
+        inner.write.park_tasks(true);
+
+        let inner = Arc::new(Mutex::new(inner));
+
+        let duplex = Duplex {
+            inner: inner.clone(),
+        };
+        let handle = DuplexHandle {
+            inner: inner,
+        };
+
+        (duplex, handle)
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl Read for Duplex {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.lock().unwrap().read.read(buf)
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl Write for Duplex {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut inner = self.inner.lock().unwrap();
+        let ret = inner.write.write(buf);
+        if let Some(task) = inner.handle_read_task.take() {
+            trace!("waking DuplexHandle read");
+            task.notify();
+        }
+        ret
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.lock().unwrap().write.flush()
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl AsyncRead for Duplex {
+}
+
+#[cfg(feature = "runtime")]
+impl AsyncWrite for Duplex {
+    fn shutdown(&mut self) -> Poll<(), io::Error> {
+        Ok(().into())
+    }
+
+    fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
+        let mut inner = self.inner.lock().unwrap();
+        if let Some(task) = inner.handle_read_task.take() {
+            task.notify();
+        }
+        inner.write.write_buf(buf)
+    }
+}
+
+#[cfg(feature = "runtime")]
+pub struct DuplexHandle {
+    inner: Arc<Mutex<DuplexInner>>,
+}
+
+#[cfg(feature = "runtime")]
+impl DuplexHandle {
+    pub fn read(&self, buf: &mut [u8]) -> Poll<usize, io::Error> {
+        let mut inner = self.inner.lock().unwrap();
+        assert!(buf.len() >= inner.write.inner.len());
+        if inner.write.inner.is_empty() {
+            trace!("DuplexHandle read parking");
+            inner.handle_read_task = Some(task::current());
+            return Ok(Async::NotReady);
+        }
+        inner.write.read(buf).map(Async::Ready)
+    }
+
+    pub fn write(&self, bytes: &[u8]) -> Poll<usize, io::Error> {
+        let mut inner = self.inner.lock().unwrap();
+        assert_eq!(inner.read.inner.pos, 0);
+        assert_eq!(inner.read.inner.vec.len(), 0, "write but read isn't empty");
+        inner
+            .read
+            .inner
+            .vec
+            .extend(bytes);
+        inner.read.block_in(bytes.len());
+        Ok(Async::Ready(bytes.len()))
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl Drop for DuplexHandle {
+    fn drop(&mut self) {
+        trace!("mock duplex handle drop");
+        if !::std::thread::panicking() {
+            let mut inner = self.inner.lock().unwrap();
+            inner.read.close();
+            inner.write.close();
+        }
+    }
+}
+
+#[cfg(feature = "runtime")]
+type BoxedConnectFut = Box<dyn Future<Item=(Duplex, Connected), Error=io::Error> + Send>;
+
+#[cfg(feature = "runtime")]
+#[derive(Clone)]
+pub struct MockConnector {
+    mocks: Arc<Mutex<MockedConnections>>,
+}
+
+#[cfg(feature = "runtime")]
+struct MockedConnections(HashMap<String, Vec<BoxedConnectFut>>);
+
+#[cfg(feature = "runtime")]
+impl MockConnector {
+    pub fn new() -> MockConnector {
+        MockConnector {
+            mocks: Arc::new(Mutex::new(MockedConnections(HashMap::new()))),
+        }
+    }
+
+    pub fn mock(&mut self, key: &str) -> DuplexHandle {
+        use futures::future;
+        self.mock_fut(key, future::ok::<_, ()>(()))
+    }
+
+    pub fn mock_fut<F>(&mut self, key: &str, fut: F) -> DuplexHandle
+    where
+        F: Future + Send + 'static,
+    {
+        self.mock_opts(key, Connected::new(), fut)
+    }
+
+    pub fn mock_opts<F>(&mut self, key: &str, connected: Connected, fut: F) -> DuplexHandle
+    where
+        F: Future + Send + 'static,
+    {
+        let key = key.to_owned();
+
+        let (duplex, handle) = Duplex::channel();
+
+        let fut = Box::new(fut.then(move |_| {
+            trace!("MockConnector mocked fut ready");
+            Ok((duplex, connected))
+        }));
+        self.mocks.lock().unwrap().0.entry(key)
+            .or_insert(Vec::new())
+            .push(fut);
+
+        handle
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl Connect for MockConnector {
+    type Transport = Duplex;
+    type Error = io::Error;
+    type Future = BoxedConnectFut;
+
+    fn connect(&self, dst: Destination) -> Self::Future {
+        trace!("mock connect: {:?}", dst);
+        let key = format!("{}://{}{}", dst.scheme(), dst.host(), if let Some(port) = dst.port() {
+            format!(":{}", port)
+        } else {
+            "".to_owned()
+        });
+        let mut mocks = self.mocks.lock().unwrap();
+        let mocks = mocks.0.get_mut(&key)
+            .expect(&format!("unknown mocks uri: {}", key));
+        assert!(!mocks.is_empty(), "no additional mocks for {}", key);
+        mocks.remove(0)
+    }
+}
+
+
+#[cfg(feature = "runtime")]
+impl Drop for MockedConnections {
+    fn drop(&mut self) {
+        if !::std::thread::panicking() {
+            for (key, mocks) in self.0.iter() {
+                assert_eq!(
+                    mocks.len(),
+                    0,
+                    "not all mocked connects for {:?} were used",
+                    key,
+                );
+            }
+        }
+    }
+}
+*/
diff --git a/hyper/src/proto/h1/conn.rs b/hyper/src/proto/h1/conn.rs
new file mode 100644
index 0000000..5ebff28
--- /dev/null
+++ b/hyper/src/proto/h1/conn.rs
@@ -0,0 +1,1425 @@
+use std::fmt;
+use std::io;
+use std::marker::PhantomData;
+#[cfg(all(feature = "server", feature = "runtime"))]
+use std::time::Duration;
+
+use bytes::{Buf, Bytes};
+use http::header::{HeaderValue, CONNECTION};
+use http::{HeaderMap, Method, Version};
+use httparse::ParserConfig;
+use tokio::io::{AsyncRead, AsyncWrite};
+#[cfg(all(feature = "server", feature = "runtime"))]
+use tokio::time::Sleep;
+use tracing::{debug, error, trace};
+
+use super::io::Buffered;
+use super::{Decoder, Encode, EncodedBuf, Encoder, Http1Transaction, ParseContext, Wants};
+use crate::body::DecodedLength;
+use crate::common::{task, Pin, Poll, Unpin};
+use crate::headers::connection_keep_alive;
+use crate::proto::{BodyLength, MessageHead};
+
+const H2_PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
+
+/// This handles a connection, which will have been established over an
+/// `AsyncRead + AsyncWrite` (like a socket), and will likely include multiple
+/// `Transaction`s over HTTP.
+///
+/// The connection will determine when a message begins and ends as well as
+/// determine if this connection can be kept alive after the message,
+/// or if it is complete.
+pub(crate) struct Conn<I, B, T> {
+    io: Buffered<I, EncodedBuf<B>>,
+    state: State,
+    _marker: PhantomData<fn(T)>,
+}
+
+impl<I, B, T> Conn<I, B, T>
+where
+    I: AsyncRead + AsyncWrite + Unpin,
+    B: Buf,
+    T: Http1Transaction,
+{
+    pub(crate) fn new(io: I) -> Conn<I, B, T> {
+        Conn {
+            io: Buffered::new(io),
+            state: State {
+                allow_half_close: false,
+                cached_headers: None,
+                error: None,
+                keep_alive: KA::Busy,
+                method: None,
+                h1_parser_config: ParserConfig::default(),
+                #[cfg(all(feature = "server", feature = "runtime"))]
+                h1_header_read_timeout: None,
+                #[cfg(all(feature = "server", feature = "runtime"))]
+                h1_header_read_timeout_fut: None,
+                #[cfg(all(feature = "server", feature = "runtime"))]
+                h1_header_read_timeout_running: false,
+                preserve_header_case: false,
+                #[cfg(feature = "ffi")]
+                preserve_header_order: false,
+                title_case_headers: false,
+                h09_responses: false,
+                #[cfg(feature = "ffi")]
+                on_informational: None,
+                #[cfg(feature = "ffi")]
+                raw_headers: false,
+                notify_read: false,
+                reading: Reading::Init,
+                writing: Writing::Init,
+                upgrade: None,
+                // We assume a modern world where the remote speaks HTTP/1.1.
+                // If they tell us otherwise, we'll downgrade in `read_head`.
+                version: Version::HTTP_11,
+            },
+            _marker: PhantomData,
+        }
+    }
+
+    #[cfg(feature = "server")]
+    pub(crate) fn set_flush_pipeline(&mut self, enabled: bool) {
+        self.io.set_flush_pipeline(enabled);
+    }
+
+    pub(crate) fn set_write_strategy_queue(&mut self) {
+        self.io.set_write_strategy_queue();
+    }
+
+    pub(crate) fn set_max_buf_size(&mut self, max: usize) {
+        self.io.set_max_buf_size(max);
+    }
+
+    #[cfg(feature = "client")]
+    pub(crate) fn set_read_buf_exact_size(&mut self, sz: usize) {
+        self.io.set_read_buf_exact_size(sz);
+    }
+
+    pub(crate) fn set_write_strategy_flatten(&mut self) {
+        self.io.set_write_strategy_flatten();
+    }
+
+    #[cfg(feature = "client")]
+    pub(crate) fn set_h1_parser_config(&mut self, parser_config: ParserConfig) {
+        self.state.h1_parser_config = parser_config;
+    }
+
+    pub(crate) fn set_title_case_headers(&mut self) {
+        self.state.title_case_headers = true;
+    }
+
+    pub(crate) fn set_preserve_header_case(&mut self) {
+        self.state.preserve_header_case = true;
+    }
+
+    #[cfg(feature = "ffi")]
+    pub(crate) fn set_preserve_header_order(&mut self) {
+        self.state.preserve_header_order = true;
+    }
+
+    #[cfg(feature = "client")]
+    pub(crate) fn set_h09_responses(&mut self) {
+        self.state.h09_responses = true;
+    }
+
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    pub(crate) fn set_http1_header_read_timeout(&mut self, val: Duration) {
+        self.state.h1_header_read_timeout = Some(val);
+    }
+
+    #[cfg(feature = "server")]
+    pub(crate) fn set_allow_half_close(&mut self) {
+        self.state.allow_half_close = true;
+    }
+
+    #[cfg(feature = "ffi")]
+    pub(crate) fn set_raw_headers(&mut self, enabled: bool) {
+        self.state.raw_headers = enabled;
+    }
+
+    pub(crate) fn into_inner(self) -> (I, Bytes) {
+        self.io.into_inner()
+    }
+
+    pub(crate) fn pending_upgrade(&mut self) -> Option<crate::upgrade::Pending> {
+        self.state.upgrade.take()
+    }
+
+    pub(crate) fn is_read_closed(&self) -> bool {
+        self.state.is_read_closed()
+    }
+
+    pub(crate) fn is_write_closed(&self) -> bool {
+        self.state.is_write_closed()
+    }
+
+    pub(crate) fn can_read_head(&self) -> bool {
+        if !matches!(self.state.reading, Reading::Init) {
+            return false;
+        }
+
+        if T::should_read_first() {
+            return true;
+        }
+
+        !matches!(self.state.writing, Writing::Init)
+    }
+
+    pub(crate) fn can_read_body(&self) -> bool {
+        match self.state.reading {
+            Reading::Body(..) | Reading::Continue(..) => true,
+            _ => false,
+        }
+    }
+
+    fn should_error_on_eof(&self) -> bool {
+        // If we're idle, it's probably just the connection closing gracefully.
+        T::should_error_on_parse_eof() && !self.state.is_idle()
+    }
+
+    fn has_h2_prefix(&self) -> bool {
+        let read_buf = self.io.read_buf();
+        read_buf.len() >= 24 && read_buf[..24] == *H2_PREFACE
+    }
+
+    pub(super) fn poll_read_head(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<crate::Result<(MessageHead<T::Incoming>, DecodedLength, Wants)>>> {
+        debug_assert!(self.can_read_head());
+        trace!("Conn::read_head");
+
+        let msg = match ready!(self.io.parse::<T>(
+            cx,
+            ParseContext {
+                cached_headers: &mut self.state.cached_headers,
+                req_method: &mut self.state.method,
+                h1_parser_config: self.state.h1_parser_config.clone(),
+                #[cfg(all(feature = "server", feature = "runtime"))]
+                h1_header_read_timeout: self.state.h1_header_read_timeout,
+                #[cfg(all(feature = "server", feature = "runtime"))]
+                h1_header_read_timeout_fut: &mut self.state.h1_header_read_timeout_fut,
+                #[cfg(all(feature = "server", feature = "runtime"))]
+                h1_header_read_timeout_running: &mut self.state.h1_header_read_timeout_running,
+                preserve_header_case: self.state.preserve_header_case,
+                #[cfg(feature = "ffi")]
+                preserve_header_order: self.state.preserve_header_order,
+                h09_responses: self.state.h09_responses,
+                #[cfg(feature = "ffi")]
+                on_informational: &mut self.state.on_informational,
+                #[cfg(feature = "ffi")]
+                raw_headers: self.state.raw_headers,
+            }
+        )) {
+            Ok(msg) => msg,
+            Err(e) => return self.on_read_head_error(e),
+        };
+
+        // Note: don't deconstruct `msg` into local variables, it appears
+        // the optimizer doesn't remove the extra copies.
+
+        debug!("incoming body is {}", msg.decode);
+
+        // Prevent accepting HTTP/0.9 responses after the initial one, if any.
+        self.state.h09_responses = false;
+
+        // Drop any OnInformational callbacks, we're done there!
+        #[cfg(feature = "ffi")]
+        {
+            self.state.on_informational = None;
+        }
+
+        self.state.busy();
+        self.state.keep_alive &= msg.keep_alive;
+        self.state.version = msg.head.version;
+
+        let mut wants = if msg.wants_upgrade {
+            Wants::UPGRADE
+        } else {
+            Wants::EMPTY
+        };
+
+        if msg.decode == DecodedLength::ZERO {
+            if msg.expect_continue {
+                debug!("ignoring expect-continue since body is empty");
+            }
+            self.state.reading = Reading::KeepAlive;
+            if !T::should_read_first() {
+                self.try_keep_alive(cx);
+            }
+        } else if msg.expect_continue {
+            self.state.reading = Reading::Continue(Decoder::new(msg.decode));
+            wants = wants.add(Wants::EXPECT);
+        } else {
+            self.state.reading = Reading::Body(Decoder::new(msg.decode));
+        }
+
+        Poll::Ready(Some(Ok((msg.head, msg.decode, wants))))
+    }
+
+    fn on_read_head_error<Z>(&mut self, e: crate::Error) -> Poll<Option<crate::Result<Z>>> {
+        // If we are currently waiting on a message, then an empty
+        // message should be reported as an error. If not, it is just
+        // the connection closing gracefully.
+        let must_error = self.should_error_on_eof();
+        self.close_read();
+        self.io.consume_leading_lines();
+        let was_mid_parse = e.is_parse() || !self.io.read_buf().is_empty();
+        if was_mid_parse || must_error {
+            // We check if the buf contains the h2 Preface
+            debug!(
+                "parse error ({}) with {} bytes",
+                e,
+                self.io.read_buf().len()
+            );
+            match self.on_parse_error(e) {
+                Ok(()) => Poll::Pending, // XXX: wat?
+                Err(e) => Poll::Ready(Some(Err(e))),
+            }
+        } else {
+            debug!("read eof");
+            self.close_write();
+            Poll::Ready(None)
+        }
+    }
+
+    pub(crate) fn poll_read_body(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<io::Result<Bytes>>> {
+        debug_assert!(self.can_read_body());
+
+        let (reading, ret) = match self.state.reading {
+            Reading::Body(ref mut decoder) => {
+                match ready!(decoder.decode(cx, &mut self.io)) {
+                    Ok(slice) => {
+                        let (reading, chunk) = if decoder.is_eof() {
+                            debug!("incoming body completed");
+                            (
+                                Reading::KeepAlive,
+                                if !slice.is_empty() {
+                                    Some(Ok(slice))
+                                } else {
+                                    None
+                                },
+                            )
+                        } else if slice.is_empty() {
+                            error!("incoming body unexpectedly ended");
+                            // This should be unreachable, since all 3 decoders
+                            // either set eof=true or return an Err when reading
+                            // an empty slice...
+                            (Reading::Closed, None)
+                        } else {
+                            return Poll::Ready(Some(Ok(slice)));
+                        };
+                        (reading, Poll::Ready(chunk))
+                    }
+                    Err(e) => {
+                        debug!("incoming body decode error: {}", e);
+                        (Reading::Closed, Poll::Ready(Some(Err(e))))
+                    }
+                }
+            }
+            Reading::Continue(ref decoder) => {
+                // Write the 100 Continue if not already responded...
+                if let Writing::Init = self.state.writing {
+                    trace!("automatically sending 100 Continue");
+                    let cont = b"HTTP/1.1 100 Continue\r\n\r\n";
+                    self.io.headers_buf().extend_from_slice(cont);
+                }
+
+                // And now recurse once in the Reading::Body state...
+                self.state.reading = Reading::Body(decoder.clone());
+                return self.poll_read_body(cx);
+            }
+            _ => unreachable!("poll_read_body invalid state: {:?}", self.state.reading),
+        };
+
+        self.state.reading = reading;
+        self.try_keep_alive(cx);
+        ret
+    }
+
+    pub(crate) fn wants_read_again(&mut self) -> bool {
+        let ret = self.state.notify_read;
+        self.state.notify_read = false;
+        ret
+    }
+
+    pub(crate) fn poll_read_keep_alive(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<crate::Result<()>> {
+        debug_assert!(!self.can_read_head() && !self.can_read_body());
+
+        if self.is_read_closed() {
+            Poll::Pending
+        } else if self.is_mid_message() {
+            self.mid_message_detect_eof(cx)
+        } else {
+            self.require_empty_read(cx)
+        }
+    }
+
+    fn is_mid_message(&self) -> bool {
+        !matches!(
+            (&self.state.reading, &self.state.writing),
+            (&Reading::Init, &Writing::Init)
+        )
+    }
+
+    // This will check to make sure the io object read is empty.
+    //
+    // This should only be called for Clients wanting to enter the idle
+    // state.
+    fn require_empty_read(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        debug_assert!(!self.can_read_head() && !self.can_read_body() && !self.is_read_closed());
+        debug_assert!(!self.is_mid_message());
+        debug_assert!(T::is_client());
+
+        if !self.io.read_buf().is_empty() {
+            debug!("received an unexpected {} bytes", self.io.read_buf().len());
+            return Poll::Ready(Err(crate::Error::new_unexpected_message()));
+        }
+
+        let num_read = ready!(self.force_io_read(cx)).map_err(crate::Error::new_io)?;
+
+        if num_read == 0 {
+            let ret = if self.should_error_on_eof() {
+                trace!("found unexpected EOF on busy connection: {:?}", self.state);
+                Poll::Ready(Err(crate::Error::new_incomplete()))
+            } else {
+                trace!("found EOF on idle connection, closing");
+                Poll::Ready(Ok(()))
+            };
+
+            // order is important: should_error needs state BEFORE close_read
+            self.state.close_read();
+            return ret;
+        }
+
+        debug!(
+            "received unexpected {} bytes on an idle connection",
+            num_read
+        );
+        Poll::Ready(Err(crate::Error::new_unexpected_message()))
+    }
+
+    fn mid_message_detect_eof(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        debug_assert!(!self.can_read_head() && !self.can_read_body() && !self.is_read_closed());
+        debug_assert!(self.is_mid_message());
+
+        if self.state.allow_half_close || !self.io.read_buf().is_empty() {
+            return Poll::Pending;
+        }
+
+        let num_read = ready!(self.force_io_read(cx)).map_err(crate::Error::new_io)?;
+
+        if num_read == 0 {
+            trace!("found unexpected EOF on busy connection: {:?}", self.state);
+            self.state.close_read();
+            Poll::Ready(Err(crate::Error::new_incomplete()))
+        } else {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    fn force_io_read(&mut self, cx: &mut task::Context<'_>) -> Poll<io::Result<usize>> {
+        debug_assert!(!self.state.is_read_closed());
+
+        let result = ready!(self.io.poll_read_from_io(cx));
+        Poll::Ready(result.map_err(|e| {
+            trace!("force_io_read; io error = {:?}", e);
+            self.state.close();
+            e
+        }))
+    }
+
+    fn maybe_notify(&mut self, cx: &mut task::Context<'_>) {
+        // its possible that we returned NotReady from poll() without having
+        // exhausted the underlying Io. We would have done this when we
+        // determined we couldn't keep reading until we knew how writing
+        // would finish.
+
+        match self.state.reading {
+            Reading::Continue(..) | Reading::Body(..) | Reading::KeepAlive | Reading::Closed => {
+                return
+            }
+            Reading::Init => (),
+        };
+
+        match self.state.writing {
+            Writing::Body(..) => return,
+            Writing::Init | Writing::KeepAlive | Writing::Closed => (),
+        }
+
+        if !self.io.is_read_blocked() {
+            if self.io.read_buf().is_empty() {
+                match self.io.poll_read_from_io(cx) {
+                    Poll::Ready(Ok(n)) => {
+                        if n == 0 {
+                            trace!("maybe_notify; read eof");
+                            if self.state.is_idle() {
+                                self.state.close();
+                            } else {
+                                self.close_read()
+                            }
+                            return;
+                        }
+                    }
+                    Poll::Pending => {
+                        trace!("maybe_notify; read_from_io blocked");
+                        return;
+                    }
+                    Poll::Ready(Err(e)) => {
+                        trace!("maybe_notify; read_from_io error: {}", e);
+                        self.state.close();
+                        self.state.error = Some(crate::Error::new_io(e));
+                    }
+                }
+            }
+            self.state.notify_read = true;
+        }
+    }
+
+    fn try_keep_alive(&mut self, cx: &mut task::Context<'_>) {
+        self.state.try_keep_alive::<T>();
+        self.maybe_notify(cx);
+    }
+
+    pub(crate) fn can_write_head(&self) -> bool {
+        if !T::should_read_first() && matches!(self.state.reading, Reading::Closed) {
+            return false;
+        }
+
+        match self.state.writing {
+            Writing::Init => self.io.can_headers_buf(),
+            _ => false,
+        }
+    }
+
+    pub(crate) fn can_write_body(&self) -> bool {
+        match self.state.writing {
+            Writing::Body(..) => true,
+            Writing::Init | Writing::KeepAlive | Writing::Closed => false,
+        }
+    }
+
+    pub(crate) fn can_buffer_body(&self) -> bool {
+        self.io.can_buffer()
+    }
+
+    pub(crate) fn write_head(&mut self, head: MessageHead<T::Outgoing>, body: Option<BodyLength>) {
+        if let Some(encoder) = self.encode_head(head, body) {
+            self.state.writing = if !encoder.is_eof() {
+                Writing::Body(encoder)
+            } else if encoder.is_last() {
+                Writing::Closed
+            } else {
+                Writing::KeepAlive
+            };
+        }
+    }
+
+    pub(crate) fn write_full_msg(&mut self, head: MessageHead<T::Outgoing>, body: B) {
+        if let Some(encoder) =
+            self.encode_head(head, Some(BodyLength::Known(body.remaining() as u64)))
+        {
+            let is_last = encoder.is_last();
+            // Make sure we don't write a body if we weren't actually allowed
+            // to do so, like because its a HEAD request.
+            if !encoder.is_eof() {
+                encoder.danger_full_buf(body, self.io.write_buf());
+            }
+            self.state.writing = if is_last {
+                Writing::Closed
+            } else {
+                Writing::KeepAlive
+            }
+        }
+    }
+
+    fn encode_head(
+        &mut self,
+        mut head: MessageHead<T::Outgoing>,
+        body: Option<BodyLength>,
+    ) -> Option<Encoder> {
+        debug_assert!(self.can_write_head());
+
+        if !T::should_read_first() {
+            self.state.busy();
+        }
+
+        self.enforce_version(&mut head);
+
+        let buf = self.io.headers_buf();
+        match super::role::encode_headers::<T>(
+            Encode {
+                head: &mut head,
+                body,
+                #[cfg(feature = "server")]
+                keep_alive: self.state.wants_keep_alive(),
+                req_method: &mut self.state.method,
+                title_case_headers: self.state.title_case_headers,
+            },
+            buf,
+        ) {
+            Ok(encoder) => {
+                debug_assert!(self.state.cached_headers.is_none());
+                debug_assert!(head.headers.is_empty());
+                self.state.cached_headers = Some(head.headers);
+
+                #[cfg(feature = "ffi")]
+                {
+                    self.state.on_informational =
+                        head.extensions.remove::<crate::ffi::OnInformational>();
+                }
+
+                Some(encoder)
+            }
+            Err(err) => {
+                self.state.error = Some(err);
+                self.state.writing = Writing::Closed;
+                None
+            }
+        }
+    }
+
+    // Fix keep-alive when Connection: keep-alive header is not present
+    fn fix_keep_alive(&mut self, head: &mut MessageHead<T::Outgoing>) {
+        let outgoing_is_keep_alive = head
+            .headers
+            .get(CONNECTION)
+            .map(connection_keep_alive)
+            .unwrap_or(false);
+
+        if !outgoing_is_keep_alive {
+            match head.version {
+                // If response is version 1.0 and keep-alive is not present in the response,
+                // disable keep-alive so the server closes the connection
+                Version::HTTP_10 => self.state.disable_keep_alive(),
+                // If response is version 1.1 and keep-alive is wanted, add
+                // Connection: keep-alive header when not present
+                Version::HTTP_11 => {
+                    if self.state.wants_keep_alive() {
+                        head.headers
+                            .insert(CONNECTION, HeaderValue::from_static("keep-alive"));
+                    }
+                }
+                _ => (),
+            }
+        }
+    }
+
+    // If we know the remote speaks an older version, we try to fix up any messages
+    // to work with our older peer.
+    fn enforce_version(&mut self, head: &mut MessageHead<T::Outgoing>) {
+        if let Version::HTTP_10 = self.state.version {
+            // Fixes response or connection when keep-alive header is not present
+            self.fix_keep_alive(head);
+            // If the remote only knows HTTP/1.0, we should force ourselves
+            // to do only speak HTTP/1.0 as well.
+            head.version = Version::HTTP_10;
+        }
+        // If the remote speaks HTTP/1.1, then it *should* be fine with
+        // both HTTP/1.0 and HTTP/1.1 from us. So again, we just let
+        // the user's headers be.
+    }
+
+    pub(crate) fn write_body(&mut self, chunk: B) {
+        debug_assert!(self.can_write_body() && self.can_buffer_body());
+        // empty chunks should be discarded at Dispatcher level
+        debug_assert!(chunk.remaining() != 0);
+
+        let state = match self.state.writing {
+            Writing::Body(ref mut encoder) => {
+                self.io.buffer(encoder.encode(chunk));
+
+                if !encoder.is_eof() {
+                    return;
+                }
+
+                if encoder.is_last() {
+                    Writing::Closed
+                } else {
+                    Writing::KeepAlive
+                }
+            }
+            _ => unreachable!("write_body invalid state: {:?}", self.state.writing),
+        };
+
+        self.state.writing = state;
+    }
+
+    pub(crate) fn write_body_and_end(&mut self, chunk: B) {
+        debug_assert!(self.can_write_body() && self.can_buffer_body());
+        // empty chunks should be discarded at Dispatcher level
+        debug_assert!(chunk.remaining() != 0);
+
+        let state = match self.state.writing {
+            Writing::Body(ref encoder) => {
+                let can_keep_alive = encoder.encode_and_end(chunk, self.io.write_buf());
+                if can_keep_alive {
+                    Writing::KeepAlive
+                } else {
+                    Writing::Closed
+                }
+            }
+            _ => unreachable!("write_body invalid state: {:?}", self.state.writing),
+        };
+
+        self.state.writing = state;
+    }
+
+    pub(crate) fn end_body(&mut self) -> crate::Result<()> {
+        debug_assert!(self.can_write_body());
+
+        let encoder = match self.state.writing {
+            Writing::Body(ref mut enc) => enc,
+            _ => return Ok(()),
+        };
+
+        // end of stream, that means we should try to eof
+        match encoder.end() {
+            Ok(end) => {
+                if let Some(end) = end {
+                    self.io.buffer(end);
+                }
+
+                self.state.writing = if encoder.is_last() || encoder.is_close_delimited() {
+                    Writing::Closed
+                } else {
+                    Writing::KeepAlive
+                };
+
+                Ok(())
+            }
+            Err(not_eof) => {
+                self.state.writing = Writing::Closed;
+                Err(crate::Error::new_body_write_aborted().with(not_eof))
+            }
+        }
+    }
+
+    // When we get a parse error, depending on what side we are, we might be able
+    // to write a response before closing the connection.
+    //
+    // - Client: there is nothing we can do
+    // - Server: if Response hasn't been written yet, we can send a 4xx response
+    fn on_parse_error(&mut self, err: crate::Error) -> crate::Result<()> {
+        if let Writing::Init = self.state.writing {
+            if self.has_h2_prefix() {
+                return Err(crate::Error::new_version_h2());
+            }
+            if let Some(msg) = T::on_error(&err) {
+                // Drop the cached headers so as to not trigger a debug
+                // assert in `write_head`...
+                self.state.cached_headers.take();
+                self.write_head(msg, None);
+                self.state.error = Some(err);
+                return Ok(());
+            }
+        }
+
+        // fallback is pass the error back up
+        Err(err)
+    }
+
+    pub(crate) fn poll_flush(&mut self, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+        ready!(Pin::new(&mut self.io).poll_flush(cx))?;
+        self.try_keep_alive(cx);
+        trace!("flushed({}): {:?}", T::LOG, self.state);
+        Poll::Ready(Ok(()))
+    }
+
+    pub(crate) fn poll_shutdown(&mut self, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+        match ready!(Pin::new(self.io.io_mut()).poll_shutdown(cx)) {
+            Ok(()) => {
+                trace!("shut down IO complete");
+                Poll::Ready(Ok(()))
+            }
+            Err(e) => {
+                debug!("error shutting down IO: {}", e);
+                Poll::Ready(Err(e))
+            }
+        }
+    }
+
+    /// If the read side can be cheaply drained, do so. Otherwise, close.
+    pub(super) fn poll_drain_or_close_read(&mut self, cx: &mut task::Context<'_>) {
+        if let Reading::Continue(ref decoder) = self.state.reading {
+            // skip sending the 100-continue
+            // just move forward to a read, in case a tiny body was included
+            self.state.reading = Reading::Body(decoder.clone());
+        }
+
+        let _ = self.poll_read_body(cx);
+
+        // If still in Reading::Body, just give up
+        match self.state.reading {
+            Reading::Init | Reading::KeepAlive => trace!("body drained"),
+            _ => self.close_read(),
+        }
+    }
+
+    pub(crate) fn close_read(&mut self) {
+        self.state.close_read();
+    }
+
+    pub(crate) fn close_write(&mut self) {
+        self.state.close_write();
+    }
+
+    #[cfg(feature = "server")]
+    pub(crate) fn disable_keep_alive(&mut self) {
+        if self.state.is_idle() {
+            trace!("disable_keep_alive; closing idle connection");
+            self.state.close();
+        } else {
+            trace!("disable_keep_alive; in-progress connection");
+            self.state.disable_keep_alive();
+        }
+    }
+
+    pub(crate) fn take_error(&mut self) -> crate::Result<()> {
+        if let Some(err) = self.state.error.take() {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    }
+
+    pub(super) fn on_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
+        trace!("{}: prepare possible HTTP upgrade", T::LOG);
+        self.state.prepare_upgrade()
+    }
+}
+
+impl<I, B: Buf, T> fmt::Debug for Conn<I, B, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Conn")
+            .field("state", &self.state)
+            .field("io", &self.io)
+            .finish()
+    }
+}
+
+// B and T are never pinned
+impl<I: Unpin, B, T> Unpin for Conn<I, B, T> {}
+
+struct State {
+    allow_half_close: bool,
+    /// Re-usable HeaderMap to reduce allocating new ones.
+    cached_headers: Option<HeaderMap>,
+    /// If an error occurs when there wasn't a direct way to return it
+    /// back to the user, this is set.
+    error: Option<crate::Error>,
+    /// Current keep-alive status.
+    keep_alive: KA,
+    /// If mid-message, the HTTP Method that started it.
+    ///
+    /// This is used to know things such as if the message can include
+    /// a body or not.
+    method: Option<Method>,
+    h1_parser_config: ParserConfig,
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    h1_header_read_timeout: Option<Duration>,
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    h1_header_read_timeout_fut: Option<Pin<Box<Sleep>>>,
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    h1_header_read_timeout_running: bool,
+    preserve_header_case: bool,
+    #[cfg(feature = "ffi")]
+    preserve_header_order: bool,
+    title_case_headers: bool,
+    h09_responses: bool,
+    /// If set, called with each 1xx informational response received for
+    /// the current request. MUST be unset after a non-1xx response is
+    /// received.
+    #[cfg(feature = "ffi")]
+    on_informational: Option<crate::ffi::OnInformational>,
+    #[cfg(feature = "ffi")]
+    raw_headers: bool,
+    /// Set to true when the Dispatcher should poll read operations
+    /// again. See the `maybe_notify` method for more.
+    notify_read: bool,
+    /// State of allowed reads
+    reading: Reading,
+    /// State of allowed writes
+    writing: Writing,
+    /// An expected pending HTTP upgrade.
+    upgrade: Option<crate::upgrade::Pending>,
+    /// Either HTTP/1.0 or 1.1 connection
+    version: Version,
+}
+
+#[derive(Debug)]
+enum Reading {
+    Init,
+    Continue(Decoder),
+    Body(Decoder),
+    KeepAlive,
+    Closed,
+}
+
+enum Writing {
+    Init,
+    Body(Encoder),
+    KeepAlive,
+    Closed,
+}
+
+impl fmt::Debug for State {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut builder = f.debug_struct("State");
+        builder
+            .field("reading", &self.reading)
+            .field("writing", &self.writing)
+            .field("keep_alive", &self.keep_alive);
+
+        // Only show error field if it's interesting...
+        if let Some(ref error) = self.error {
+            builder.field("error", error);
+        }
+
+        if self.allow_half_close {
+            builder.field("allow_half_close", &true);
+        }
+
+        // Purposefully leaving off other fields..
+
+        builder.finish()
+    }
+}
+
+impl fmt::Debug for Writing {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Writing::Init => f.write_str("Init"),
+            Writing::Body(ref enc) => f.debug_tuple("Body").field(enc).finish(),
+            Writing::KeepAlive => f.write_str("KeepAlive"),
+            Writing::Closed => f.write_str("Closed"),
+        }
+    }
+}
+
+impl std::ops::BitAndAssign<bool> for KA {
+    fn bitand_assign(&mut self, enabled: bool) {
+        if !enabled {
+            trace!("remote disabling keep-alive");
+            *self = KA::Disabled;
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum KA {
+    Idle,
+    Busy,
+    Disabled,
+}
+
+impl Default for KA {
+    fn default() -> KA {
+        KA::Busy
+    }
+}
+
+impl KA {
+    fn idle(&mut self) {
+        *self = KA::Idle;
+    }
+
+    fn busy(&mut self) {
+        *self = KA::Busy;
+    }
+
+    fn disable(&mut self) {
+        *self = KA::Disabled;
+    }
+
+    fn status(&self) -> KA {
+        *self
+    }
+}
+
+impl State {
+    fn close(&mut self) {
+        trace!("State::close()");
+        self.reading = Reading::Closed;
+        self.writing = Writing::Closed;
+        self.keep_alive.disable();
+    }
+
+    fn close_read(&mut self) {
+        trace!("State::close_read()");
+        self.reading = Reading::Closed;
+        self.keep_alive.disable();
+    }
+
+    fn close_write(&mut self) {
+        trace!("State::close_write()");
+        self.writing = Writing::Closed;
+        self.keep_alive.disable();
+    }
+
+    fn wants_keep_alive(&self) -> bool {
+        if let KA::Disabled = self.keep_alive.status() {
+            false
+        } else {
+            true
+        }
+    }
+
+    fn try_keep_alive<T: Http1Transaction>(&mut self) {
+        match (&self.reading, &self.writing) {
+            (&Reading::KeepAlive, &Writing::KeepAlive) => {
+                if let KA::Busy = self.keep_alive.status() {
+                    self.idle::<T>();
+                } else {
+                    trace!(
+                        "try_keep_alive({}): could keep-alive, but status = {:?}",
+                        T::LOG,
+                        self.keep_alive
+                    );
+                    self.close();
+                }
+            }
+            (&Reading::Closed, &Writing::KeepAlive) | (&Reading::KeepAlive, &Writing::Closed) => {
+                self.close()
+            }
+            _ => (),
+        }
+    }
+
+    fn disable_keep_alive(&mut self) {
+        self.keep_alive.disable()
+    }
+
+    fn busy(&mut self) {
+        if let KA::Disabled = self.keep_alive.status() {
+            return;
+        }
+        self.keep_alive.busy();
+    }
+
+    fn idle<T: Http1Transaction>(&mut self) {
+        debug_assert!(!self.is_idle(), "State::idle() called while idle");
+
+        self.method = None;
+        self.keep_alive.idle();
+
+        if !self.is_idle() {
+            self.close();
+            return;
+        }
+
+        self.reading = Reading::Init;
+        self.writing = Writing::Init;
+
+        // !T::should_read_first() means Client.
+        //
+        // If Client connection has just gone idle, the Dispatcher
+        // should try the poll loop one more time, so as to poll the
+        // pending requests stream.
+        if !T::should_read_first() {
+            self.notify_read = true;
+        }
+    }
+
+    fn is_idle(&self) -> bool {
+        matches!(self.keep_alive.status(), KA::Idle)
+    }
+
+    fn is_read_closed(&self) -> bool {
+        matches!(self.reading, Reading::Closed)
+    }
+
+    fn is_write_closed(&self) -> bool {
+        matches!(self.writing, Writing::Closed)
+    }
+
+    fn prepare_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
+        let (tx, rx) = crate::upgrade::pending();
+        self.upgrade = Some(tx);
+        rx
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_read_head_short(b: &mut ::test::Bencher) {
+        use super::*;
+        let s = b"GET / HTTP/1.1\r\nHost: localhost:8080\r\n\r\n";
+        let len = s.len();
+        b.bytes = len as u64;
+
+        // an empty IO, we'll be skipping and using the read buffer anyways
+        let io = tokio_test::io::Builder::new().build();
+        let mut conn = Conn::<_, bytes::Bytes, crate::proto::h1::ServerTransaction>::new(io);
+        *conn.io.read_buf_mut() = ::bytes::BytesMut::from(&s[..]);
+        conn.state.cached_headers = Some(HeaderMap::with_capacity(2));
+
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+
+        b.iter(|| {
+            rt.block_on(futures_util::future::poll_fn(|cx| {
+                match conn.poll_read_head(cx) {
+                    Poll::Ready(Some(Ok(x))) => {
+                        ::test::black_box(&x);
+                        let mut headers = x.0.headers;
+                        headers.clear();
+                        conn.state.cached_headers = Some(headers);
+                    }
+                    f => panic!("expected Ready(Some(Ok(..))): {:?}", f),
+                }
+
+                conn.io.read_buf_mut().reserve(1);
+                unsafe {
+                    conn.io.read_buf_mut().set_len(len);
+                }
+                conn.state.reading = Reading::Init;
+                Poll::Ready(())
+            }));
+        });
+    }
+
+    /*
+    //TODO: rewrite these using dispatch... someday...
+    use futures::{Async, Future, Stream, Sink};
+    use futures::future;
+
+    use proto::{self, ClientTransaction, MessageHead, ServerTransaction};
+    use super::super::Encoder;
+    use mock::AsyncIo;
+
+    use super::{Conn, Decoder, Reading, Writing};
+    use ::uri::Uri;
+
+    use std::str::FromStr;
+
+    #[test]
+    fn test_conn_init_read() {
+        let good_message = b"GET / HTTP/1.1\r\n\r\n".to_vec();
+        let len = good_message.len();
+        let io = AsyncIo::new_buf(good_message, len);
+        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+
+        match conn.poll().unwrap() {
+            Async::Ready(Some(Frame::Message { message, body: false })) => {
+                assert_eq!(message, MessageHead {
+                    subject: ::proto::RequestLine(::Get, Uri::from_str("/").unwrap()),
+                    .. MessageHead::default()
+                })
+            },
+            f => panic!("frame is not Frame::Message: {:?}", f)
+        }
+    }
+
+    #[test]
+    fn test_conn_parse_partial() {
+        let _: Result<(), ()> = future::lazy(|| {
+            let good_message = b"GET / HTTP/1.1\r\nHost: foo.bar\r\n\r\n".to_vec();
+            let io = AsyncIo::new_buf(good_message, 10);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            assert!(conn.poll().unwrap().is_not_ready());
+            conn.io.io_mut().block_in(50);
+            let async = conn.poll().unwrap();
+            assert!(async.is_ready());
+            match async {
+                Async::Ready(Some(Frame::Message { .. })) => (),
+                f => panic!("frame is not Message: {:?}", f),
+            }
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_init_read_eof_idle() {
+        let io = AsyncIo::new_buf(vec![], 1);
+        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+        conn.state.idle();
+
+        match conn.poll().unwrap() {
+            Async::Ready(None) => {},
+            other => panic!("frame is not None: {:?}", other)
+        }
+    }
+
+    #[test]
+    fn test_conn_init_read_eof_idle_partial_parse() {
+        let io = AsyncIo::new_buf(b"GET / HTTP/1.1".to_vec(), 100);
+        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+        conn.state.idle();
+
+        match conn.poll() {
+            Err(ref err) if err.kind() == std::io::ErrorKind::UnexpectedEof => {},
+            other => panic!("unexpected frame: {:?}", other)
+        }
+    }
+
+    #[test]
+    fn test_conn_init_read_eof_busy() {
+        let _: Result<(), ()> = future::lazy(|| {
+            // server ignores
+            let io = AsyncIo::new_eof();
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            conn.state.busy();
+
+            match conn.poll().unwrap() {
+                Async::Ready(None) => {},
+                other => panic!("unexpected frame: {:?}", other)
+            }
+
+            // client
+            let io = AsyncIo::new_eof();
+            let mut conn = Conn::<_, proto::Bytes, ClientTransaction>::new(io);
+            conn.state.busy();
+
+            match conn.poll() {
+                Err(ref err) if err.kind() == std::io::ErrorKind::UnexpectedEof => {},
+                other => panic!("unexpected frame: {:?}", other)
+            }
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_body_finish_read_eof() {
+        let _: Result<(), ()> = future::lazy(|| {
+            let io = AsyncIo::new_eof();
+            let mut conn = Conn::<_, proto::Bytes, ClientTransaction>::new(io);
+            conn.state.busy();
+            conn.state.writing = Writing::KeepAlive;
+            conn.state.reading = Reading::Body(Decoder::length(0));
+
+            match conn.poll() {
+                Ok(Async::Ready(Some(Frame::Body { chunk: None }))) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+
+            // conn eofs, but tokio-proto will call poll() again, before calling flush()
+            // the conn eof in this case is perfectly fine
+
+            match conn.poll() {
+                Ok(Async::Ready(None)) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_message_empty_body_read_eof() {
+        let _: Result<(), ()> = future::lazy(|| {
+            let io = AsyncIo::new_buf(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n".to_vec(), 1024);
+            let mut conn = Conn::<_, proto::Bytes, ClientTransaction>::new(io);
+            conn.state.busy();
+            conn.state.writing = Writing::KeepAlive;
+
+            match conn.poll() {
+                Ok(Async::Ready(Some(Frame::Message { body: false, .. }))) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+
+            // conn eofs, but tokio-proto will call poll() again, before calling flush()
+            // the conn eof in this case is perfectly fine
+
+            match conn.poll() {
+                Ok(Async::Ready(None)) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_read_body_end() {
+        let _: Result<(), ()> = future::lazy(|| {
+            let io = AsyncIo::new_buf(b"POST / HTTP/1.1\r\nContent-Length: 5\r\n\r\n12345".to_vec(), 1024);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            conn.state.busy();
+
+            match conn.poll() {
+                Ok(Async::Ready(Some(Frame::Message { body: true, .. }))) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+
+            match conn.poll() {
+                Ok(Async::Ready(Some(Frame::Body { chunk: Some(_) }))) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+
+            // When the body is done, `poll` MUST return a `Body` frame with chunk set to `None`
+            match conn.poll() {
+                Ok(Async::Ready(Some(Frame::Body { chunk: None }))) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+
+            match conn.poll() {
+                Ok(Async::NotReady) => (),
+                other => panic!("unexpected frame: {:?}", other)
+            }
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_closed_read() {
+        let io = AsyncIo::new_buf(vec![], 0);
+        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+        conn.state.close();
+
+        match conn.poll().unwrap() {
+            Async::Ready(None) => {},
+            other => panic!("frame is not None: {:?}", other)
+        }
+    }
+
+    #[test]
+    fn test_conn_body_write_length() {
+        let _ = pretty_env_logger::try_init();
+        let _: Result<(), ()> = future::lazy(|| {
+            let io = AsyncIo::new_buf(vec![], 0);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            let max = super::super::io::DEFAULT_MAX_BUFFER_SIZE + 4096;
+            conn.state.writing = Writing::Body(Encoder::length((max * 2) as u64));
+
+            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'a'; max].into()) }).unwrap().is_ready());
+            assert!(!conn.can_buffer_body());
+
+            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'b'; 1024 * 8].into()) }).unwrap().is_not_ready());
+
+            conn.io.io_mut().block_in(1024 * 3);
+            assert!(conn.poll_complete().unwrap().is_not_ready());
+            conn.io.io_mut().block_in(1024 * 3);
+            assert!(conn.poll_complete().unwrap().is_not_ready());
+            conn.io.io_mut().block_in(max * 2);
+            assert!(conn.poll_complete().unwrap().is_ready());
+
+            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'c'; 1024 * 8].into()) }).unwrap().is_ready());
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_body_write_chunked() {
+        let _: Result<(), ()> = future::lazy(|| {
+            let io = AsyncIo::new_buf(vec![], 4096);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            conn.state.writing = Writing::Body(Encoder::chunked());
+
+            assert!(conn.start_send(Frame::Body { chunk: Some("headers".into()) }).unwrap().is_ready());
+            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'x'; 8192].into()) }).unwrap().is_ready());
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_body_flush() {
+        let _: Result<(), ()> = future::lazy(|| {
+            let io = AsyncIo::new_buf(vec![], 1024 * 1024 * 5);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            conn.state.writing = Writing::Body(Encoder::length(1024 * 1024));
+            assert!(conn.start_send(Frame::Body { chunk: Some(vec![b'a'; 1024 * 1024].into()) }).unwrap().is_ready());
+            assert!(!conn.can_buffer_body());
+            conn.io.io_mut().block_in(1024 * 1024 * 5);
+            assert!(conn.poll_complete().unwrap().is_ready());
+            assert!(conn.can_buffer_body());
+            assert!(conn.io.io_mut().flushed());
+
+            Ok(())
+        }).wait();
+    }
+
+    #[test]
+    fn test_conn_parking() {
+        use std::sync::Arc;
+        use futures::executor::Notify;
+        use futures::executor::NotifyHandle;
+
+        struct Car {
+            permit: bool,
+        }
+        impl Notify for Car {
+            fn notify(&self, _id: usize) {
+                assert!(self.permit, "unparked without permit");
+            }
+        }
+
+        fn car(permit: bool) -> NotifyHandle {
+            Arc::new(Car {
+                permit: permit,
+            }).into()
+        }
+
+        // test that once writing is done, unparks
+        let f = future::lazy(|| {
+            let io = AsyncIo::new_buf(vec![], 4096);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            conn.state.reading = Reading::KeepAlive;
+            assert!(conn.poll().unwrap().is_not_ready());
+
+            conn.state.writing = Writing::KeepAlive;
+            assert!(conn.poll_complete().unwrap().is_ready());
+            Ok::<(), ()>(())
+        });
+        ::futures::executor::spawn(f).poll_future_notify(&car(true), 0).unwrap();
+
+
+        // test that flushing when not waiting on read doesn't unpark
+        let f = future::lazy(|| {
+            let io = AsyncIo::new_buf(vec![], 4096);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            conn.state.writing = Writing::KeepAlive;
+            assert!(conn.poll_complete().unwrap().is_ready());
+            Ok::<(), ()>(())
+        });
+        ::futures::executor::spawn(f).poll_future_notify(&car(false), 0).unwrap();
+
+
+        // test that flushing and writing isn't done doesn't unpark
+        let f = future::lazy(|| {
+            let io = AsyncIo::new_buf(vec![], 4096);
+            let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+            conn.state.reading = Reading::KeepAlive;
+            assert!(conn.poll().unwrap().is_not_ready());
+            conn.state.writing = Writing::Body(Encoder::length(5_000));
+            assert!(conn.poll_complete().unwrap().is_ready());
+            Ok::<(), ()>(())
+        });
+        ::futures::executor::spawn(f).poll_future_notify(&car(false), 0).unwrap();
+    }
+
+    #[test]
+    fn test_conn_closed_write() {
+        let io = AsyncIo::new_buf(vec![], 0);
+        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+        conn.state.close();
+
+        match conn.start_send(Frame::Body { chunk: Some(b"foobar".to_vec().into()) }) {
+            Err(_e) => {},
+            other => panic!("did not return Err: {:?}", other)
+        }
+
+        assert!(conn.state.is_write_closed());
+    }
+
+    #[test]
+    fn test_conn_write_empty_chunk() {
+        let io = AsyncIo::new_buf(vec![], 0);
+        let mut conn = Conn::<_, proto::Bytes, ServerTransaction>::new(io);
+        conn.state.writing = Writing::KeepAlive;
+
+        assert!(conn.start_send(Frame::Body { chunk: None }).unwrap().is_ready());
+        assert!(conn.start_send(Frame::Body { chunk: Some(Vec::new().into()) }).unwrap().is_ready());
+        conn.start_send(Frame::Body { chunk: Some(vec![b'a'].into()) }).unwrap_err();
+    }
+    */
+}
diff --git a/hyper/src/proto/h1/decode.rs b/hyper/src/proto/h1/decode.rs
new file mode 100644
index 0000000..1e3a38e
--- /dev/null
+++ b/hyper/src/proto/h1/decode.rs
@@ -0,0 +1,731 @@
+use std::error::Error as StdError;
+use std::fmt;
+use std::io;
+use std::usize;
+
+use bytes::Bytes;
+use tracing::{debug, trace};
+
+use crate::common::{task, Poll};
+
+use super::io::MemRead;
+use super::DecodedLength;
+
+use self::Kind::{Chunked, Eof, Length};
+
+/// Decoders to handle different Transfer-Encodings.
+///
+/// If a message body does not include a Transfer-Encoding, it *should*
+/// include a Content-Length header.
+#[derive(Clone, PartialEq)]
+pub(crate) struct Decoder {
+    kind: Kind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum Kind {
+    /// A Reader used when a Content-Length header is passed with a positive integer.
+    Length(u64),
+    /// A Reader used when Transfer-Encoding is `chunked`.
+    Chunked(ChunkedState, u64),
+    /// A Reader used for responses that don't indicate a length or chunked.
+    ///
+    /// The bool tracks when EOF is seen on the transport.
+    ///
+    /// Note: This should only used for `Response`s. It is illegal for a
+    /// `Request` to be made with both `Content-Length` and
+    /// `Transfer-Encoding: chunked` missing, as explained from the spec:
+    ///
+    /// > If a Transfer-Encoding header field is present in a response and
+    /// > the chunked transfer coding is not the final encoding, the
+    /// > message body length is determined by reading the connection until
+    /// > it is closed by the server.  If a Transfer-Encoding header field
+    /// > is present in a request and the chunked transfer coding is not
+    /// > the final encoding, the message body length cannot be determined
+    /// > reliably; the server MUST respond with the 400 (Bad Request)
+    /// > status code and then close the connection.
+    Eof(bool),
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+enum ChunkedState {
+    Size,
+    SizeLws,
+    Extension,
+    SizeLf,
+    Body,
+    BodyCr,
+    BodyLf,
+    Trailer,
+    TrailerLf,
+    EndCr,
+    EndLf,
+    End,
+}
+
+impl Decoder {
+    // constructors
+
+    pub(crate) fn length(x: u64) -> Decoder {
+        Decoder {
+            kind: Kind::Length(x),
+        }
+    }
+
+    pub(crate) fn chunked() -> Decoder {
+        Decoder {
+            kind: Kind::Chunked(ChunkedState::Size, 0),
+        }
+    }
+
+    pub(crate) fn eof() -> Decoder {
+        Decoder {
+            kind: Kind::Eof(false),
+        }
+    }
+
+    pub(super) fn new(len: DecodedLength) -> Self {
+        match len {
+            DecodedLength::CHUNKED => Decoder::chunked(),
+            DecodedLength::CLOSE_DELIMITED => Decoder::eof(),
+            length => Decoder::length(length.danger_len()),
+        }
+    }
+
+    // methods
+
+    pub(crate) fn is_eof(&self) -> bool {
+        matches!(self.kind, Length(0) | Chunked(ChunkedState::End, _) | Eof(true))
+    }
+
+    pub(crate) fn decode<R: MemRead>(
+        &mut self,
+        cx: &mut task::Context<'_>,
+        body: &mut R,
+    ) -> Poll<Result<Bytes, io::Error>> {
+        trace!("decode; state={:?}", self.kind);
+        match self.kind {
+            Length(ref mut remaining) => {
+                if *remaining == 0 {
+                    Poll::Ready(Ok(Bytes::new()))
+                } else {
+                    let to_read = *remaining as usize;
+                    let buf = ready!(body.read_mem(cx, to_read))?;
+                    let num = buf.as_ref().len() as u64;
+                    if num > *remaining {
+                        *remaining = 0;
+                    } else if num == 0 {
+                        return Poll::Ready(Err(io::Error::new(
+                            io::ErrorKind::UnexpectedEof,
+                            IncompleteBody,
+                        )));
+                    } else {
+                        *remaining -= num;
+                    }
+                    Poll::Ready(Ok(buf))
+                }
+            }
+            Chunked(ref mut state, ref mut size) => {
+                loop {
+                    let mut buf = None;
+                    // advances the chunked state
+                    *state = ready!(state.step(cx, body, size, &mut buf))?;
+                    if *state == ChunkedState::End {
+                        trace!("end of chunked");
+                        return Poll::Ready(Ok(Bytes::new()));
+                    }
+                    if let Some(buf) = buf {
+                        return Poll::Ready(Ok(buf));
+                    }
+                }
+            }
+            Eof(ref mut is_eof) => {
+                if *is_eof {
+                    Poll::Ready(Ok(Bytes::new()))
+                } else {
+                    // 8192 chosen because its about 2 packets, there probably
+                    // won't be that much available, so don't have MemReaders
+                    // allocate buffers to big
+                    body.read_mem(cx, 8192).map_ok(|slice| {
+                        *is_eof = slice.is_empty();
+                        slice
+                    })
+                }
+            }
+        }
+    }
+
+    #[cfg(test)]
+    async fn decode_fut<R: MemRead>(&mut self, body: &mut R) -> Result<Bytes, io::Error> {
+        futures_util::future::poll_fn(move |cx| self.decode(cx, body)).await
+    }
+}
+
+impl fmt::Debug for Decoder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.kind, f)
+    }
+}
+
+macro_rules! byte (
+    ($rdr:ident, $cx:expr) => ({
+        let buf = ready!($rdr.read_mem($cx, 1))?;
+        if !buf.is_empty() {
+            buf[0]
+        } else {
+            return Poll::Ready(Err(io::Error::new(io::ErrorKind::UnexpectedEof,
+                                      "unexpected EOF during chunk size line")));
+        }
+    })
+);
+
+impl ChunkedState {
+    fn step<R: MemRead>(
+        &self,
+        cx: &mut task::Context<'_>,
+        body: &mut R,
+        size: &mut u64,
+        buf: &mut Option<Bytes>,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        use self::ChunkedState::*;
+        match *self {
+            Size => ChunkedState::read_size(cx, body, size),
+            SizeLws => ChunkedState::read_size_lws(cx, body),
+            Extension => ChunkedState::read_extension(cx, body),
+            SizeLf => ChunkedState::read_size_lf(cx, body, *size),
+            Body => ChunkedState::read_body(cx, body, size, buf),
+            BodyCr => ChunkedState::read_body_cr(cx, body),
+            BodyLf => ChunkedState::read_body_lf(cx, body),
+            Trailer => ChunkedState::read_trailer(cx, body),
+            TrailerLf => ChunkedState::read_trailer_lf(cx, body),
+            EndCr => ChunkedState::read_end_cr(cx, body),
+            EndLf => ChunkedState::read_end_lf(cx, body),
+            End => Poll::Ready(Ok(ChunkedState::End)),
+        }
+    }
+    fn read_size<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+        size: &mut u64,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("Read chunk hex size");
+
+        macro_rules! or_overflow {
+            ($e:expr) => (
+                match $e {
+                    Some(val) => val,
+                    None => return Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::InvalidData,
+                        "invalid chunk size: overflow",
+                    ))),
+                }
+            )
+        }
+
+        let radix = 16;
+        match byte!(rdr, cx) {
+            b @ b'0'..=b'9' => {
+                *size = or_overflow!(size.checked_mul(radix));
+                *size = or_overflow!(size.checked_add((b - b'0') as u64));
+            }
+            b @ b'a'..=b'f' => {
+                *size = or_overflow!(size.checked_mul(radix));
+                *size = or_overflow!(size.checked_add((b + 10 - b'a') as u64));
+            }
+            b @ b'A'..=b'F' => {
+                *size = or_overflow!(size.checked_mul(radix));
+                *size = or_overflow!(size.checked_add((b + 10 - b'A') as u64));
+            }
+            b'\t' | b' ' => return Poll::Ready(Ok(ChunkedState::SizeLws)),
+            b';' => return Poll::Ready(Ok(ChunkedState::Extension)),
+            b'\r' => return Poll::Ready(Ok(ChunkedState::SizeLf)),
+            _ => {
+                return Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "Invalid chunk size line: Invalid Size",
+                )));
+            }
+        }
+        Poll::Ready(Ok(ChunkedState::Size))
+    }
+    fn read_size_lws<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("read_size_lws");
+        match byte!(rdr, cx) {
+            // LWS can follow the chunk size, but no more digits can come
+            b'\t' | b' ' => Poll::Ready(Ok(ChunkedState::SizeLws)),
+            b';' => Poll::Ready(Ok(ChunkedState::Extension)),
+            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk size linear white space",
+            ))),
+        }
+    }
+    fn read_extension<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("read_extension");
+        // We don't care about extensions really at all. Just ignore them.
+        // They "end" at the next CRLF.
+        //
+        // However, some implementations may not check for the CR, so to save
+        // them from themselves, we reject extensions containing plain LF as
+        // well.
+        match byte!(rdr, cx) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
+            b'\n' => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "invalid chunk extension contains newline",
+            ))),
+            _ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
+        }
+    }
+    fn read_size_lf<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+        size: u64,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("Chunk size is {:?}", size);
+        match byte!(rdr, cx) {
+            b'\n' => {
+                if size == 0 {
+                    Poll::Ready(Ok(ChunkedState::EndCr))
+                } else {
+                    debug!("incoming chunked header: {0:#X} ({0} bytes)", size);
+                    Poll::Ready(Ok(ChunkedState::Body))
+                }
+            }
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk size LF",
+            ))),
+        }
+    }
+
+    fn read_body<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+        rem: &mut u64,
+        buf: &mut Option<Bytes>,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("Chunked read, remaining={:?}", rem);
+
+        // cap remaining bytes at the max capacity of usize
+        let rem_cap = match *rem {
+            r if r > usize::MAX as u64 => usize::MAX,
+            r => r as usize,
+        };
+
+        let to_read = rem_cap;
+        let slice = ready!(rdr.read_mem(cx, to_read))?;
+        let count = slice.len();
+
+        if count == 0 {
+            *rem = 0;
+            return Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::UnexpectedEof,
+                IncompleteBody,
+            )));
+        }
+        *buf = Some(slice);
+        *rem -= count as u64;
+
+        if *rem > 0 {
+            Poll::Ready(Ok(ChunkedState::Body))
+        } else {
+            Poll::Ready(Ok(ChunkedState::BodyCr))
+        }
+    }
+    fn read_body_cr<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr, cx) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::BodyLf)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk body CR",
+            ))),
+        }
+    }
+    fn read_body_lf<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr, cx) {
+            b'\n' => Poll::Ready(Ok(ChunkedState::Size)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk body LF",
+            ))),
+        }
+    }
+
+    fn read_trailer<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        trace!("read_trailer");
+        match byte!(rdr, cx) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::TrailerLf)),
+            _ => Poll::Ready(Ok(ChunkedState::Trailer)),
+        }
+    }
+    fn read_trailer_lf<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr, cx) {
+            b'\n' => Poll::Ready(Ok(ChunkedState::EndCr)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid trailer end LF",
+            ))),
+        }
+    }
+
+    fn read_end_cr<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr, cx) {
+            b'\r' => Poll::Ready(Ok(ChunkedState::EndLf)),
+            _ => Poll::Ready(Ok(ChunkedState::Trailer)),
+        }
+    }
+    fn read_end_lf<R: MemRead>(
+        cx: &mut task::Context<'_>,
+        rdr: &mut R,
+    ) -> Poll<Result<ChunkedState, io::Error>> {
+        match byte!(rdr, cx) {
+            b'\n' => Poll::Ready(Ok(ChunkedState::End)),
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Invalid chunk end LF",
+            ))),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct IncompleteBody;
+
+impl fmt::Display for IncompleteBody {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "end of file before message length reached")
+    }
+}
+
+impl StdError for IncompleteBody {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::pin::Pin;
+    use std::time::Duration;
+    use tokio::io::{AsyncRead, ReadBuf};
+
+    impl<'a> MemRead for &'a [u8] {
+        fn read_mem(&mut self, _: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
+            let n = std::cmp::min(len, self.len());
+            if n > 0 {
+                let (a, b) = self.split_at(n);
+                let buf = Bytes::copy_from_slice(a);
+                *self = b;
+                Poll::Ready(Ok(buf))
+            } else {
+                Poll::Ready(Ok(Bytes::new()))
+            }
+        }
+    }
+
+    impl<'a> MemRead for &'a mut (dyn AsyncRead + Unpin) {
+        fn read_mem(&mut self, cx: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
+            let mut v = vec![0; len];
+            let mut buf = ReadBuf::new(&mut v);
+            ready!(Pin::new(self).poll_read(cx, &mut buf)?);
+            Poll::Ready(Ok(Bytes::copy_from_slice(&buf.filled())))
+        }
+    }
+
+    #[cfg(feature = "nightly")]
+    impl MemRead for Bytes {
+        fn read_mem(&mut self, _: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
+            let n = std::cmp::min(len, self.len());
+            let ret = self.split_to(n);
+            Poll::Ready(Ok(ret))
+        }
+    }
+
+    /*
+    use std::io;
+    use std::io::Write;
+    use super::Decoder;
+    use super::ChunkedState;
+    use futures::{Async, Poll};
+    use bytes::{BytesMut, Bytes};
+    use crate::mock::AsyncIo;
+    */
+
+    #[tokio::test]
+    async fn test_read_chunk_size() {
+        use std::io::ErrorKind::{InvalidData, InvalidInput, UnexpectedEof};
+
+        async fn read(s: &str) -> u64 {
+            let mut state = ChunkedState::Size;
+            let rdr = &mut s.as_bytes();
+            let mut size = 0;
+            loop {
+                let result =
+                    futures_util::future::poll_fn(|cx| state.step(cx, rdr, &mut size, &mut None))
+                        .await;
+                let desc = format!("read_size failed for {:?}", s);
+                state = result.expect(desc.as_str());
+                if state == ChunkedState::Body || state == ChunkedState::EndCr {
+                    break;
+                }
+            }
+            size
+        }
+
+        async fn read_err(s: &str, expected_err: io::ErrorKind) {
+            let mut state = ChunkedState::Size;
+            let rdr = &mut s.as_bytes();
+            let mut size = 0;
+            loop {
+                let result =
+                    futures_util::future::poll_fn(|cx| state.step(cx, rdr, &mut size, &mut None))
+                        .await;
+                state = match result {
+                    Ok(s) => s,
+                    Err(e) => {
+                        assert!(
+                            expected_err == e.kind(),
+                            "Reading {:?}, expected {:?}, but got {:?}",
+                            s,
+                            expected_err,
+                            e.kind()
+                        );
+                        return;
+                    }
+                };
+                if state == ChunkedState::Body || state == ChunkedState::End {
+                    panic!("Was Ok. Expected Err for {:?}", s);
+                }
+            }
+        }
+
+        assert_eq!(1, read("1\r\n").await);
+        assert_eq!(1, read("01\r\n").await);
+        assert_eq!(0, read("0\r\n").await);
+        assert_eq!(0, read("00\r\n").await);
+        assert_eq!(10, read("A\r\n").await);
+        assert_eq!(10, read("a\r\n").await);
+        assert_eq!(255, read("Ff\r\n").await);
+        assert_eq!(255, read("Ff   \r\n").await);
+        // Missing LF or CRLF
+        read_err("F\rF", InvalidInput).await;
+        read_err("F", UnexpectedEof).await;
+        // Invalid hex digit
+        read_err("X\r\n", InvalidInput).await;
+        read_err("1X\r\n", InvalidInput).await;
+        read_err("-\r\n", InvalidInput).await;
+        read_err("-1\r\n", InvalidInput).await;
+        // Acceptable (if not fully valid) extensions do not influence the size
+        assert_eq!(1, read("1;extension\r\n").await);
+        assert_eq!(10, read("a;ext name=value\r\n").await);
+        assert_eq!(1, read("1;extension;extension2\r\n").await);
+        assert_eq!(1, read("1;;;  ;\r\n").await);
+        assert_eq!(2, read("2; extension...\r\n").await);
+        assert_eq!(3, read("3   ; extension=123\r\n").await);
+        assert_eq!(3, read("3   ;\r\n").await);
+        assert_eq!(3, read("3   ;   \r\n").await);
+        // Invalid extensions cause an error
+        read_err("1 invalid extension\r\n", InvalidInput).await;
+        read_err("1 A\r\n", InvalidInput).await;
+        read_err("1;no CRLF", UnexpectedEof).await;
+        read_err("1;reject\nnewlines\r\n", InvalidData).await;
+        // Overflow
+        read_err("f0000000000000003\r\n", InvalidData).await;
+    }
+
+    #[tokio::test]
+    async fn test_read_sized_early_eof() {
+        let mut bytes = &b"foo bar"[..];
+        let mut decoder = Decoder::length(10);
+        assert_eq!(decoder.decode_fut(&mut bytes).await.unwrap().len(), 7);
+        let e = decoder.decode_fut(&mut bytes).await.unwrap_err();
+        assert_eq!(e.kind(), io::ErrorKind::UnexpectedEof);
+    }
+
+    #[tokio::test]
+    async fn test_read_chunked_early_eof() {
+        let mut bytes = &b"\
+            9\r\n\
+            foo bar\
+        "[..];
+        let mut decoder = Decoder::chunked();
+        assert_eq!(decoder.decode_fut(&mut bytes).await.unwrap().len(), 7);
+        let e = decoder.decode_fut(&mut bytes).await.unwrap_err();
+        assert_eq!(e.kind(), io::ErrorKind::UnexpectedEof);
+    }
+
+    #[tokio::test]
+    async fn test_read_chunked_single_read() {
+        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\n"[..];
+        let buf = Decoder::chunked()
+            .decode_fut(&mut mock_buf)
+            .await
+            .expect("decode");
+        assert_eq!(16, buf.len());
+        let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
+        assert_eq!("1234567890abcdef", &result);
+    }
+
+    #[tokio::test]
+    async fn test_read_chunked_trailer_with_missing_lf() {
+        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\nbad\r\r\n"[..];
+        let mut decoder = Decoder::chunked();
+        decoder.decode_fut(&mut mock_buf).await.expect("decode");
+        let e = decoder.decode_fut(&mut mock_buf).await.unwrap_err();
+        assert_eq!(e.kind(), io::ErrorKind::InvalidInput);
+    }
+
+    #[tokio::test]
+    async fn test_read_chunked_after_eof() {
+        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\n\r\n"[..];
+        let mut decoder = Decoder::chunked();
+
+        // normal read
+        let buf = decoder.decode_fut(&mut mock_buf).await.unwrap();
+        assert_eq!(16, buf.len());
+        let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
+        assert_eq!("1234567890abcdef", &result);
+
+        // eof read
+        let buf = decoder.decode_fut(&mut mock_buf).await.expect("decode");
+        assert_eq!(0, buf.len());
+
+        // ensure read after eof also returns eof
+        let buf = decoder.decode_fut(&mut mock_buf).await.expect("decode");
+        assert_eq!(0, buf.len());
+    }
+
+    // perform an async read using a custom buffer size and causing a blocking
+    // read at the specified byte
+    async fn read_async(mut decoder: Decoder, content: &[u8], block_at: usize) -> String {
+        let mut outs = Vec::new();
+
+        let mut ins = if block_at == 0 {
+            tokio_test::io::Builder::new()
+                .wait(Duration::from_millis(10))
+                .read(content)
+                .build()
+        } else {
+            tokio_test::io::Builder::new()
+                .read(&content[..block_at])
+                .wait(Duration::from_millis(10))
+                .read(&content[block_at..])
+                .build()
+        };
+
+        let mut ins = &mut ins as &mut (dyn AsyncRead + Unpin);
+
+        loop {
+            let buf = decoder
+                .decode_fut(&mut ins)
+                .await
+                .expect("unexpected decode error");
+            if buf.is_empty() {
+                break; // eof
+            }
+            outs.extend(buf.as_ref());
+        }
+
+        String::from_utf8(outs).expect("decode String")
+    }
+
+    // iterate over the different ways that this async read could go.
+    // tests blocking a read at each byte along the content - The shotgun approach
+    async fn all_async_cases(content: &str, expected: &str, decoder: Decoder) {
+        let content_len = content.len();
+        for block_at in 0..content_len {
+            let actual = read_async(decoder.clone(), content.as_bytes(), block_at).await;
+            assert_eq!(expected, &actual) //, "Failed async. Blocking at {}", block_at);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_read_length_async() {
+        let content = "foobar";
+        all_async_cases(content, content, Decoder::length(content.len() as u64)).await;
+    }
+
+    #[tokio::test]
+    async fn test_read_chunked_async() {
+        let content = "3\r\nfoo\r\n3\r\nbar\r\n0\r\n\r\n";
+        let expected = "foobar";
+        all_async_cases(content, expected, Decoder::chunked()).await;
+    }
+
+    #[tokio::test]
+    async fn test_read_eof_async() {
+        let content = "foobar";
+        all_async_cases(content, content, Decoder::eof()).await;
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_decode_chunked_1kb(b: &mut test::Bencher) {
+        let rt = new_runtime();
+
+        const LEN: usize = 1024;
+        let mut vec = Vec::new();
+        vec.extend(format!("{:x}\r\n", LEN).as_bytes());
+        vec.extend(&[0; LEN][..]);
+        vec.extend(b"\r\n");
+        let content = Bytes::from(vec);
+
+        b.bytes = LEN as u64;
+
+        b.iter(|| {
+            let mut decoder = Decoder::chunked();
+            rt.block_on(async {
+                let mut raw = content.clone();
+                let chunk = decoder.decode_fut(&mut raw).await.unwrap();
+                assert_eq!(chunk.len(), LEN);
+            });
+        });
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_decode_length_1kb(b: &mut test::Bencher) {
+        let rt = new_runtime();
+
+        const LEN: usize = 1024;
+        let content = Bytes::from(&[0; LEN][..]);
+        b.bytes = LEN as u64;
+
+        b.iter(|| {
+            let mut decoder = Decoder::length(LEN as u64);
+            rt.block_on(async {
+                let mut raw = content.clone();
+                let chunk = decoder.decode_fut(&mut raw).await.unwrap();
+                assert_eq!(chunk.len(), LEN);
+            });
+        });
+    }
+
+    #[cfg(feature = "nightly")]
+    fn new_runtime() -> tokio::runtime::Runtime {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("rt build")
+    }
+}
diff --git a/hyper/src/proto/h1/dispatch.rs b/hyper/src/proto/h1/dispatch.rs
new file mode 100644
index 0000000..677131b
--- /dev/null
+++ b/hyper/src/proto/h1/dispatch.rs
@@ -0,0 +1,750 @@
+use std::error::Error as StdError;
+
+use bytes::{Buf, Bytes};
+use http::Request;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tracing::{debug, trace};
+
+use super::{Http1Transaction, Wants};
+use crate::body::{Body, DecodedLength, HttpBody};
+use crate::common::{task, Future, Pin, Poll, Unpin};
+use crate::proto::{
+    BodyLength, Conn, Dispatched, MessageHead, RequestHead,
+};
+use crate::upgrade::OnUpgrade;
+
+pub(crate) struct Dispatcher<D, Bs: HttpBody, I, T> {
+    conn: Conn<I, Bs::Data, T>,
+    dispatch: D,
+    body_tx: Option<crate::body::Sender>,
+    body_rx: Pin<Box<Option<Bs>>>,
+    is_closing: bool,
+}
+
+pub(crate) trait Dispatch {
+    type PollItem;
+    type PollBody;
+    type PollError;
+    type RecvItem;
+    fn poll_msg(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<Result<(Self::PollItem, Self::PollBody), Self::PollError>>>;
+    fn recv_msg(&mut self, msg: crate::Result<(Self::RecvItem, Body)>) -> crate::Result<()>;
+    fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), ()>>;
+    fn should_poll(&self) -> bool;
+}
+
+cfg_server! {
+    use crate::service::HttpService;
+
+    pub(crate) struct Server<S: HttpService<B>, B> {
+        in_flight: Pin<Box<Option<S::Future>>>,
+        pub(crate) service: S,
+    }
+}
+
+cfg_client! {
+    pin_project_lite::pin_project! {
+        pub(crate) struct Client<B> {
+            callback: Option<crate::client::dispatch::Callback<Request<B>, http::Response<Body>>>,
+            #[pin]
+            rx: ClientRx<B>,
+            rx_closed: bool,
+        }
+    }
+
+    type ClientRx<B> = crate::client::dispatch::Receiver<Request<B>, http::Response<Body>>;
+}
+
+impl<D, Bs, I, T> Dispatcher<D, Bs, I, T>
+where
+    D: Dispatch<
+        PollItem = MessageHead<T::Outgoing>,
+        PollBody = Bs,
+        RecvItem = MessageHead<T::Incoming>,
+    > + Unpin,
+    D::PollError: Into<Box<dyn StdError + Send + Sync>>,
+    I: AsyncRead + AsyncWrite + Unpin,
+    T: Http1Transaction + Unpin,
+    Bs: HttpBody + 'static,
+    Bs::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    pub(crate) fn new(dispatch: D, conn: Conn<I, Bs::Data, T>) -> Self {
+        Dispatcher {
+            conn,
+            dispatch,
+            body_tx: None,
+            body_rx: Box::pin(None),
+            is_closing: false,
+        }
+    }
+
+    #[cfg(feature = "server")]
+    pub(crate) fn disable_keep_alive(&mut self) {
+        self.conn.disable_keep_alive();
+        if self.conn.is_write_closed() {
+            self.close();
+        }
+    }
+
+    pub(crate) fn into_inner(self) -> (I, Bytes, D) {
+        let (io, buf) = self.conn.into_inner();
+        (io, buf, self.dispatch)
+    }
+
+    /// Run this dispatcher until HTTP says this connection is done,
+    /// but don't call `AsyncWrite::shutdown` on the underlying IO.
+    ///
+    /// This is useful for old-style HTTP upgrades, but ignores
+    /// newer-style upgrade API.
+    pub(crate) fn poll_without_shutdown(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<crate::Result<()>>
+    where
+        Self: Unpin,
+    {
+        Pin::new(self).poll_catch(cx, false).map_ok(|ds| {
+            if let Dispatched::Upgrade(pending) = ds {
+                pending.manual();
+            }
+        })
+    }
+
+    fn poll_catch(
+        &mut self,
+        cx: &mut task::Context<'_>,
+        should_shutdown: bool,
+    ) -> Poll<crate::Result<Dispatched>> {
+        Poll::Ready(ready!(self.poll_inner(cx, should_shutdown)).or_else(|e| {
+            // An error means we're shutting down either way.
+            // We just try to give the error to the user,
+            // and close the connection with an Ok. If we
+            // cannot give it to the user, then return the Err.
+            self.dispatch.recv_msg(Err(e))?;
+            Ok(Dispatched::Shutdown)
+        }))
+    }
+
+    fn poll_inner(
+        &mut self,
+        cx: &mut task::Context<'_>,
+        should_shutdown: bool,
+    ) -> Poll<crate::Result<Dispatched>> {
+        T::update_date();
+
+        ready!(self.poll_loop(cx))?;
+
+        if self.is_done() {
+            if let Some(pending) = self.conn.pending_upgrade() {
+                self.conn.take_error()?;
+                return Poll::Ready(Ok(Dispatched::Upgrade(pending)));
+            } else if should_shutdown {
+                ready!(self.conn.poll_shutdown(cx)).map_err(crate::Error::new_shutdown)?;
+            }
+            self.conn.take_error()?;
+            Poll::Ready(Ok(Dispatched::Shutdown))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn poll_loop(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        // Limit the looping on this connection, in case it is ready far too
+        // often, so that other futures don't starve.
+        //
+        // 16 was chosen arbitrarily, as that is number of pipelined requests
+        // benchmarks often use. Perhaps it should be a config option instead.
+        for _ in 0..16 {
+            let _ = self.poll_read(cx)?;
+            let _ = self.poll_write(cx)?;
+            let _ = self.poll_flush(cx)?;
+
+            // This could happen if reading paused before blocking on IO,
+            // such as getting to the end of a framed message, but then
+            // writing/flushing set the state back to Init. In that case,
+            // if the read buffer still had bytes, we'd want to try poll_read
+            // again, or else we wouldn't ever be woken up again.
+            //
+            // Using this instead of task::current() and notify() inside
+            // the Conn is noticeably faster in pipelined benchmarks.
+            if !self.conn.wants_read_again() {
+                //break;
+                return Poll::Ready(Ok(()));
+            }
+        }
+
+        trace!("poll_loop yielding (self = {:p})", self);
+
+        task::yield_now(cx).map(|never| match never {})
+    }
+
+    fn poll_read(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        loop {
+            if self.is_closing {
+                return Poll::Ready(Ok(()));
+            } else if self.conn.can_read_head() {
+                ready!(self.poll_read_head(cx))?;
+            } else if let Some(mut body) = self.body_tx.take() {
+                if self.conn.can_read_body() {
+                    match body.poll_ready(cx) {
+                        Poll::Ready(Ok(())) => (),
+                        Poll::Pending => {
+                            self.body_tx = Some(body);
+                            return Poll::Pending;
+                        }
+                        Poll::Ready(Err(_canceled)) => {
+                            // user doesn't care about the body
+                            // so we should stop reading
+                            trace!("body receiver dropped before eof, draining or closing");
+                            self.conn.poll_drain_or_close_read(cx);
+                            continue;
+                        }
+                    }
+                    match self.conn.poll_read_body(cx) {
+                        Poll::Ready(Some(Ok(chunk))) => match body.try_send_data(chunk) {
+                            Ok(()) => {
+                                self.body_tx = Some(body);
+                            }
+                            Err(_canceled) => {
+                                if self.conn.can_read_body() {
+                                    trace!("body receiver dropped before eof, closing");
+                                    self.conn.close_read();
+                                }
+                            }
+                        },
+                        Poll::Ready(None) => {
+                            // just drop, the body will close automatically
+                        }
+                        Poll::Pending => {
+                            self.body_tx = Some(body);
+                            return Poll::Pending;
+                        }
+                        Poll::Ready(Some(Err(e))) => {
+                            body.send_error(crate::Error::new_body(e));
+                        }
+                    }
+                } else {
+                    // just drop, the body will close automatically
+                }
+            } else {
+                return self.conn.poll_read_keep_alive(cx);
+            }
+        }
+    }
+
+    fn poll_read_head(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        // can dispatch receive, or does it still care about, an incoming message?
+        match ready!(self.dispatch.poll_ready(cx)) {
+            Ok(()) => (),
+            Err(()) => {
+                trace!("dispatch no longer receiving messages");
+                self.close();
+                return Poll::Ready(Ok(()));
+            }
+        }
+        // dispatch is ready for a message, try to read one
+        match ready!(self.conn.poll_read_head(cx)) {
+            Some(Ok((mut head, body_len, wants))) => {
+                let body = match body_len {
+                    DecodedLength::ZERO => Body::empty(),
+                    other => {
+                        let (tx, rx) = Body::new_channel(other, wants.contains(Wants::EXPECT));
+                        self.body_tx = Some(tx);
+                        rx
+                    }
+                };
+                if wants.contains(Wants::UPGRADE) {
+                    let upgrade = self.conn.on_upgrade();
+                    debug_assert!(!upgrade.is_none(), "empty upgrade");
+                    debug_assert!(head.extensions.get::<OnUpgrade>().is_none(), "OnUpgrade already set");
+                    head.extensions.insert(upgrade);
+                }
+                self.dispatch.recv_msg(Ok((head, body)))?;
+                Poll::Ready(Ok(()))
+            }
+            Some(Err(err)) => {
+                debug!("read_head error: {}", err);
+                self.dispatch.recv_msg(Err(err))?;
+                // if here, the dispatcher gave the user the error
+                // somewhere else. we still need to shutdown, but
+                // not as a second error.
+                self.close();
+                Poll::Ready(Ok(()))
+            }
+            None => {
+                // read eof, the write side will have been closed too unless
+                // allow_read_close was set to true, in which case just do
+                // nothing...
+                debug_assert!(self.conn.is_read_closed());
+                if self.conn.is_write_closed() {
+                    self.close();
+                }
+                Poll::Ready(Ok(()))
+            }
+        }
+    }
+
+    fn poll_write(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        loop {
+            if self.is_closing {
+                return Poll::Ready(Ok(()));
+            } else if self.body_rx.is_none()
+                && self.conn.can_write_head()
+                && self.dispatch.should_poll()
+            {
+                if let Some(msg) = ready!(Pin::new(&mut self.dispatch).poll_msg(cx)) {
+                    let (head, mut body) = msg.map_err(crate::Error::new_user_service)?;
+
+                    // Check if the body knows its full data immediately.
+                    //
+                    // If so, we can skip a bit of bookkeeping that streaming
+                    // bodies need to do.
+                    if let Some(full) = crate::body::take_full_data(&mut body) {
+                        self.conn.write_full_msg(head, full);
+                        return Poll::Ready(Ok(()));
+                    }
+
+                    let body_type = if body.is_end_stream() {
+                        self.body_rx.set(None);
+                        None
+                    } else {
+                        let btype = body
+                            .size_hint()
+                            .exact()
+                            .map(BodyLength::Known)
+                            .or_else(|| Some(BodyLength::Unknown));
+                        self.body_rx.set(Some(body));
+                        btype
+                    };
+                    self.conn.write_head(head, body_type);
+                } else {
+                    self.close();
+                    return Poll::Ready(Ok(()));
+                }
+            } else if !self.conn.can_buffer_body() {
+                ready!(self.poll_flush(cx))?;
+            } else {
+                // A new scope is needed :(
+                if let (Some(mut body), clear_body) =
+                    OptGuard::new(self.body_rx.as_mut()).guard_mut()
+                {
+                    debug_assert!(!*clear_body, "opt guard defaults to keeping body");
+                    if !self.conn.can_write_body() {
+                        trace!(
+                            "no more write body allowed, user body is_end_stream = {}",
+                            body.is_end_stream(),
+                        );
+                        *clear_body = true;
+                        continue;
+                    }
+
+                    let item = ready!(body.as_mut().poll_data(cx));
+                    if let Some(item) = item {
+                        let chunk = item.map_err(|e| {
+                            *clear_body = true;
+                            crate::Error::new_user_body(e)
+                        })?;
+                        let eos = body.is_end_stream();
+                        if eos {
+                            *clear_body = true;
+                            if chunk.remaining() == 0 {
+                                trace!("discarding empty chunk");
+                                self.conn.end_body()?;
+                            } else {
+                                self.conn.write_body_and_end(chunk);
+                            }
+                        } else {
+                            if chunk.remaining() == 0 {
+                                trace!("discarding empty chunk");
+                                continue;
+                            }
+                            self.conn.write_body(chunk);
+                        }
+                    } else {
+                        *clear_body = true;
+                        self.conn.end_body()?;
+                    }
+                } else {
+                    return Poll::Pending;
+                }
+            }
+        }
+    }
+
+    fn poll_flush(&mut self, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        self.conn.poll_flush(cx).map_err(|err| {
+            debug!("error writing: {}", err);
+            crate::Error::new_body_write(err)
+        })
+    }
+
+    fn close(&mut self) {
+        self.is_closing = true;
+        self.conn.close_read();
+        self.conn.close_write();
+    }
+
+    fn is_done(&self) -> bool {
+        if self.is_closing {
+            return true;
+        }
+
+        let read_done = self.conn.is_read_closed();
+
+        if !T::should_read_first() && read_done {
+            // a client that cannot read may was well be done.
+            true
+        } else {
+            let write_done = self.conn.is_write_closed()
+                || (!self.dispatch.should_poll() && self.body_rx.is_none());
+            read_done && write_done
+        }
+    }
+}
+
+impl<D, Bs, I, T> Future for Dispatcher<D, Bs, I, T>
+where
+    D: Dispatch<
+        PollItem = MessageHead<T::Outgoing>,
+        PollBody = Bs,
+        RecvItem = MessageHead<T::Incoming>,
+    > + Unpin,
+    D::PollError: Into<Box<dyn StdError + Send + Sync>>,
+    I: AsyncRead + AsyncWrite + Unpin,
+    T: Http1Transaction + Unpin,
+    Bs: HttpBody + 'static,
+    Bs::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Output = crate::Result<Dispatched>;
+
+    #[inline]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        self.poll_catch(cx, true)
+    }
+}
+
+// ===== impl OptGuard =====
+
+/// A drop guard to allow a mutable borrow of an Option while being able to
+/// set whether the `Option` should be cleared on drop.
+struct OptGuard<'a, T>(Pin<&'a mut Option<T>>, bool);
+
+impl<'a, T> OptGuard<'a, T> {
+    fn new(pin: Pin<&'a mut Option<T>>) -> Self {
+        OptGuard(pin, false)
+    }
+
+    fn guard_mut(&mut self) -> (Option<Pin<&mut T>>, &mut bool) {
+        (self.0.as_mut().as_pin_mut(), &mut self.1)
+    }
+}
+
+impl<'a, T> Drop for OptGuard<'a, T> {
+    fn drop(&mut self) {
+        if self.1 {
+            self.0.set(None);
+        }
+    }
+}
+
+// ===== impl Server =====
+
+cfg_server! {
+    impl<S, B> Server<S, B>
+    where
+        S: HttpService<B>,
+    {
+        pub(crate) fn new(service: S) -> Server<S, B> {
+            Server {
+                in_flight: Box::pin(None),
+                service,
+            }
+        }
+
+        pub(crate) fn into_service(self) -> S {
+            self.service
+        }
+    }
+
+    // Service is never pinned
+    impl<S: HttpService<B>, B> Unpin for Server<S, B> {}
+
+    impl<S, Bs> Dispatch for Server<S, Body>
+    where
+        S: HttpService<Body, ResBody = Bs>,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        Bs: HttpBody,
+    {
+        type PollItem = MessageHead<http::StatusCode>;
+        type PollBody = Bs;
+        type PollError = S::Error;
+        type RecvItem = RequestHead;
+
+        fn poll_msg(
+            mut self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+        ) -> Poll<Option<Result<(Self::PollItem, Self::PollBody), Self::PollError>>> {
+            let mut this = self.as_mut();
+            let ret = if let Some(ref mut fut) = this.in_flight.as_mut().as_pin_mut() {
+                let resp = ready!(fut.as_mut().poll(cx)?);
+                let (parts, body) = resp.into_parts();
+                let head = MessageHead {
+                    version: parts.version,
+                    subject: parts.status,
+                    headers: parts.headers,
+                    extensions: parts.extensions,
+                };
+                Poll::Ready(Some(Ok((head, body))))
+            } else {
+                unreachable!("poll_msg shouldn't be called if no inflight");
+            };
+
+            // Since in_flight finished, remove it
+            this.in_flight.set(None);
+            ret
+        }
+
+        fn recv_msg(&mut self, msg: crate::Result<(Self::RecvItem, Body)>) -> crate::Result<()> {
+            let (msg, body) = msg?;
+            let mut req = Request::new(body);
+            *req.method_mut() = msg.subject.0;
+            *req.uri_mut() = msg.subject.1;
+            *req.headers_mut() = msg.headers;
+            *req.version_mut() = msg.version;
+            *req.extensions_mut() = msg.extensions;
+            let fut = self.service.call(req);
+            self.in_flight.set(Some(fut));
+            Ok(())
+        }
+
+        fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), ()>> {
+            if self.in_flight.is_some() {
+                Poll::Pending
+            } else {
+                self.service.poll_ready(cx).map_err(|_e| {
+                    // FIXME: return error value.
+                    trace!("service closed");
+                })
+            }
+        }
+
+        fn should_poll(&self) -> bool {
+            self.in_flight.is_some()
+        }
+    }
+}
+
+// ===== impl Client =====
+
+cfg_client! {
+    impl<B> Client<B> {
+        pub(crate) fn new(rx: ClientRx<B>) -> Client<B> {
+            Client {
+                callback: None,
+                rx,
+                rx_closed: false,
+            }
+        }
+    }
+
+    impl<B> Dispatch for Client<B>
+    where
+        B: HttpBody,
+    {
+        type PollItem = RequestHead;
+        type PollBody = B;
+        type PollError = crate::common::Never;
+        type RecvItem = crate::proto::ResponseHead;
+
+        fn poll_msg(
+            mut self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+        ) -> Poll<Option<Result<(Self::PollItem, Self::PollBody), crate::common::Never>>> {
+            let mut this = self.as_mut();
+            debug_assert!(!this.rx_closed);
+            match this.rx.poll_recv(cx) {
+                Poll::Ready(Some((req, mut cb))) => {
+                    // check that future hasn't been canceled already
+                    match cb.poll_canceled(cx) {
+                        Poll::Ready(()) => {
+                            trace!("request canceled");
+                            Poll::Ready(None)
+                        }
+                        Poll::Pending => {
+                            let (parts, body) = req.into_parts();
+                            let head = RequestHead {
+                                version: parts.version,
+                                subject: crate::proto::RequestLine(parts.method, parts.uri),
+                                headers: parts.headers,
+                                extensions: parts.extensions,
+                            };
+                            this.callback = Some(cb);
+                            Poll::Ready(Some(Ok((head, body))))
+                        }
+                    }
+                }
+                Poll::Ready(None) => {
+                    // user has dropped sender handle
+                    trace!("client tx closed");
+                    this.rx_closed = true;
+                    Poll::Ready(None)
+                }
+                Poll::Pending => Poll::Pending,
+            }
+        }
+
+        fn recv_msg(&mut self, msg: crate::Result<(Self::RecvItem, Body)>) -> crate::Result<()> {
+            match msg {
+                Ok((msg, body)) => {
+                    if let Some(cb) = self.callback.take() {
+                        let res = msg.into_response(body);
+                        cb.send(Ok(res));
+                        Ok(())
+                    } else {
+                        // Getting here is likely a bug! An error should have happened
+                        // in Conn::require_empty_read() before ever parsing a
+                        // full message!
+                        Err(crate::Error::new_unexpected_message())
+                    }
+                }
+                Err(err) => {
+                    if let Some(cb) = self.callback.take() {
+                        cb.send(Err((err, None)));
+                        Ok(())
+                    } else if !self.rx_closed {
+                        self.rx.close();
+                        if let Some((req, cb)) = self.rx.try_recv() {
+                            trace!("canceling queued request with connection error: {}", err);
+                            // in this case, the message was never even started, so it's safe to tell
+                            // the user that the request was completely canceled
+                            cb.send(Err((crate::Error::new_canceled().with(err), Some(req))));
+                            Ok(())
+                        } else {
+                            Err(err)
+                        }
+                    } else {
+                        Err(err)
+                    }
+                }
+            }
+        }
+
+        fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), ()>> {
+            match self.callback {
+                Some(ref mut cb) => match cb.poll_canceled(cx) {
+                    Poll::Ready(()) => {
+                        trace!("callback receiver has dropped");
+                        Poll::Ready(Err(()))
+                    }
+                    Poll::Pending => Poll::Ready(Ok(())),
+                },
+                None => Poll::Ready(Err(())),
+            }
+        }
+
+        fn should_poll(&self) -> bool {
+            self.callback.is_none()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::proto::h1::ClientTransaction;
+    use std::time::Duration;
+
+    #[test]
+    fn client_read_bytes_before_writing_request() {
+        let _ = pretty_env_logger::try_init();
+
+        tokio_test::task::spawn(()).enter(|cx, _| {
+            let (io, mut handle) = tokio_test::io::Builder::new().build_with_handle();
+
+            // Block at 0 for now, but we will release this response before
+            // the request is ready to write later...
+            let (mut tx, rx) = crate::client::dispatch::channel();
+            let conn = Conn::<_, bytes::Bytes, ClientTransaction>::new(io);
+            let mut dispatcher = Dispatcher::new(Client::new(rx), conn);
+
+            // First poll is needed to allow tx to send...
+            assert!(Pin::new(&mut dispatcher).poll(cx).is_pending());
+
+            // Unblock our IO, which has a response before we've sent request!
+            //
+            handle.read(b"HTTP/1.1 200 OK\r\n\r\n");
+
+            let mut res_rx = tx
+                .try_send(crate::Request::new(crate::Body::empty()))
+                .unwrap();
+
+            tokio_test::assert_ready_ok!(Pin::new(&mut dispatcher).poll(cx));
+            let err = tokio_test::assert_ready_ok!(Pin::new(&mut res_rx).poll(cx))
+                .expect_err("callback should send error");
+
+            match (err.0.kind(), err.1) {
+                (&crate::error::Kind::Canceled, Some(_)) => (),
+                other => panic!("expected Canceled, got {:?}", other),
+            }
+        });
+    }
+
+    #[tokio::test]
+    async fn client_flushing_is_not_ready_for_next_request() {
+        let _ = pretty_env_logger::try_init();
+
+        let (io, _handle) = tokio_test::io::Builder::new()
+            .write(b"POST / HTTP/1.1\r\ncontent-length: 4\r\n\r\n")
+            .read(b"HTTP/1.1 200 OK\r\ncontent-length: 0\r\n\r\n")
+            .wait(std::time::Duration::from_secs(2))
+            .build_with_handle();
+
+        let (mut tx, rx) = crate::client::dispatch::channel();
+        let mut conn = Conn::<_, bytes::Bytes, ClientTransaction>::new(io);
+        conn.set_write_strategy_queue();
+
+        let dispatcher = Dispatcher::new(Client::new(rx), conn);
+        let _dispatcher = tokio::spawn(async move { dispatcher.await });
+
+        let req = crate::Request::builder()
+            .method("POST")
+            .body(crate::Body::from("reee"))
+            .unwrap();
+
+        let res = tx.try_send(req).unwrap().await.expect("response");
+        drop(res);
+
+        assert!(!tx.is_ready());
+    }
+
+    #[tokio::test]
+    async fn body_empty_chunks_ignored() {
+        let _ = pretty_env_logger::try_init();
+
+        let io = tokio_test::io::Builder::new()
+            // no reading or writing, just be blocked for the test...
+            .wait(Duration::from_secs(5))
+            .build();
+
+        let (mut tx, rx) = crate::client::dispatch::channel();
+        let conn = Conn::<_, bytes::Bytes, ClientTransaction>::new(io);
+        let mut dispatcher = tokio_test::task::spawn(Dispatcher::new(Client::new(rx), conn));
+
+        // First poll is needed to allow tx to send...
+        assert!(dispatcher.poll().is_pending());
+
+        let body = {
+            let (mut tx, body) = crate::Body::channel();
+            tx.try_send_data("".into()).unwrap();
+            body
+        };
+
+        let _res_rx = tx.try_send(crate::Request::new(body)).unwrap();
+
+        // Ensure conn.write_body wasn't called with the empty chunk.
+        // If it is, it will trigger an assertion.
+        assert!(dispatcher.poll().is_pending());
+    }
+}
diff --git a/hyper/src/proto/h1/encode.rs b/hyper/src/proto/h1/encode.rs
new file mode 100644
index 0000000..f0aa261
--- /dev/null
+++ b/hyper/src/proto/h1/encode.rs
@@ -0,0 +1,439 @@
+use std::fmt;
+use std::io::IoSlice;
+
+use bytes::buf::{Chain, Take};
+use bytes::Buf;
+use tracing::trace;
+
+use super::io::WriteBuf;
+
+type StaticBuf = &'static [u8];
+
+/// Encoders to handle different Transfer-Encodings.
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Encoder {
+    kind: Kind,
+    is_last: bool,
+}
+
+#[derive(Debug)]
+pub(crate) struct EncodedBuf<B> {
+    kind: BufKind<B>,
+}
+
+#[derive(Debug)]
+pub(crate) struct NotEof(u64);
+
+#[derive(Debug, PartialEq, Clone)]
+enum Kind {
+    /// An Encoder for when Transfer-Encoding includes `chunked`.
+    Chunked,
+    /// An Encoder for when Content-Length is set.
+    ///
+    /// Enforces that the body is not longer than the Content-Length header.
+    Length(u64),
+    /// An Encoder for when neither Content-Length nor Chunked encoding is set.
+    ///
+    /// This is mostly only used with HTTP/1.0 with a length. This kind requires
+    /// the connection to be closed when the body is finished.
+    #[cfg(feature = "server")]
+    CloseDelimited,
+}
+
+#[derive(Debug)]
+enum BufKind<B> {
+    Exact(B),
+    Limited(Take<B>),
+    Chunked(Chain<Chain<ChunkSize, B>, StaticBuf>),
+    ChunkedEnd(StaticBuf),
+}
+
+impl Encoder {
+    fn new(kind: Kind) -> Encoder {
+        Encoder {
+            kind,
+            is_last: false,
+        }
+    }
+    pub(crate) fn chunked() -> Encoder {
+        Encoder::new(Kind::Chunked)
+    }
+
+    pub(crate) fn length(len: u64) -> Encoder {
+        Encoder::new(Kind::Length(len))
+    }
+
+    #[cfg(feature = "server")]
+    pub(crate) fn close_delimited() -> Encoder {
+        Encoder::new(Kind::CloseDelimited)
+    }
+
+    pub(crate) fn is_eof(&self) -> bool {
+        matches!(self.kind, Kind::Length(0))
+    }
+
+    #[cfg(feature = "server")]
+    pub(crate) fn set_last(mut self, is_last: bool) -> Self {
+        self.is_last = is_last;
+        self
+    }
+
+    pub(crate) fn is_last(&self) -> bool {
+        self.is_last
+    }
+
+    pub(crate) fn is_close_delimited(&self) -> bool {
+        match self.kind {
+            #[cfg(feature = "server")]
+            Kind::CloseDelimited => true,
+            _ => false,
+        }
+    }
+
+    pub(crate) fn end<B>(&self) -> Result<Option<EncodedBuf<B>>, NotEof> {
+        match self.kind {
+            Kind::Length(0) => Ok(None),
+            Kind::Chunked => Ok(Some(EncodedBuf {
+                kind: BufKind::ChunkedEnd(b"0\r\n\r\n"),
+            })),
+            #[cfg(feature = "server")]
+            Kind::CloseDelimited => Ok(None),
+            Kind::Length(n) => Err(NotEof(n)),
+        }
+    }
+
+    pub(crate) fn encode<B>(&mut self, msg: B) -> EncodedBuf<B>
+    where
+        B: Buf,
+    {
+        let len = msg.remaining();
+        debug_assert!(len > 0, "encode() called with empty buf");
+
+        let kind = match self.kind {
+            Kind::Chunked => {
+                trace!("encoding chunked {}B", len);
+                let buf = ChunkSize::new(len)
+                    .chain(msg)
+                    .chain(b"\r\n" as &'static [u8]);
+                BufKind::Chunked(buf)
+            }
+            Kind::Length(ref mut remaining) => {
+                trace!("sized write, len = {}", len);
+                if len as u64 > *remaining {
+                    let limit = *remaining as usize;
+                    *remaining = 0;
+                    BufKind::Limited(msg.take(limit))
+                } else {
+                    *remaining -= len as u64;
+                    BufKind::Exact(msg)
+                }
+            }
+            #[cfg(feature = "server")]
+            Kind::CloseDelimited => {
+                trace!("close delimited write {}B", len);
+                BufKind::Exact(msg)
+            }
+        };
+        EncodedBuf { kind }
+    }
+
+    pub(super) fn encode_and_end<B>(&self, msg: B, dst: &mut WriteBuf<EncodedBuf<B>>) -> bool
+    where
+        B: Buf,
+    {
+        let len = msg.remaining();
+        debug_assert!(len > 0, "encode() called with empty buf");
+
+        match self.kind {
+            Kind::Chunked => {
+                trace!("encoding chunked {}B", len);
+                let buf = ChunkSize::new(len)
+                    .chain(msg)
+                    .chain(b"\r\n0\r\n\r\n" as &'static [u8]);
+                dst.buffer(buf);
+                !self.is_last
+            }
+            Kind::Length(remaining) => {
+                use std::cmp::Ordering;
+
+                trace!("sized write, len = {}", len);
+                match (len as u64).cmp(&remaining) {
+                    Ordering::Equal => {
+                        dst.buffer(msg);
+                        !self.is_last
+                    }
+                    Ordering::Greater => {
+                        dst.buffer(msg.take(remaining as usize));
+                        !self.is_last
+                    }
+                    Ordering::Less => {
+                        dst.buffer(msg);
+                        false
+                    }
+                }
+            }
+            #[cfg(feature = "server")]
+            Kind::CloseDelimited => {
+                trace!("close delimited write {}B", len);
+                dst.buffer(msg);
+                false
+            }
+        }
+    }
+
+    /// Encodes the full body, without verifying the remaining length matches.
+    ///
+    /// This is used in conjunction with HttpBody::__hyper_full_data(), which
+    /// means we can trust that the buf has the correct size (the buf itself
+    /// was checked to make the headers).
+    pub(super) fn danger_full_buf<B>(self, msg: B, dst: &mut WriteBuf<EncodedBuf<B>>)
+    where
+        B: Buf,
+    {
+        debug_assert!(msg.remaining() > 0, "encode() called with empty buf");
+        debug_assert!(
+            match self.kind {
+                Kind::Length(len) => len == msg.remaining() as u64,
+                _ => true,
+            },
+            "danger_full_buf length mismatches"
+        );
+
+        match self.kind {
+            Kind::Chunked => {
+                let len = msg.remaining();
+                trace!("encoding chunked {}B", len);
+                let buf = ChunkSize::new(len)
+                    .chain(msg)
+                    .chain(b"\r\n0\r\n\r\n" as &'static [u8]);
+                dst.buffer(buf);
+            }
+            _ => {
+                dst.buffer(msg);
+            }
+        }
+    }
+}
+
+impl<B> Buf for EncodedBuf<B>
+where
+    B: Buf,
+{
+    #[inline]
+    fn remaining(&self) -> usize {
+        match self.kind {
+            BufKind::Exact(ref b) => b.remaining(),
+            BufKind::Limited(ref b) => b.remaining(),
+            BufKind::Chunked(ref b) => b.remaining(),
+            BufKind::ChunkedEnd(ref b) => b.remaining(),
+        }
+    }
+
+    #[inline]
+    fn chunk(&self) -> &[u8] {
+        match self.kind {
+            BufKind::Exact(ref b) => b.chunk(),
+            BufKind::Limited(ref b) => b.chunk(),
+            BufKind::Chunked(ref b) => b.chunk(),
+            BufKind::ChunkedEnd(ref b) => b.chunk(),
+        }
+    }
+
+    #[inline]
+    fn advance(&mut self, cnt: usize) {
+        match self.kind {
+            BufKind::Exact(ref mut b) => b.advance(cnt),
+            BufKind::Limited(ref mut b) => b.advance(cnt),
+            BufKind::Chunked(ref mut b) => b.advance(cnt),
+            BufKind::ChunkedEnd(ref mut b) => b.advance(cnt),
+        }
+    }
+
+    #[inline]
+    fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
+        match self.kind {
+            BufKind::Exact(ref b) => b.chunks_vectored(dst),
+            BufKind::Limited(ref b) => b.chunks_vectored(dst),
+            BufKind::Chunked(ref b) => b.chunks_vectored(dst),
+            BufKind::ChunkedEnd(ref b) => b.chunks_vectored(dst),
+        }
+    }
+}
+
+#[cfg(target_pointer_width = "32")]
+const USIZE_BYTES: usize = 4;
+
+#[cfg(target_pointer_width = "64")]
+const USIZE_BYTES: usize = 8;
+
+// each byte will become 2 hex
+const CHUNK_SIZE_MAX_BYTES: usize = USIZE_BYTES * 2;
+
+#[derive(Clone, Copy)]
+struct ChunkSize {
+    bytes: [u8; CHUNK_SIZE_MAX_BYTES + 2],
+    pos: u8,
+    len: u8,
+}
+
+impl ChunkSize {
+    fn new(len: usize) -> ChunkSize {
+        use std::fmt::Write;
+        let mut size = ChunkSize {
+            bytes: [0; CHUNK_SIZE_MAX_BYTES + 2],
+            pos: 0,
+            len: 0,
+        };
+        write!(&mut size, "{:X}\r\n", len).expect("CHUNK_SIZE_MAX_BYTES should fit any usize");
+        size
+    }
+}
+
+impl Buf for ChunkSize {
+    #[inline]
+    fn remaining(&self) -> usize {
+        (self.len - self.pos).into()
+    }
+
+    #[inline]
+    fn chunk(&self) -> &[u8] {
+        &self.bytes[self.pos.into()..self.len.into()]
+    }
+
+    #[inline]
+    fn advance(&mut self, cnt: usize) {
+        assert!(cnt <= self.remaining());
+        self.pos += cnt as u8; // just asserted cnt fits in u8
+    }
+}
+
+impl fmt::Debug for ChunkSize {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ChunkSize")
+            .field("bytes", &&self.bytes[..self.len.into()])
+            .field("pos", &self.pos)
+            .finish()
+    }
+}
+
+impl fmt::Write for ChunkSize {
+    fn write_str(&mut self, num: &str) -> fmt::Result {
+        use std::io::Write;
+        (&mut self.bytes[self.len.into()..])
+            .write_all(num.as_bytes())
+            .expect("&mut [u8].write() cannot error");
+        self.len += num.len() as u8; // safe because bytes is never bigger than 256
+        Ok(())
+    }
+}
+
+impl<B: Buf> From<B> for EncodedBuf<B> {
+    fn from(buf: B) -> Self {
+        EncodedBuf {
+            kind: BufKind::Exact(buf),
+        }
+    }
+}
+
+impl<B: Buf> From<Take<B>> for EncodedBuf<B> {
+    fn from(buf: Take<B>) -> Self {
+        EncodedBuf {
+            kind: BufKind::Limited(buf),
+        }
+    }
+}
+
+impl<B: Buf> From<Chain<Chain<ChunkSize, B>, StaticBuf>> for EncodedBuf<B> {
+    fn from(buf: Chain<Chain<ChunkSize, B>, StaticBuf>) -> Self {
+        EncodedBuf {
+            kind: BufKind::Chunked(buf),
+        }
+    }
+}
+
+impl fmt::Display for NotEof {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "early end, expected {} more bytes", self.0)
+    }
+}
+
+impl std::error::Error for NotEof {}
+
+#[cfg(test)]
+mod tests {
+    use bytes::BufMut;
+
+    use super::super::io::Cursor;
+    use super::Encoder;
+
+    #[test]
+    fn chunked() {
+        let mut encoder = Encoder::chunked();
+        let mut dst = Vec::new();
+
+        let msg1 = b"foo bar".as_ref();
+        let buf1 = encoder.encode(msg1);
+        dst.put(buf1);
+        assert_eq!(dst, b"7\r\nfoo bar\r\n");
+
+        let msg2 = b"baz quux herp".as_ref();
+        let buf2 = encoder.encode(msg2);
+        dst.put(buf2);
+
+        assert_eq!(dst, b"7\r\nfoo bar\r\nD\r\nbaz quux herp\r\n");
+
+        let end = encoder.end::<Cursor<Vec<u8>>>().unwrap().unwrap();
+        dst.put(end);
+
+        assert_eq!(
+            dst,
+            b"7\r\nfoo bar\r\nD\r\nbaz quux herp\r\n0\r\n\r\n".as_ref()
+        );
+    }
+
+    #[test]
+    fn length() {
+        let max_len = 8;
+        let mut encoder = Encoder::length(max_len as u64);
+        let mut dst = Vec::new();
+
+        let msg1 = b"foo bar".as_ref();
+        let buf1 = encoder.encode(msg1);
+        dst.put(buf1);
+
+        assert_eq!(dst, b"foo bar");
+        assert!(!encoder.is_eof());
+        encoder.end::<()>().unwrap_err();
+
+        let msg2 = b"baz".as_ref();
+        let buf2 = encoder.encode(msg2);
+        dst.put(buf2);
+
+        assert_eq!(dst.len(), max_len);
+        assert_eq!(dst, b"foo barb");
+        assert!(encoder.is_eof());
+        assert!(encoder.end::<()>().unwrap().is_none());
+    }
+
+    #[test]
+    fn eof() {
+        let mut encoder = Encoder::close_delimited();
+        let mut dst = Vec::new();
+
+        let msg1 = b"foo bar".as_ref();
+        let buf1 = encoder.encode(msg1);
+        dst.put(buf1);
+
+        assert_eq!(dst, b"foo bar");
+        assert!(!encoder.is_eof());
+        encoder.end::<()>().unwrap();
+
+        let msg2 = b"baz".as_ref();
+        let buf2 = encoder.encode(msg2);
+        dst.put(buf2);
+
+        assert_eq!(dst, b"foo barbaz");
+        assert!(!encoder.is_eof());
+        encoder.end::<()>().unwrap();
+    }
+}
diff --git a/hyper/src/proto/h1/io.rs b/hyper/src/proto/h1/io.rs
new file mode 100644
index 0000000..1d251e2
--- /dev/null
+++ b/hyper/src/proto/h1/io.rs
@@ -0,0 +1,1002 @@
+use std::cmp;
+use std::fmt;
+#[cfg(all(feature = "server", feature = "runtime"))]
+use std::future::Future;
+use std::io::{self, IoSlice};
+use std::marker::Unpin;
+use std::mem::MaybeUninit;
+#[cfg(all(feature = "server", feature = "runtime"))]
+use std::time::Duration;
+
+use bytes::{Buf, BufMut, Bytes, BytesMut};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+#[cfg(all(feature = "server", feature = "runtime"))]
+use tokio::time::Instant;
+use tracing::{debug, trace};
+
+use super::{Http1Transaction, ParseContext, ParsedMessage};
+use crate::common::buf::BufList;
+use crate::common::{task, Pin, Poll};
+
+/// The initial buffer size allocated before trying to read from IO.
+pub(crate) const INIT_BUFFER_SIZE: usize = 8192;
+
+/// The minimum value that can be set to max buffer size.
+pub(crate) const MINIMUM_MAX_BUFFER_SIZE: usize = INIT_BUFFER_SIZE;
+
+/// The default maximum read buffer size. If the buffer gets this big and
+/// a message is still not complete, a `TooLarge` error is triggered.
+// Note: if this changes, update server::conn::Http::max_buf_size docs.
+pub(crate) const DEFAULT_MAX_BUFFER_SIZE: usize = 8192 + 4096 * 100;
+
+/// The maximum number of distinct `Buf`s to hold in a list before requiring
+/// a flush. Only affects when the buffer strategy is to queue buffers.
+///
+/// Note that a flush can happen before reaching the maximum. This simply
+/// forces a flush if the queue gets this big.
+const MAX_BUF_LIST_BUFFERS: usize = 16;
+
+pub(crate) struct Buffered<T, B> {
+    flush_pipeline: bool,
+    io: T,
+    read_blocked: bool,
+    read_buf: BytesMut,
+    read_buf_strategy: ReadStrategy,
+    write_buf: WriteBuf<B>,
+}
+
+impl<T, B> fmt::Debug for Buffered<T, B>
+where
+    B: Buf,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Buffered")
+            .field("read_buf", &self.read_buf)
+            .field("write_buf", &self.write_buf)
+            .finish()
+    }
+}
+
+impl<T, B> Buffered<T, B>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    B: Buf,
+{
+    pub(crate) fn new(io: T) -> Buffered<T, B> {
+        let strategy = if io.is_write_vectored() {
+            WriteStrategy::Queue
+        } else {
+            WriteStrategy::Flatten
+        };
+        let write_buf = WriteBuf::new(strategy);
+        Buffered {
+            flush_pipeline: false,
+            io,
+            read_blocked: false,
+            read_buf: BytesMut::with_capacity(0),
+            read_buf_strategy: ReadStrategy::default(),
+            write_buf,
+        }
+    }
+
+    #[cfg(feature = "server")]
+    pub(crate) fn set_flush_pipeline(&mut self, enabled: bool) {
+        debug_assert!(!self.write_buf.has_remaining());
+        self.flush_pipeline = enabled;
+        if enabled {
+            self.set_write_strategy_flatten();
+        }
+    }
+
+    pub(crate) fn set_max_buf_size(&mut self, max: usize) {
+        assert!(
+            max >= MINIMUM_MAX_BUFFER_SIZE,
+            "The max_buf_size cannot be smaller than {}.",
+            MINIMUM_MAX_BUFFER_SIZE,
+        );
+        self.read_buf_strategy = ReadStrategy::with_max(max);
+        self.write_buf.max_buf_size = max;
+    }
+
+    #[cfg(feature = "client")]
+    pub(crate) fn set_read_buf_exact_size(&mut self, sz: usize) {
+        self.read_buf_strategy = ReadStrategy::Exact(sz);
+    }
+
+    pub(crate) fn set_write_strategy_flatten(&mut self) {
+        // this should always be called only at construction time,
+        // so this assert is here to catch myself
+        debug_assert!(self.write_buf.queue.bufs_cnt() == 0);
+        self.write_buf.set_strategy(WriteStrategy::Flatten);
+    }
+
+    pub(crate) fn set_write_strategy_queue(&mut self) {
+        // this should always be called only at construction time,
+        // so this assert is here to catch myself
+        debug_assert!(self.write_buf.queue.bufs_cnt() == 0);
+        self.write_buf.set_strategy(WriteStrategy::Queue);
+    }
+
+    pub(crate) fn read_buf(&self) -> &[u8] {
+        self.read_buf.as_ref()
+    }
+
+    #[cfg(test)]
+    #[cfg(feature = "nightly")]
+    pub(super) fn read_buf_mut(&mut self) -> &mut BytesMut {
+        &mut self.read_buf
+    }
+
+    /// Return the "allocated" available space, not the potential space
+    /// that could be allocated in the future.
+    fn read_buf_remaining_mut(&self) -> usize {
+        self.read_buf.capacity() - self.read_buf.len()
+    }
+
+    /// Return whether we can append to the headers buffer.
+    ///
+    /// Reasons we can't:
+    /// - The write buf is in queue mode, and some of the past body is still
+    ///   needing to be flushed.
+    pub(crate) fn can_headers_buf(&self) -> bool {
+        !self.write_buf.queue.has_remaining()
+    }
+
+    pub(crate) fn headers_buf(&mut self) -> &mut Vec<u8> {
+        let buf = self.write_buf.headers_mut();
+        &mut buf.bytes
+    }
+
+    pub(super) fn write_buf(&mut self) -> &mut WriteBuf<B> {
+        &mut self.write_buf
+    }
+
+    pub(crate) fn buffer<BB: Buf + Into<B>>(&mut self, buf: BB) {
+        self.write_buf.buffer(buf)
+    }
+
+    pub(crate) fn can_buffer(&self) -> bool {
+        self.flush_pipeline || self.write_buf.can_buffer()
+    }
+
+    pub(crate) fn consume_leading_lines(&mut self) {
+        if !self.read_buf.is_empty() {
+            let mut i = 0;
+            while i < self.read_buf.len() {
+                match self.read_buf[i] {
+                    b'\r' | b'\n' => i += 1,
+                    _ => break,
+                }
+            }
+            self.read_buf.advance(i);
+        }
+    }
+
+    pub(super) fn parse<S>(
+        &mut self,
+        cx: &mut task::Context<'_>,
+        parse_ctx: ParseContext<'_>,
+    ) -> Poll<crate::Result<ParsedMessage<S::Incoming>>>
+    where
+        S: Http1Transaction,
+    {
+        loop {
+            match super::role::parse_headers::<S>(
+                &mut self.read_buf,
+                ParseContext {
+                    cached_headers: parse_ctx.cached_headers,
+                    req_method: parse_ctx.req_method,
+                    h1_parser_config: parse_ctx.h1_parser_config.clone(),
+                    #[cfg(all(feature = "server", feature = "runtime"))]
+                    h1_header_read_timeout: parse_ctx.h1_header_read_timeout,
+                    #[cfg(all(feature = "server", feature = "runtime"))]
+                    h1_header_read_timeout_fut: parse_ctx.h1_header_read_timeout_fut,
+                    #[cfg(all(feature = "server", feature = "runtime"))]
+                    h1_header_read_timeout_running: parse_ctx.h1_header_read_timeout_running,
+                    preserve_header_case: parse_ctx.preserve_header_case,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: parse_ctx.preserve_header_order,
+                    h09_responses: parse_ctx.h09_responses,
+                    #[cfg(feature = "ffi")]
+                    on_informational: parse_ctx.on_informational,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: parse_ctx.raw_headers,
+                },
+            )? {
+                Some(msg) => {
+                    debug!("parsed {} headers", msg.head.headers.len());
+
+                    #[cfg(all(feature = "server", feature = "runtime"))]
+                    {
+                        *parse_ctx.h1_header_read_timeout_running = false;
+
+                        if let Some(h1_header_read_timeout_fut) =
+                            parse_ctx.h1_header_read_timeout_fut
+                        {
+                            // Reset the timer in order to avoid woken up when the timeout finishes
+                            h1_header_read_timeout_fut
+                                .as_mut()
+                                .reset(Instant::now() + Duration::from_secs(30 * 24 * 60 * 60));
+                        }
+                    }
+                    return Poll::Ready(Ok(msg));
+                }
+                None => {
+                    let max = self.read_buf_strategy.max();
+                    if self.read_buf.len() >= max {
+                        debug!("max_buf_size ({}) reached, closing", max);
+                        return Poll::Ready(Err(crate::Error::new_too_large()));
+                    }
+
+                    #[cfg(all(feature = "server", feature = "runtime"))]
+                    if *parse_ctx.h1_header_read_timeout_running {
+                        if let Some(h1_header_read_timeout_fut) =
+                            parse_ctx.h1_header_read_timeout_fut
+                        {
+                            if Pin::new(h1_header_read_timeout_fut).poll(cx).is_ready() {
+                                *parse_ctx.h1_header_read_timeout_running = false;
+
+                                tracing::warn!("read header from client timeout");
+                                return Poll::Ready(Err(crate::Error::new_header_timeout()));
+                            }
+                        }
+                    }
+                }
+            }
+            if ready!(self.poll_read_from_io(cx)).map_err(crate::Error::new_io)? == 0 {
+                trace!("parse eof");
+                return Poll::Ready(Err(crate::Error::new_incomplete()));
+            }
+        }
+    }
+
+    pub(crate) fn poll_read_from_io(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<io::Result<usize>> {
+        self.read_blocked = false;
+        let next = self.read_buf_strategy.next();
+        if self.read_buf_remaining_mut() < next {
+            self.read_buf.reserve(next);
+        }
+
+        let dst = self.read_buf.chunk_mut();
+        let dst = unsafe { &mut *(dst as *mut _ as *mut [MaybeUninit<u8>]) };
+        let mut buf = ReadBuf::uninit(dst);
+        match Pin::new(&mut self.io).poll_read(cx, &mut buf) {
+            Poll::Ready(Ok(_)) => {
+                let n = buf.filled().len();
+                trace!("received {} bytes", n);
+                unsafe {
+                    // Safety: we just read that many bytes into the
+                    // uninitialized part of the buffer, so this is okay.
+                    // @tokio pls give me back `poll_read_buf` thanks
+                    self.read_buf.advance_mut(n);
+                }
+                self.read_buf_strategy.record(n);
+                Poll::Ready(Ok(n))
+            }
+            Poll::Pending => {
+                self.read_blocked = true;
+                Poll::Pending
+            }
+            Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+        }
+    }
+
+    pub(crate) fn into_inner(self) -> (T, Bytes) {
+        (self.io, self.read_buf.freeze())
+    }
+
+    pub(crate) fn io_mut(&mut self) -> &mut T {
+        &mut self.io
+    }
+
+    pub(crate) fn is_read_blocked(&self) -> bool {
+        self.read_blocked
+    }
+
+    pub(crate) fn poll_flush(&mut self, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+        if self.flush_pipeline && !self.read_buf.is_empty() {
+            Poll::Ready(Ok(()))
+        } else if self.write_buf.remaining() == 0 {
+            Pin::new(&mut self.io).poll_flush(cx)
+        } else {
+            if let WriteStrategy::Flatten = self.write_buf.strategy {
+                return self.poll_flush_flattened(cx);
+            }
+
+            const MAX_WRITEV_BUFS: usize = 64;
+            loop {
+                let n = {
+                    let mut iovs = [IoSlice::new(&[]); MAX_WRITEV_BUFS];
+                    let len = self.write_buf.chunks_vectored(&mut iovs);
+                    ready!(Pin::new(&mut self.io).poll_write_vectored(cx, &iovs[..len]))?
+                };
+                // TODO(eliza): we have to do this manually because
+                // `poll_write_buf` doesn't exist in Tokio 0.3 yet...when
+                // `poll_write_buf` comes back, the manual advance will need to leave!
+                self.write_buf.advance(n);
+                debug!("flushed {} bytes", n);
+                if self.write_buf.remaining() == 0 {
+                    break;
+                } else if n == 0 {
+                    trace!(
+                        "write returned zero, but {} bytes remaining",
+                        self.write_buf.remaining()
+                    );
+                    return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
+                }
+            }
+            Pin::new(&mut self.io).poll_flush(cx)
+        }
+    }
+
+    /// Specialized version of `flush` when strategy is Flatten.
+    ///
+    /// Since all buffered bytes are flattened into the single headers buffer,
+    /// that skips some bookkeeping around using multiple buffers.
+    fn poll_flush_flattened(&mut self, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+        loop {
+            let n = ready!(Pin::new(&mut self.io).poll_write(cx, self.write_buf.headers.chunk()))?;
+            debug!("flushed {} bytes", n);
+            self.write_buf.headers.advance(n);
+            if self.write_buf.headers.remaining() == 0 {
+                self.write_buf.headers.reset();
+                break;
+            } else if n == 0 {
+                trace!(
+                    "write returned zero, but {} bytes remaining",
+                    self.write_buf.remaining()
+                );
+                return Poll::Ready(Err(io::ErrorKind::WriteZero.into()));
+            }
+        }
+        Pin::new(&mut self.io).poll_flush(cx)
+    }
+
+    #[cfg(test)]
+    fn flush<'a>(&'a mut self) -> impl std::future::Future<Output = io::Result<()>> + 'a {
+        futures_util::future::poll_fn(move |cx| self.poll_flush(cx))
+    }
+}
+
+// The `B` is a `Buf`, we never project a pin to it
+impl<T: Unpin, B> Unpin for Buffered<T, B> {}
+
+// TODO: This trait is old... at least rename to PollBytes or something...
+pub(crate) trait MemRead {
+    fn read_mem(&mut self, cx: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>>;
+}
+
+impl<T, B> MemRead for Buffered<T, B>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    B: Buf,
+{
+    fn read_mem(&mut self, cx: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
+        if !self.read_buf.is_empty() {
+            let n = std::cmp::min(len, self.read_buf.len());
+            Poll::Ready(Ok(self.read_buf.split_to(n).freeze()))
+        } else {
+            let n = ready!(self.poll_read_from_io(cx))?;
+            Poll::Ready(Ok(self.read_buf.split_to(::std::cmp::min(len, n)).freeze()))
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum ReadStrategy {
+    Adaptive {
+        decrease_now: bool,
+        next: usize,
+        max: usize,
+    },
+    #[cfg(feature = "client")]
+    Exact(usize),
+}
+
+impl ReadStrategy {
+    fn with_max(max: usize) -> ReadStrategy {
+        ReadStrategy::Adaptive {
+            decrease_now: false,
+            next: INIT_BUFFER_SIZE,
+            max,
+        }
+    }
+
+    fn next(&self) -> usize {
+        match *self {
+            ReadStrategy::Adaptive { next, .. } => next,
+            #[cfg(feature = "client")]
+            ReadStrategy::Exact(exact) => exact,
+        }
+    }
+
+    fn max(&self) -> usize {
+        match *self {
+            ReadStrategy::Adaptive { max, .. } => max,
+            #[cfg(feature = "client")]
+            ReadStrategy::Exact(exact) => exact,
+        }
+    }
+
+    fn record(&mut self, bytes_read: usize) {
+        match *self {
+            ReadStrategy::Adaptive {
+                ref mut decrease_now,
+                ref mut next,
+                max,
+                ..
+            } => {
+                if bytes_read >= *next {
+                    *next = cmp::min(incr_power_of_two(*next), max);
+                    *decrease_now = false;
+                } else {
+                    let decr_to = prev_power_of_two(*next);
+                    if bytes_read < decr_to {
+                        if *decrease_now {
+                            *next = cmp::max(decr_to, INIT_BUFFER_SIZE);
+                            *decrease_now = false;
+                        } else {
+                            // Decreasing is a two "record" process.
+                            *decrease_now = true;
+                        }
+                    } else {
+                        // A read within the current range should cancel
+                        // a potential decrease, since we just saw proof
+                        // that we still need this size.
+                        *decrease_now = false;
+                    }
+                }
+            }
+            #[cfg(feature = "client")]
+            ReadStrategy::Exact(_) => (),
+        }
+    }
+}
+
+fn incr_power_of_two(n: usize) -> usize {
+    n.saturating_mul(2)
+}
+
+fn prev_power_of_two(n: usize) -> usize {
+    // Only way this shift can underflow is if n is less than 4.
+    // (Which would means `usize::MAX >> 64` and underflowed!)
+    debug_assert!(n >= 4);
+    (::std::usize::MAX >> (n.leading_zeros() + 2)) + 1
+}
+
+impl Default for ReadStrategy {
+    fn default() -> ReadStrategy {
+        ReadStrategy::with_max(DEFAULT_MAX_BUFFER_SIZE)
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct Cursor<T> {
+    bytes: T,
+    pos: usize,
+}
+
+impl<T: AsRef<[u8]>> Cursor<T> {
+    #[inline]
+    pub(crate) fn new(bytes: T) -> Cursor<T> {
+        Cursor { bytes, pos: 0 }
+    }
+}
+
+impl Cursor<Vec<u8>> {
+    /// If we've advanced the position a bit in this cursor, and wish to
+    /// extend the underlying vector, we may wish to unshift the "read" bytes
+    /// off, and move everything else over.
+    fn maybe_unshift(&mut self, additional: usize) {
+        if self.pos == 0 {
+            // nothing to do
+            return;
+        }
+
+        if self.bytes.capacity() - self.bytes.len() >= additional {
+            // there's room!
+            return;
+        }
+
+        self.bytes.drain(0..self.pos);
+        self.pos = 0;
+    }
+
+    fn reset(&mut self) {
+        self.pos = 0;
+        self.bytes.clear();
+    }
+}
+
+impl<T: AsRef<[u8]>> fmt::Debug for Cursor<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Cursor")
+            .field("pos", &self.pos)
+            .field("len", &self.bytes.as_ref().len())
+            .finish()
+    }
+}
+
+impl<T: AsRef<[u8]>> Buf for Cursor<T> {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.bytes.as_ref().len() - self.pos
+    }
+
+    #[inline]
+    fn chunk(&self) -> &[u8] {
+        &self.bytes.as_ref()[self.pos..]
+    }
+
+    #[inline]
+    fn advance(&mut self, cnt: usize) {
+        debug_assert!(self.pos + cnt <= self.bytes.as_ref().len());
+        self.pos += cnt;
+    }
+}
+
+// an internal buffer to collect writes before flushes
+pub(super) struct WriteBuf<B> {
+    /// Re-usable buffer that holds message headers
+    headers: Cursor<Vec<u8>>,
+    max_buf_size: usize,
+    /// Deque of user buffers if strategy is Queue
+    queue: BufList<B>,
+    strategy: WriteStrategy,
+}
+
+impl<B: Buf> WriteBuf<B> {
+    fn new(strategy: WriteStrategy) -> WriteBuf<B> {
+        WriteBuf {
+            headers: Cursor::new(Vec::with_capacity(INIT_BUFFER_SIZE)),
+            max_buf_size: DEFAULT_MAX_BUFFER_SIZE,
+            queue: BufList::new(),
+            strategy,
+        }
+    }
+}
+
+impl<B> WriteBuf<B>
+where
+    B: Buf,
+{
+    fn set_strategy(&mut self, strategy: WriteStrategy) {
+        self.strategy = strategy;
+    }
+
+    pub(super) fn buffer<BB: Buf + Into<B>>(&mut self, mut buf: BB) {
+        debug_assert!(buf.has_remaining());
+        match self.strategy {
+            WriteStrategy::Flatten => {
+                let head = self.headers_mut();
+
+                head.maybe_unshift(buf.remaining());
+                trace!(
+                    self.len = head.remaining(),
+                    buf.len = buf.remaining(),
+                    "buffer.flatten"
+                );
+                //perf: This is a little faster than <Vec as BufMut>>::put,
+                //but accomplishes the same result.
+                loop {
+                    let adv = {
+                        let slice = buf.chunk();
+                        if slice.is_empty() {
+                            return;
+                        }
+                        head.bytes.extend_from_slice(slice);
+                        slice.len()
+                    };
+                    buf.advance(adv);
+                }
+            }
+            WriteStrategy::Queue => {
+                trace!(
+                    self.len = self.remaining(),
+                    buf.len = buf.remaining(),
+                    "buffer.queue"
+                );
+                self.queue.push(buf.into());
+            }
+        }
+    }
+
+    fn can_buffer(&self) -> bool {
+        match self.strategy {
+            WriteStrategy::Flatten => self.remaining() < self.max_buf_size,
+            WriteStrategy::Queue => {
+                self.queue.bufs_cnt() < MAX_BUF_LIST_BUFFERS && self.remaining() < self.max_buf_size
+            }
+        }
+    }
+
+    fn headers_mut(&mut self) -> &mut Cursor<Vec<u8>> {
+        debug_assert!(!self.queue.has_remaining());
+        &mut self.headers
+    }
+}
+
+impl<B: Buf> fmt::Debug for WriteBuf<B> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("WriteBuf")
+            .field("remaining", &self.remaining())
+            .field("strategy", &self.strategy)
+            .finish()
+    }
+}
+
+impl<B: Buf> Buf for WriteBuf<B> {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.headers.remaining() + self.queue.remaining()
+    }
+
+    #[inline]
+    fn chunk(&self) -> &[u8] {
+        let headers = self.headers.chunk();
+        if !headers.is_empty() {
+            headers
+        } else {
+            self.queue.chunk()
+        }
+    }
+
+    #[inline]
+    fn advance(&mut self, cnt: usize) {
+        let hrem = self.headers.remaining();
+
+        match hrem.cmp(&cnt) {
+            cmp::Ordering::Equal => self.headers.reset(),
+            cmp::Ordering::Greater => self.headers.advance(cnt),
+            cmp::Ordering::Less => {
+                let qcnt = cnt - hrem;
+                self.headers.reset();
+                self.queue.advance(qcnt);
+            }
+        }
+    }
+
+    #[inline]
+    fn chunks_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
+        let n = self.headers.chunks_vectored(dst);
+        self.queue.chunks_vectored(&mut dst[n..]) + n
+    }
+}
+
+#[derive(Debug)]
+enum WriteStrategy {
+    Flatten,
+    Queue,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    use tokio_test::io::Builder as Mock;
+
+    // #[cfg(feature = "nightly")]
+    // use test::Bencher;
+
+    /*
+    impl<T: Read> MemRead for AsyncIo<T> {
+        fn read_mem(&mut self, len: usize) -> Poll<Bytes, io::Error> {
+            let mut v = vec![0; len];
+            let n = try_nb!(self.read(v.as_mut_slice()));
+            Ok(Async::Ready(BytesMut::from(&v[..n]).freeze()))
+        }
+    }
+    */
+
+    #[tokio::test]
+    #[ignore]
+    async fn iobuf_write_empty_slice() {
+        // TODO(eliza): can i have writev back pls T_T
+        // // First, let's just check that the Mock would normally return an
+        // // error on an unexpected write, even if the buffer is empty...
+        // let mut mock = Mock::new().build();
+        // futures_util::future::poll_fn(|cx| {
+        //     Pin::new(&mut mock).poll_write_buf(cx, &mut Cursor::new(&[]))
+        // })
+        // .await
+        // .expect_err("should be a broken pipe");
+
+        // // underlying io will return the logic error upon write,
+        // // so we are testing that the io_buf does not trigger a write
+        // // when there is nothing to flush
+        // let mock = Mock::new().build();
+        // let mut io_buf = Buffered::<_, Cursor<Vec<u8>>>::new(mock);
+        // io_buf.flush().await.expect("should short-circuit flush");
+    }
+
+    #[tokio::test]
+    async fn parse_reads_until_blocked() {
+        use crate::proto::h1::ClientTransaction;
+
+        let _ = pretty_env_logger::try_init();
+        let mock = Mock::new()
+            // Split over multiple reads will read all of it
+            .read(b"HTTP/1.1 200 OK\r\n")
+            .read(b"Server: hyper\r\n")
+            // missing last line ending
+            .wait(Duration::from_secs(1))
+            .build();
+
+        let mut buffered = Buffered::<_, Cursor<Vec<u8>>>::new(mock);
+
+        // We expect a `parse` to be not ready, and so can't await it directly.
+        // Rather, this `poll_fn` will wrap the `Poll` result.
+        futures_util::future::poll_fn(|cx| {
+            let parse_ctx = ParseContext {
+                cached_headers: &mut None,
+                req_method: &mut None,
+                h1_parser_config: Default::default(),
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout: None,
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout_fut: &mut None,
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout_running: &mut false,
+                preserve_header_case: false,
+                #[cfg(feature = "ffi")]
+                preserve_header_order: false,
+                h09_responses: false,
+                #[cfg(feature = "ffi")]
+                on_informational: &mut None,
+                #[cfg(feature = "ffi")]
+                raw_headers: false,
+            };
+            assert!(buffered
+                .parse::<ClientTransaction>(cx, parse_ctx)
+                .is_pending());
+            Poll::Ready(())
+        })
+        .await;
+
+        assert_eq!(
+            buffered.read_buf,
+            b"HTTP/1.1 200 OK\r\nServer: hyper\r\n"[..]
+        );
+    }
+
+    #[test]
+    fn read_strategy_adaptive_increments() {
+        let mut strategy = ReadStrategy::default();
+        assert_eq!(strategy.next(), 8192);
+
+        // Grows if record == next
+        strategy.record(8192);
+        assert_eq!(strategy.next(), 16384);
+
+        strategy.record(16384);
+        assert_eq!(strategy.next(), 32768);
+
+        // Enormous records still increment at same rate
+        strategy.record(::std::usize::MAX);
+        assert_eq!(strategy.next(), 65536);
+
+        let max = strategy.max();
+        while strategy.next() < max {
+            strategy.record(max);
+        }
+
+        assert_eq!(strategy.next(), max, "never goes over max");
+        strategy.record(max + 1);
+        assert_eq!(strategy.next(), max, "never goes over max");
+    }
+
+    #[test]
+    fn read_strategy_adaptive_decrements() {
+        let mut strategy = ReadStrategy::default();
+        strategy.record(8192);
+        assert_eq!(strategy.next(), 16384);
+
+        strategy.record(1);
+        assert_eq!(
+            strategy.next(),
+            16384,
+            "first smaller record doesn't decrement yet"
+        );
+        strategy.record(8192);
+        assert_eq!(strategy.next(), 16384, "record was with range");
+
+        strategy.record(1);
+        assert_eq!(
+            strategy.next(),
+            16384,
+            "in-range record should make this the 'first' again"
+        );
+
+        strategy.record(1);
+        assert_eq!(strategy.next(), 8192, "second smaller record decrements");
+
+        strategy.record(1);
+        assert_eq!(strategy.next(), 8192, "first doesn't decrement");
+        strategy.record(1);
+        assert_eq!(strategy.next(), 8192, "doesn't decrement under minimum");
+    }
+
+    #[test]
+    fn read_strategy_adaptive_stays_the_same() {
+        let mut strategy = ReadStrategy::default();
+        strategy.record(8192);
+        assert_eq!(strategy.next(), 16384);
+
+        strategy.record(8193);
+        assert_eq!(
+            strategy.next(),
+            16384,
+            "first smaller record doesn't decrement yet"
+        );
+
+        strategy.record(8193);
+        assert_eq!(
+            strategy.next(),
+            16384,
+            "with current step does not decrement"
+        );
+    }
+
+    #[test]
+    fn read_strategy_adaptive_max_fuzz() {
+        fn fuzz(max: usize) {
+            let mut strategy = ReadStrategy::with_max(max);
+            while strategy.next() < max {
+                strategy.record(::std::usize::MAX);
+            }
+            let mut next = strategy.next();
+            while next > 8192 {
+                strategy.record(1);
+                strategy.record(1);
+                next = strategy.next();
+                assert!(
+                    next.is_power_of_two(),
+                    "decrement should be powers of two: {} (max = {})",
+                    next,
+                    max,
+                );
+            }
+        }
+
+        let mut max = 8192;
+        while max < std::usize::MAX {
+            fuzz(max);
+            max = (max / 2).saturating_mul(3);
+        }
+        fuzz(::std::usize::MAX);
+    }
+
+    #[test]
+    #[should_panic]
+    #[cfg(debug_assertions)] // needs to trigger a debug_assert
+    fn write_buf_requires_non_empty_bufs() {
+        let mock = Mock::new().build();
+        let mut buffered = Buffered::<_, Cursor<Vec<u8>>>::new(mock);
+
+        buffered.buffer(Cursor::new(Vec::new()));
+    }
+
+    /*
+    TODO: needs tokio_test::io to allow configure write_buf calls
+    #[test]
+    fn write_buf_queue() {
+        let _ = pretty_env_logger::try_init();
+
+        let mock = AsyncIo::new_buf(vec![], 1024);
+        let mut buffered = Buffered::<_, Cursor<Vec<u8>>>::new(mock);
+
+
+        buffered.headers_buf().extend(b"hello ");
+        buffered.buffer(Cursor::new(b"world, ".to_vec()));
+        buffered.buffer(Cursor::new(b"it's ".to_vec()));
+        buffered.buffer(Cursor::new(b"hyper!".to_vec()));
+        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 3);
+        buffered.flush().unwrap();
+
+        assert_eq!(buffered.io, b"hello world, it's hyper!");
+        assert_eq!(buffered.io.num_writes(), 1);
+        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 0);
+    }
+    */
+
+    #[tokio::test]
+    async fn write_buf_flatten() {
+        let _ = pretty_env_logger::try_init();
+
+        let mock = Mock::new().write(b"hello world, it's hyper!").build();
+
+        let mut buffered = Buffered::<_, Cursor<Vec<u8>>>::new(mock);
+        buffered.write_buf.set_strategy(WriteStrategy::Flatten);
+
+        buffered.headers_buf().extend(b"hello ");
+        buffered.buffer(Cursor::new(b"world, ".to_vec()));
+        buffered.buffer(Cursor::new(b"it's ".to_vec()));
+        buffered.buffer(Cursor::new(b"hyper!".to_vec()));
+        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 0);
+
+        buffered.flush().await.expect("flush");
+    }
+
+    #[test]
+    fn write_buf_flatten_partially_flushed() {
+        let _ = pretty_env_logger::try_init();
+
+        let b = |s: &str| Cursor::new(s.as_bytes().to_vec());
+
+        let mut write_buf = WriteBuf::<Cursor<Vec<u8>>>::new(WriteStrategy::Flatten);
+
+        write_buf.buffer(b("hello "));
+        write_buf.buffer(b("world, "));
+
+        assert_eq!(write_buf.chunk(), b"hello world, ");
+
+        // advance most of the way, but not all
+        write_buf.advance(11);
+
+        assert_eq!(write_buf.chunk(), b", ");
+        assert_eq!(write_buf.headers.pos, 11);
+        assert_eq!(write_buf.headers.bytes.capacity(), INIT_BUFFER_SIZE);
+
+        // there's still room in the headers buffer, so just push on the end
+        write_buf.buffer(b("it's hyper!"));
+
+        assert_eq!(write_buf.chunk(), b", it's hyper!");
+        assert_eq!(write_buf.headers.pos, 11);
+
+        let rem1 = write_buf.remaining();
+        let cap = write_buf.headers.bytes.capacity();
+
+        // but when this would go over capacity, don't copy the old bytes
+        write_buf.buffer(Cursor::new(vec![b'X'; cap]));
+        assert_eq!(write_buf.remaining(), cap + rem1);
+        assert_eq!(write_buf.headers.pos, 0);
+    }
+
+    #[tokio::test]
+    async fn write_buf_queue_disable_auto() {
+        let _ = pretty_env_logger::try_init();
+
+        let mock = Mock::new()
+            .write(b"hello ")
+            .write(b"world, ")
+            .write(b"it's ")
+            .write(b"hyper!")
+            .build();
+
+        let mut buffered = Buffered::<_, Cursor<Vec<u8>>>::new(mock);
+        buffered.write_buf.set_strategy(WriteStrategy::Queue);
+
+        // we have 4 buffers, and vec IO disabled, but explicitly said
+        // don't try to auto detect (via setting strategy above)
+
+        buffered.headers_buf().extend(b"hello ");
+        buffered.buffer(Cursor::new(b"world, ".to_vec()));
+        buffered.buffer(Cursor::new(b"it's ".to_vec()));
+        buffered.buffer(Cursor::new(b"hyper!".to_vec()));
+        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 3);
+
+        buffered.flush().await.expect("flush");
+
+        assert_eq!(buffered.write_buf.queue.bufs_cnt(), 0);
+    }
+
+    // #[cfg(feature = "nightly")]
+    // #[bench]
+    // fn bench_write_buf_flatten_buffer_chunk(b: &mut Bencher) {
+    //     let s = "Hello, World!";
+    //     b.bytes = s.len() as u64;
+
+    //     let mut write_buf = WriteBuf::<bytes::Bytes>::new();
+    //     write_buf.set_strategy(WriteStrategy::Flatten);
+    //     b.iter(|| {
+    //         let chunk = bytes::Bytes::from(s);
+    //         write_buf.buffer(chunk);
+    //         ::test::black_box(&write_buf);
+    //         write_buf.headers.bytes.clear();
+    //     })
+    // }
+}
diff --git a/hyper/src/proto/h1/mod.rs b/hyper/src/proto/h1/mod.rs
new file mode 100644
index 0000000..5a2587a
--- /dev/null
+++ b/hyper/src/proto/h1/mod.rs
@@ -0,0 +1,122 @@
+#[cfg(all(feature = "server", feature = "runtime"))]
+use std::{pin::Pin, time::Duration};
+
+use bytes::BytesMut;
+use http::{HeaderMap, Method};
+use httparse::ParserConfig;
+#[cfg(all(feature = "server", feature = "runtime"))]
+use tokio::time::Sleep;
+
+use crate::body::DecodedLength;
+use crate::proto::{BodyLength, MessageHead};
+
+pub(crate) use self::conn::Conn;
+pub(crate) use self::decode::Decoder;
+pub(crate) use self::dispatch::Dispatcher;
+pub(crate) use self::encode::{EncodedBuf, Encoder};
+//TODO: move out of h1::io
+pub(crate) use self::io::MINIMUM_MAX_BUFFER_SIZE;
+
+mod conn;
+mod decode;
+pub(crate) mod dispatch;
+mod encode;
+mod io;
+mod role;
+
+cfg_client! {
+    pub(crate) type ClientTransaction = role::Client;
+}
+
+cfg_server! {
+    pub(crate) type ServerTransaction = role::Server;
+}
+
+pub(crate) trait Http1Transaction {
+    type Incoming;
+    type Outgoing: Default;
+    const LOG: &'static str;
+    fn parse(bytes: &mut BytesMut, ctx: ParseContext<'_>) -> ParseResult<Self::Incoming>;
+    fn encode(enc: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> crate::Result<Encoder>;
+
+    fn on_error(err: &crate::Error) -> Option<MessageHead<Self::Outgoing>>;
+
+    fn is_client() -> bool {
+        !Self::is_server()
+    }
+
+    fn is_server() -> bool {
+        !Self::is_client()
+    }
+
+    fn should_error_on_parse_eof() -> bool {
+        Self::is_client()
+    }
+
+    fn should_read_first() -> bool {
+        Self::is_server()
+    }
+
+    fn update_date() {}
+}
+
+/// Result newtype for Http1Transaction::parse.
+pub(crate) type ParseResult<T> = Result<Option<ParsedMessage<T>>, crate::error::Parse>;
+
+#[derive(Debug)]
+pub(crate) struct ParsedMessage<T> {
+    head: MessageHead<T>,
+    decode: DecodedLength,
+    expect_continue: bool,
+    keep_alive: bool,
+    wants_upgrade: bool,
+}
+
+pub(crate) struct ParseContext<'a> {
+    cached_headers: &'a mut Option<HeaderMap>,
+    req_method: &'a mut Option<Method>,
+    h1_parser_config: ParserConfig,
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    h1_header_read_timeout: Option<Duration>,
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    h1_header_read_timeout_fut: &'a mut Option<Pin<Box<Sleep>>>,
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    h1_header_read_timeout_running: &'a mut bool,
+    preserve_header_case: bool,
+    #[cfg(feature = "ffi")]
+    preserve_header_order: bool,
+    h09_responses: bool,
+    #[cfg(feature = "ffi")]
+    on_informational: &'a mut Option<crate::ffi::OnInformational>,
+    #[cfg(feature = "ffi")]
+    raw_headers: bool,
+}
+
+/// Passed to Http1Transaction::encode
+pub(crate) struct Encode<'a, T> {
+    head: &'a mut MessageHead<T>,
+    body: Option<BodyLength>,
+    #[cfg(feature = "server")]
+    keep_alive: bool,
+    req_method: &'a mut Option<Method>,
+    title_case_headers: bool,
+}
+
+/// Extra flags that a request "wants", like expect-continue or upgrades.
+#[derive(Clone, Copy, Debug)]
+struct Wants(u8);
+
+impl Wants {
+    const EMPTY: Wants = Wants(0b00);
+    const EXPECT: Wants = Wants(0b01);
+    const UPGRADE: Wants = Wants(0b10);
+
+    #[must_use]
+    fn add(self, other: Wants) -> Wants {
+        Wants(self.0 | other.0)
+    }
+
+    fn contains(&self, other: Wants) -> bool {
+        (self.0 & other.0) == other.0
+    }
+}
diff --git a/hyper/src/proto/h1/role.rs b/hyper/src/proto/h1/role.rs
new file mode 100644
index 0000000..6252207
--- /dev/null
+++ b/hyper/src/proto/h1/role.rs
@@ -0,0 +1,2847 @@
+use std::fmt::{self, Write};
+use std::mem::MaybeUninit;
+
+use bytes::Bytes;
+use bytes::BytesMut;
+#[cfg(feature = "server")]
+use http::header::ValueIter;
+use http::header::{self, Entry, HeaderName, HeaderValue};
+use http::{HeaderMap, Method, StatusCode, Version};
+#[cfg(all(feature = "server", feature = "runtime"))]
+use tokio::time::Instant;
+use tracing::{debug, error, trace, trace_span, warn};
+
+use crate::body::DecodedLength;
+#[cfg(feature = "server")]
+use crate::common::date;
+use crate::error::Parse;
+use crate::ext::HeaderCaseMap;
+#[cfg(feature = "ffi")]
+use crate::ext::OriginalHeaderOrder;
+use crate::headers;
+use crate::proto::h1::{
+    Encode, Encoder, Http1Transaction, ParseContext, ParseResult, ParsedMessage,
+};
+use crate::proto::{BodyLength, MessageHead, RequestHead, RequestLine};
+
+const MAX_HEADERS: usize = 100;
+const AVERAGE_HEADER_SIZE: usize = 30; // totally scientific
+#[cfg(feature = "server")]
+const MAX_URI_LEN: usize = (u16::MAX - 1) as usize;
+
+macro_rules! header_name {
+    ($bytes:expr) => {{
+        {
+            match HeaderName::from_bytes($bytes) {
+                Ok(name) => name,
+                Err(e) => maybe_panic!(e),
+            }
+        }
+    }};
+}
+
+macro_rules! header_value {
+    ($bytes:expr) => {{
+        {
+            unsafe { HeaderValue::from_maybe_shared_unchecked($bytes) }
+        }
+    }};
+}
+
+macro_rules! maybe_panic {
+    ($($arg:tt)*) => ({
+        let _err = ($($arg)*);
+        if cfg!(debug_assertions) {
+            panic!("{:?}", _err);
+        } else {
+            error!("Internal Hyper error, please report {:?}", _err);
+            return Err(Parse::Internal)
+        }
+    })
+}
+
+pub(super) fn parse_headers<T>(
+    bytes: &mut BytesMut,
+    ctx: ParseContext<'_>,
+) -> ParseResult<T::Incoming>
+where
+    T: Http1Transaction,
+{
+    // If the buffer is empty, don't bother entering the span, it's just noise.
+    if bytes.is_empty() {
+        return Ok(None);
+    }
+
+    let span = trace_span!("parse_headers");
+    let _s = span.enter();
+
+    #[cfg(all(feature = "server", feature = "runtime"))]
+    if !*ctx.h1_header_read_timeout_running {
+        if let Some(h1_header_read_timeout) = ctx.h1_header_read_timeout {
+            let deadline = Instant::now() + h1_header_read_timeout;
+            *ctx.h1_header_read_timeout_running = true;
+            match ctx.h1_header_read_timeout_fut {
+                Some(h1_header_read_timeout_fut) => {
+                    debug!("resetting h1 header read timeout timer");
+                    h1_header_read_timeout_fut.as_mut().reset(deadline);
+                }
+                None => {
+                    debug!("setting h1 header read timeout timer");
+                    *ctx.h1_header_read_timeout_fut =
+                        Some(Box::pin(tokio::time::sleep_until(deadline)));
+                }
+            }
+        }
+    }
+
+    T::parse(bytes, ctx)
+}
+
+pub(super) fn encode_headers<T>(
+    enc: Encode<'_, T::Outgoing>,
+    dst: &mut Vec<u8>,
+) -> crate::Result<Encoder>
+where
+    T: Http1Transaction,
+{
+    let span = trace_span!("encode_headers");
+    let _s = span.enter();
+    T::encode(enc, dst)
+}
+
+// There are 2 main roles, Client and Server.
+
+#[cfg(feature = "client")]
+pub(crate) enum Client {}
+
+#[cfg(feature = "server")]
+pub(crate) enum Server {}
+
+#[cfg(feature = "server")]
+impl Http1Transaction for Server {
+    type Incoming = RequestLine;
+    type Outgoing = StatusCode;
+    const LOG: &'static str = "{role=server}";
+
+    fn parse(buf: &mut BytesMut, ctx: ParseContext<'_>) -> ParseResult<RequestLine> {
+        debug_assert!(!buf.is_empty(), "parse called with empty buf");
+
+        let mut keep_alive;
+        let is_http_11;
+        let subject;
+        let version;
+        let len;
+        let headers_len;
+
+        // Unsafe: both headers_indices and headers are using uninitialized memory,
+        // but we *never* read any of it until after httparse has assigned
+        // values into it. By not zeroing out the stack memory, this saves
+        // a good ~5% on pipeline benchmarks.
+        let mut headers_indices: [MaybeUninit<HeaderIndices>; MAX_HEADERS] = unsafe {
+            // SAFETY: We can go safely from MaybeUninit array to array of MaybeUninit
+            MaybeUninit::uninit().assume_init()
+        };
+        {
+            /* SAFETY: it is safe to go from MaybeUninit array to array of MaybeUninit */
+            let mut headers: [MaybeUninit<httparse::Header<'_>>; MAX_HEADERS] =
+                unsafe { MaybeUninit::uninit().assume_init() };
+            trace!(bytes = buf.len(), "Request.parse");
+            let mut req = httparse::Request::new(&mut []);
+            let bytes = buf.as_ref();
+            match req.parse_with_uninit_headers(bytes, &mut headers) {
+                Ok(httparse::Status::Complete(parsed_len)) => {
+                    trace!("Request.parse Complete({})", parsed_len);
+                    len = parsed_len;
+                    let uri = req.path.unwrap();
+                    if uri.len() > MAX_URI_LEN {
+                        return Err(Parse::UriTooLong);
+                    }
+                    subject = RequestLine(
+                        Method::from_bytes(req.method.unwrap().as_bytes())?,
+                        uri.parse()?,
+                    );
+                    version = if req.version.unwrap() == 1 {
+                        keep_alive = true;
+                        is_http_11 = true;
+                        Version::HTTP_11
+                    } else {
+                        keep_alive = false;
+                        is_http_11 = false;
+                        Version::HTTP_10
+                    };
+
+                    record_header_indices(bytes, &req.headers, &mut headers_indices)?;
+                    headers_len = req.headers.len();
+                }
+                Ok(httparse::Status::Partial) => return Ok(None),
+                Err(err) => {
+                    return Err(match err {
+                        // if invalid Token, try to determine if for method or path
+                        httparse::Error::Token => {
+                            if req.method.is_none() {
+                                Parse::Method
+                            } else {
+                                debug_assert!(req.path.is_none());
+                                Parse::Uri
+                            }
+                        }
+                        other => other.into(),
+                    });
+                }
+            }
+        };
+
+        let slice = buf.split_to(len).freeze();
+
+        // According to https://tools.ietf.org/html/rfc7230#section-3.3.3
+        // 1. (irrelevant to Request)
+        // 2. (irrelevant to Request)
+        // 3. Transfer-Encoding: chunked has a chunked body.
+        // 4. If multiple differing Content-Length headers or invalid, close connection.
+        // 5. Content-Length header has a sized body.
+        // 6. Length 0.
+        // 7. (irrelevant to Request)
+
+        let mut decoder = DecodedLength::ZERO;
+        let mut expect_continue = false;
+        let mut con_len = None;
+        let mut is_te = false;
+        let mut is_te_chunked = false;
+        let mut wants_upgrade = subject.0 == Method::CONNECT;
+
+        let mut header_case_map = if ctx.preserve_header_case {
+            Some(HeaderCaseMap::default())
+        } else {
+            None
+        };
+
+        #[cfg(feature = "ffi")]
+        let mut header_order = if ctx.preserve_header_order {
+            Some(OriginalHeaderOrder::default())
+        } else {
+            None
+        };
+
+        let mut headers = ctx.cached_headers.take().unwrap_or_else(HeaderMap::new);
+
+        headers.reserve(headers_len);
+
+        for header in &headers_indices[..headers_len] {
+            // SAFETY: array is valid up to `headers_len`
+            let header = unsafe { &*header.as_ptr() };
+            let name = header_name!(&slice[header.name.0..header.name.1]);
+            let value = header_value!(slice.slice(header.value.0..header.value.1));
+
+            match name {
+                header::TRANSFER_ENCODING => {
+                    // https://tools.ietf.org/html/rfc7230#section-3.3.3
+                    // If Transfer-Encoding header is present, and 'chunked' is
+                    // not the final encoding, and this is a Request, then it is
+                    // malformed. A server should respond with 400 Bad Request.
+                    if !is_http_11 {
+                        debug!("HTTP/1.0 cannot have Transfer-Encoding header");
+                        return Err(Parse::transfer_encoding_unexpected());
+                    }
+                    is_te = true;
+                    if headers::is_chunked_(&value) {
+                        is_te_chunked = true;
+                        decoder = DecodedLength::CHUNKED;
+                    } else {
+                        is_te_chunked = false;
+                    }
+                }
+                header::CONTENT_LENGTH => {
+                    if is_te {
+                        continue;
+                    }
+                    let len = headers::content_length_parse(&value)
+                        .ok_or_else(Parse::content_length_invalid)?;
+                    if let Some(prev) = con_len {
+                        if prev != len {
+                            debug!(
+                                "multiple Content-Length headers with different values: [{}, {}]",
+                                prev, len,
+                            );
+                            return Err(Parse::content_length_invalid());
+                        }
+                        // we don't need to append this secondary length
+                        continue;
+                    }
+                    decoder = DecodedLength::checked_new(len)?;
+                    con_len = Some(len);
+                }
+                header::CONNECTION => {
+                    // keep_alive was previously set to default for Version
+                    if keep_alive {
+                        // HTTP/1.1
+                        keep_alive = !headers::connection_close(&value);
+                    } else {
+                        // HTTP/1.0
+                        keep_alive = headers::connection_keep_alive(&value);
+                    }
+                }
+                header::EXPECT => {
+                    // According to https://datatracker.ietf.org/doc/html/rfc2616#section-14.20
+                    // Comparison of expectation values is case-insensitive for unquoted tokens
+                    // (including the 100-continue token)
+                    expect_continue = value.as_bytes().eq_ignore_ascii_case(b"100-continue");
+                }
+                header::UPGRADE => {
+                    // Upgrades are only allowed with HTTP/1.1
+                    wants_upgrade = is_http_11;
+                }
+
+                _ => (),
+            }
+
+            if let Some(ref mut header_case_map) = header_case_map {
+                header_case_map.append(&name, slice.slice(header.name.0..header.name.1));
+            }
+
+            #[cfg(feature = "ffi")]
+            if let Some(ref mut header_order) = header_order {
+                header_order.append(&name);
+            }
+
+            headers.append(name, value);
+        }
+
+        if is_te && !is_te_chunked {
+            debug!("request with transfer-encoding header, but not chunked, bad request");
+            return Err(Parse::transfer_encoding_invalid());
+        }
+
+        let mut extensions = http::Extensions::default();
+
+        if let Some(header_case_map) = header_case_map {
+            extensions.insert(header_case_map);
+        }
+
+        #[cfg(feature = "ffi")]
+        if let Some(header_order) = header_order {
+            extensions.insert(header_order);
+        }
+
+        *ctx.req_method = Some(subject.0.clone());
+
+        Ok(Some(ParsedMessage {
+            head: MessageHead {
+                version,
+                subject,
+                headers,
+                extensions,
+            },
+            decode: decoder,
+            expect_continue,
+            keep_alive,
+            wants_upgrade,
+        }))
+    }
+
+    fn encode(mut msg: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> crate::Result<Encoder> {
+        trace!(
+            "Server::encode status={:?}, body={:?}, req_method={:?}",
+            msg.head.subject,
+            msg.body,
+            msg.req_method
+        );
+
+        let mut wrote_len = false;
+
+        // hyper currently doesn't support returning 1xx status codes as a Response
+        // This is because Service only allows returning a single Response, and
+        // so if you try to reply with a e.g. 100 Continue, you have no way of
+        // replying with the latter status code response.
+        let (ret, is_last) = if msg.head.subject == StatusCode::SWITCHING_PROTOCOLS {
+            (Ok(()), true)
+        } else if msg.req_method == &Some(Method::CONNECT) && msg.head.subject.is_success() {
+            // Sending content-length or transfer-encoding header on 2xx response
+            // to CONNECT is forbidden in RFC 7231.
+            wrote_len = true;
+            (Ok(()), true)
+        } else if msg.head.subject.is_informational() {
+            warn!("response with 1xx status code not supported");
+            *msg.head = MessageHead::default();
+            msg.head.subject = StatusCode::INTERNAL_SERVER_ERROR;
+            msg.body = None;
+            (Err(crate::Error::new_user_unsupported_status_code()), true)
+        } else {
+            (Ok(()), !msg.keep_alive)
+        };
+
+        // In some error cases, we don't know about the invalid message until already
+        // pushing some bytes onto the `dst`. In those cases, we don't want to send
+        // the half-pushed message, so rewind to before.
+        let orig_len = dst.len();
+
+        let init_cap = 30 + msg.head.headers.len() * AVERAGE_HEADER_SIZE;
+        dst.reserve(init_cap);
+
+        let custom_reason_phrase = msg.head.extensions.get::<crate::ext::ReasonPhrase>();
+
+        if msg.head.version == Version::HTTP_11
+            && msg.head.subject == StatusCode::OK
+            && custom_reason_phrase.is_none()
+        {
+            extend(dst, b"HTTP/1.1 200 OK\r\n");
+        } else {
+            match msg.head.version {
+                Version::HTTP_10 => extend(dst, b"HTTP/1.0 "),
+                Version::HTTP_11 => extend(dst, b"HTTP/1.1 "),
+                Version::HTTP_2 => {
+                    debug!("response with HTTP2 version coerced to HTTP/1.1");
+                    extend(dst, b"HTTP/1.1 ");
+                }
+                other => panic!("unexpected response version: {:?}", other),
+            }
+
+            extend(dst, msg.head.subject.as_str().as_bytes());
+            extend(dst, b" ");
+
+            if let Some(reason) = custom_reason_phrase {
+                extend(dst, reason.as_bytes());
+            } else {
+                // a reason MUST be written, as many parsers will expect it.
+                extend(
+                    dst,
+                    msg.head
+                        .subject
+                        .canonical_reason()
+                        .unwrap_or("<none>")
+                        .as_bytes(),
+                );
+            }
+
+            extend(dst, b"\r\n");
+        }
+
+        let orig_headers;
+        let extensions = std::mem::take(&mut msg.head.extensions);
+        let orig_headers = match extensions.get::<HeaderCaseMap>() {
+            None if msg.title_case_headers => {
+                orig_headers = HeaderCaseMap::default();
+                Some(&orig_headers)
+            }
+            orig_headers => orig_headers,
+        };
+        let encoder = if let Some(orig_headers) = orig_headers {
+            Self::encode_headers_with_original_case(
+                msg,
+                dst,
+                is_last,
+                orig_len,
+                wrote_len,
+                orig_headers,
+            )?
+        } else {
+            Self::encode_headers_with_lower_case(msg, dst, is_last, orig_len, wrote_len)?
+        };
+
+        ret.map(|()| encoder)
+    }
+
+    fn on_error(err: &crate::Error) -> Option<MessageHead<Self::Outgoing>> {
+        use crate::error::Kind;
+        let status = match *err.kind() {
+            Kind::Parse(Parse::Method)
+            | Kind::Parse(Parse::Header(_))
+            | Kind::Parse(Parse::Uri)
+            | Kind::Parse(Parse::Version) => StatusCode::BAD_REQUEST,
+            Kind::Parse(Parse::TooLarge) => StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE,
+            Kind::Parse(Parse::UriTooLong) => StatusCode::URI_TOO_LONG,
+            _ => return None,
+        };
+
+        debug!("sending automatic response ({}) for parse error", status);
+        let mut msg = MessageHead::default();
+        msg.subject = status;
+        Some(msg)
+    }
+
+    fn is_server() -> bool {
+        true
+    }
+
+    fn update_date() {
+        date::update();
+    }
+}
+
+#[cfg(feature = "server")]
+impl Server {
+    fn can_have_body(method: &Option<Method>, status: StatusCode) -> bool {
+        Server::can_chunked(method, status)
+    }
+
+    fn can_chunked(method: &Option<Method>, status: StatusCode) -> bool {
+        if method == &Some(Method::HEAD) || method == &Some(Method::CONNECT) && status.is_success()
+        {
+            false
+        } else if status.is_informational() {
+            false
+        } else {
+            match status {
+                StatusCode::NO_CONTENT | StatusCode::NOT_MODIFIED => false,
+                _ => true,
+            }
+        }
+    }
+
+    fn can_have_content_length(method: &Option<Method>, status: StatusCode) -> bool {
+        if status.is_informational() || method == &Some(Method::CONNECT) && status.is_success() {
+            false
+        } else {
+            match status {
+                StatusCode::NO_CONTENT | StatusCode::NOT_MODIFIED => false,
+                _ => true,
+            }
+        }
+    }
+
+    fn can_have_implicit_zero_content_length(method: &Option<Method>, status: StatusCode) -> bool {
+        Server::can_have_content_length(method, status) && method != &Some(Method::HEAD)
+    }
+
+    fn encode_headers_with_lower_case(
+        msg: Encode<'_, StatusCode>,
+        dst: &mut Vec<u8>,
+        is_last: bool,
+        orig_len: usize,
+        wrote_len: bool,
+    ) -> crate::Result<Encoder> {
+        struct LowercaseWriter;
+
+        impl HeaderNameWriter for LowercaseWriter {
+            #[inline]
+            fn write_full_header_line(
+                &mut self,
+                dst: &mut Vec<u8>,
+                line: &str,
+                _: (HeaderName, &str),
+            ) {
+                extend(dst, line.as_bytes())
+            }
+
+            #[inline]
+            fn write_header_name_with_colon(
+                &mut self,
+                dst: &mut Vec<u8>,
+                name_with_colon: &str,
+                _: HeaderName,
+            ) {
+                extend(dst, name_with_colon.as_bytes())
+            }
+
+            #[inline]
+            fn write_header_name(&mut self, dst: &mut Vec<u8>, name: &HeaderName) {
+                extend(dst, name.as_str().as_bytes())
+            }
+        }
+
+        Self::encode_headers(msg, dst, is_last, orig_len, wrote_len, LowercaseWriter)
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn encode_headers_with_original_case(
+        msg: Encode<'_, StatusCode>,
+        dst: &mut Vec<u8>,
+        is_last: bool,
+        orig_len: usize,
+        wrote_len: bool,
+        orig_headers: &HeaderCaseMap,
+    ) -> crate::Result<Encoder> {
+        struct OrigCaseWriter<'map> {
+            map: &'map HeaderCaseMap,
+            current: Option<(HeaderName, ValueIter<'map, Bytes>)>,
+            title_case_headers: bool,
+        }
+
+        impl HeaderNameWriter for OrigCaseWriter<'_> {
+            #[inline]
+            fn write_full_header_line(
+                &mut self,
+                dst: &mut Vec<u8>,
+                _: &str,
+                (name, rest): (HeaderName, &str),
+            ) {
+                self.write_header_name(dst, &name);
+                extend(dst, rest.as_bytes());
+            }
+
+            #[inline]
+            fn write_header_name_with_colon(
+                &mut self,
+                dst: &mut Vec<u8>,
+                _: &str,
+                name: HeaderName,
+            ) {
+                self.write_header_name(dst, &name);
+                extend(dst, b": ");
+            }
+
+            #[inline]
+            fn write_header_name(&mut self, dst: &mut Vec<u8>, name: &HeaderName) {
+                let Self {
+                    map,
+                    ref mut current,
+                    title_case_headers,
+                } = *self;
+                if current.as_ref().map_or(true, |(last, _)| last != name) {
+                    *current = None;
+                }
+                let (_, values) =
+                    current.get_or_insert_with(|| (name.clone(), map.get_all_internal(name)));
+
+                if let Some(orig_name) = values.next() {
+                    extend(dst, orig_name);
+                } else if title_case_headers {
+                    title_case(dst, name.as_str().as_bytes());
+                } else {
+                    extend(dst, name.as_str().as_bytes());
+                }
+            }
+        }
+
+        let header_name_writer = OrigCaseWriter {
+            map: orig_headers,
+            current: None,
+            title_case_headers: msg.title_case_headers,
+        };
+
+        Self::encode_headers(msg, dst, is_last, orig_len, wrote_len, header_name_writer)
+    }
+
+    #[inline]
+    fn encode_headers<W>(
+        msg: Encode<'_, StatusCode>,
+        dst: &mut Vec<u8>,
+        mut is_last: bool,
+        orig_len: usize,
+        mut wrote_len: bool,
+        mut header_name_writer: W,
+    ) -> crate::Result<Encoder>
+    where
+        W: HeaderNameWriter,
+    {
+        // In some error cases, we don't know about the invalid message until already
+        // pushing some bytes onto the `dst`. In those cases, we don't want to send
+        // the half-pushed message, so rewind to before.
+        let rewind = |dst: &mut Vec<u8>| {
+            dst.truncate(orig_len);
+        };
+
+        let mut encoder = Encoder::length(0);
+        let mut wrote_date = false;
+        let mut cur_name = None;
+        let mut is_name_written = false;
+        let mut must_write_chunked = false;
+        let mut prev_con_len = None;
+
+        macro_rules! handle_is_name_written {
+            () => {{
+                if is_name_written {
+                    // we need to clean up and write the newline
+                    debug_assert_ne!(
+                        &dst[dst.len() - 2..],
+                        b"\r\n",
+                        "previous header wrote newline but set is_name_written"
+                    );
+
+                    if must_write_chunked {
+                        extend(dst, b", chunked\r\n");
+                    } else {
+                        extend(dst, b"\r\n");
+                    }
+                }
+            }};
+        }
+
+        'headers: for (opt_name, value) in msg.head.headers.drain() {
+            if let Some(n) = opt_name {
+                cur_name = Some(n);
+                handle_is_name_written!();
+                is_name_written = false;
+            }
+            let name = cur_name.as_ref().expect("current header name");
+            match *name {
+                header::CONTENT_LENGTH => {
+                    if wrote_len && !is_name_written {
+                        warn!("unexpected content-length found, canceling");
+                        rewind(dst);
+                        return Err(crate::Error::new_user_header());
+                    }
+                    match msg.body {
+                        Some(BodyLength::Known(known_len)) => {
+                            // The HttpBody claims to know a length, and
+                            // the headers are already set. For performance
+                            // reasons, we are just going to trust that
+                            // the values match.
+                            //
+                            // In debug builds, we'll assert they are the
+                            // same to help developers find bugs.
+                            #[cfg(debug_assertions)]
+                            {
+                                if let Some(len) = headers::content_length_parse(&value) {
+                                    assert!(
+                                        len == known_len,
+                                        "payload claims content-length of {}, custom content-length header claims {}",
+                                        known_len,
+                                        len,
+                                    );
+                                }
+                            }
+
+                            if !is_name_written {
+                                encoder = Encoder::length(known_len);
+                                header_name_writer.write_header_name_with_colon(
+                                    dst,
+                                    "content-length: ",
+                                    header::CONTENT_LENGTH,
+                                );
+                                extend(dst, value.as_bytes());
+                                wrote_len = true;
+                                is_name_written = true;
+                            }
+                            continue 'headers;
+                        }
+                        Some(BodyLength::Unknown) => {
+                            // The HttpBody impl didn't know how long the
+                            // body is, but a length header was included.
+                            // We have to parse the value to return our
+                            // Encoder...
+
+                            if let Some(len) = headers::content_length_parse(&value) {
+                                if let Some(prev) = prev_con_len {
+                                    if prev != len {
+                                        warn!(
+                                            "multiple Content-Length values found: [{}, {}]",
+                                            prev, len
+                                        );
+                                        rewind(dst);
+                                        return Err(crate::Error::new_user_header());
+                                    }
+                                    debug_assert!(is_name_written);
+                                    continue 'headers;
+                                } else {
+                                    // we haven't written content-length yet!
+                                    encoder = Encoder::length(len);
+                                    header_name_writer.write_header_name_with_colon(
+                                        dst,
+                                        "content-length: ",
+                                        header::CONTENT_LENGTH,
+                                    );
+                                    extend(dst, value.as_bytes());
+                                    wrote_len = true;
+                                    is_name_written = true;
+                                    prev_con_len = Some(len);
+                                    continue 'headers;
+                                }
+                            } else {
+                                warn!("illegal Content-Length value: {:?}", value);
+                                rewind(dst);
+                                return Err(crate::Error::new_user_header());
+                            }
+                        }
+                        None => {
+                            // We have no body to actually send,
+                            // but the headers claim a content-length.
+                            // There's only 2 ways this makes sense:
+                            //
+                            // - The header says the length is `0`.
+                            // - This is a response to a `HEAD` request.
+                            if msg.req_method == &Some(Method::HEAD) {
+                                debug_assert_eq!(encoder, Encoder::length(0));
+                            } else {
+                                if value.as_bytes() != b"0" {
+                                    warn!(
+                                        "content-length value found, but empty body provided: {:?}",
+                                        value
+                                    );
+                                }
+                                continue 'headers;
+                            }
+                        }
+                    }
+                    wrote_len = true;
+                }
+                header::TRANSFER_ENCODING => {
+                    if wrote_len && !is_name_written {
+                        warn!("unexpected transfer-encoding found, canceling");
+                        rewind(dst);
+                        return Err(crate::Error::new_user_header());
+                    }
+                    // check that we actually can send a chunked body...
+                    if msg.head.version == Version::HTTP_10
+                        || !Server::can_chunked(msg.req_method, msg.head.subject)
+                    {
+                        continue;
+                    }
+                    wrote_len = true;
+                    // Must check each value, because `chunked` needs to be the
+                    // last encoding, or else we add it.
+                    must_write_chunked = !headers::is_chunked_(&value);
+
+                    if !is_name_written {
+                        encoder = Encoder::chunked();
+                        is_name_written = true;
+                        header_name_writer.write_header_name_with_colon(
+                            dst,
+                            "transfer-encoding: ",
+                            header::TRANSFER_ENCODING,
+                        );
+                        extend(dst, value.as_bytes());
+                    } else {
+                        extend(dst, b", ");
+                        extend(dst, value.as_bytes());
+                    }
+                    continue 'headers;
+                }
+                header::CONNECTION => {
+                    if !is_last && headers::connection_close(&value) {
+                        is_last = true;
+                    }
+                    if !is_name_written {
+                        is_name_written = true;
+                        header_name_writer.write_header_name_with_colon(
+                            dst,
+                            "connection: ",
+                            header::CONNECTION,
+                        );
+                        extend(dst, value.as_bytes());
+                    } else {
+                        extend(dst, b", ");
+                        extend(dst, value.as_bytes());
+                    }
+                    continue 'headers;
+                }
+                header::DATE => {
+                    wrote_date = true;
+                }
+                _ => (),
+            }
+            //TODO: this should perhaps instead combine them into
+            //single lines, as RFC7230 suggests is preferable.
+
+            // non-special write Name and Value
+            debug_assert!(
+                !is_name_written,
+                "{:?} set is_name_written and didn't continue loop",
+                name,
+            );
+            header_name_writer.write_header_name(dst, name);
+            extend(dst, b": ");
+            extend(dst, value.as_bytes());
+            extend(dst, b"\r\n");
+        }
+
+        handle_is_name_written!();
+
+        if !wrote_len {
+            encoder = match msg.body {
+                Some(BodyLength::Unknown) => {
+                    if msg.head.version == Version::HTTP_10
+                        || !Server::can_chunked(msg.req_method, msg.head.subject)
+                    {
+                        Encoder::close_delimited()
+                    } else {
+                        header_name_writer.write_full_header_line(
+                            dst,
+                            "transfer-encoding: chunked\r\n",
+                            (header::TRANSFER_ENCODING, ": chunked\r\n"),
+                        );
+                        Encoder::chunked()
+                    }
+                }
+                None | Some(BodyLength::Known(0)) => {
+                    if Server::can_have_implicit_zero_content_length(
+                        msg.req_method,
+                        msg.head.subject,
+                    ) {
+                        header_name_writer.write_full_header_line(
+                            dst,
+                            "content-length: 0\r\n",
+                            (header::CONTENT_LENGTH, ": 0\r\n"),
+                        )
+                    }
+                    Encoder::length(0)
+                }
+                Some(BodyLength::Known(len)) => {
+                    if !Server::can_have_content_length(msg.req_method, msg.head.subject) {
+                        Encoder::length(0)
+                    } else {
+                        header_name_writer.write_header_name_with_colon(
+                            dst,
+                            "content-length: ",
+                            header::CONTENT_LENGTH,
+                        );
+                        extend(dst, ::itoa::Buffer::new().format(len).as_bytes());
+                        extend(dst, b"\r\n");
+                        Encoder::length(len)
+                    }
+                }
+            };
+        }
+
+        if !Server::can_have_body(msg.req_method, msg.head.subject) {
+            trace!(
+                "server body forced to 0; method={:?}, status={:?}",
+                msg.req_method,
+                msg.head.subject
+            );
+            encoder = Encoder::length(0);
+        }
+
+        // cached date is much faster than formatting every request
+        if !wrote_date {
+            dst.reserve(date::DATE_VALUE_LENGTH + 8);
+            header_name_writer.write_header_name_with_colon(dst, "date: ", header::DATE);
+            date::extend(dst);
+            extend(dst, b"\r\n\r\n");
+        } else {
+            extend(dst, b"\r\n");
+        }
+
+        Ok(encoder.set_last(is_last))
+    }
+}
+
+#[cfg(feature = "server")]
+trait HeaderNameWriter {
+    fn write_full_header_line(
+        &mut self,
+        dst: &mut Vec<u8>,
+        line: &str,
+        name_value_pair: (HeaderName, &str),
+    );
+    fn write_header_name_with_colon(
+        &mut self,
+        dst: &mut Vec<u8>,
+        name_with_colon: &str,
+        name: HeaderName,
+    );
+    fn write_header_name(&mut self, dst: &mut Vec<u8>, name: &HeaderName);
+}
+
+#[cfg(feature = "client")]
+impl Http1Transaction for Client {
+    type Incoming = StatusCode;
+    type Outgoing = RequestLine;
+    const LOG: &'static str = "{role=client}";
+
+    fn parse(buf: &mut BytesMut, ctx: ParseContext<'_>) -> ParseResult<StatusCode> {
+        debug_assert!(!buf.is_empty(), "parse called with empty buf");
+
+        // Loop to skip information status code headers (100 Continue, etc).
+        loop {
+            // Unsafe: see comment in Server Http1Transaction, above.
+            let mut headers_indices: [MaybeUninit<HeaderIndices>; MAX_HEADERS] = unsafe {
+                // SAFETY: We can go safely from MaybeUninit array to array of MaybeUninit
+                MaybeUninit::uninit().assume_init()
+            };
+            let (len, status, reason, version, headers_len) = {
+                // SAFETY: We can go safely from MaybeUninit array to array of MaybeUninit
+                let mut headers: [MaybeUninit<httparse::Header<'_>>; MAX_HEADERS] =
+                    unsafe { MaybeUninit::uninit().assume_init() };
+                trace!(bytes = buf.len(), "Response.parse");
+                let mut res = httparse::Response::new(&mut []);
+                let bytes = buf.as_ref();
+                match ctx.h1_parser_config.parse_response_with_uninit_headers(
+                    &mut res,
+                    bytes,
+                    &mut headers,
+                ) {
+                    Ok(httparse::Status::Complete(len)) => {
+                        trace!("Response.parse Complete({})", len);
+                        let status = StatusCode::from_u16(res.code.unwrap())?;
+
+                        let reason = {
+                            let reason = res.reason.unwrap();
+                            // Only save the reason phrase if it isn't the canonical reason
+                            if Some(reason) != status.canonical_reason() {
+                                Some(Bytes::copy_from_slice(reason.as_bytes()))
+                            } else {
+                                None
+                            }
+                        };
+
+                        let version = if res.version.unwrap() == 1 {
+                            Version::HTTP_11
+                        } else {
+                            Version::HTTP_10
+                        };
+                        record_header_indices(bytes, &res.headers, &mut headers_indices)?;
+                        let headers_len = res.headers.len();
+                        (len, status, reason, version, headers_len)
+                    }
+                    Ok(httparse::Status::Partial) => return Ok(None),
+                    Err(httparse::Error::Version) if ctx.h09_responses => {
+                        trace!("Response.parse accepted HTTP/0.9 response");
+
+                        (0, StatusCode::OK, None, Version::HTTP_09, 0)
+                    }
+                    Err(e) => return Err(e.into()),
+                }
+            };
+
+            let mut slice = buf.split_to(len);
+
+            if ctx
+                .h1_parser_config
+                .obsolete_multiline_headers_in_responses_are_allowed()
+            {
+                for header in &headers_indices[..headers_len] {
+                    // SAFETY: array is valid up to `headers_len`
+                    let header = unsafe { &*header.as_ptr() };
+                    for b in &mut slice[header.value.0..header.value.1] {
+                        if *b == b'\r' || *b == b'\n' {
+                            *b = b' ';
+                        }
+                    }
+                }
+            }
+
+            let slice = slice.freeze();
+
+            let mut headers = ctx.cached_headers.take().unwrap_or_else(HeaderMap::new);
+
+            let mut keep_alive = version == Version::HTTP_11;
+
+            let mut header_case_map = if ctx.preserve_header_case {
+                Some(HeaderCaseMap::default())
+            } else {
+                None
+            };
+
+            #[cfg(feature = "ffi")]
+            let mut header_order = if ctx.preserve_header_order {
+                Some(OriginalHeaderOrder::default())
+            } else {
+                None
+            };
+
+            headers.reserve(headers_len);
+            for header in &headers_indices[..headers_len] {
+                // SAFETY: array is valid up to `headers_len`
+                let header = unsafe { &*header.as_ptr() };
+                let name = header_name!(&slice[header.name.0..header.name.1]);
+                let value = header_value!(slice.slice(header.value.0..header.value.1));
+
+                if let header::CONNECTION = name {
+                    // keep_alive was previously set to default for Version
+                    if keep_alive {
+                        // HTTP/1.1
+                        keep_alive = !headers::connection_close(&value);
+                    } else {
+                        // HTTP/1.0
+                        keep_alive = headers::connection_keep_alive(&value);
+                    }
+                }
+
+                if let Some(ref mut header_case_map) = header_case_map {
+                    header_case_map.append(&name, slice.slice(header.name.0..header.name.1));
+                }
+
+                #[cfg(feature = "ffi")]
+                if let Some(ref mut header_order) = header_order {
+                    header_order.append(&name);
+                }
+
+                headers.append(name, value);
+            }
+
+            let mut extensions = http::Extensions::default();
+
+            if let Some(header_case_map) = header_case_map {
+                extensions.insert(header_case_map);
+            }
+
+            #[cfg(feature = "ffi")]
+            if let Some(header_order) = header_order {
+                extensions.insert(header_order);
+            }
+
+            if let Some(reason) = reason {
+                // Safety: httparse ensures that only valid reason phrase bytes are present in this
+                // field.
+                let reason = unsafe { crate::ext::ReasonPhrase::from_bytes_unchecked(reason) };
+                extensions.insert(reason);
+            }
+
+            #[cfg(feature = "ffi")]
+            if ctx.raw_headers {
+                extensions.insert(crate::ffi::RawHeaders(crate::ffi::hyper_buf(slice)));
+            }
+
+            let head = MessageHead {
+                version,
+                subject: status,
+                headers,
+                extensions,
+            };
+            if let Some((decode, is_upgrade)) = Client::decoder(&head, ctx.req_method)? {
+                return Ok(Some(ParsedMessage {
+                    head,
+                    decode,
+                    expect_continue: false,
+                    // a client upgrade means the connection can't be used
+                    // again, as it is definitely upgrading.
+                    keep_alive: keep_alive && !is_upgrade,
+                    wants_upgrade: is_upgrade,
+                }));
+            }
+
+            #[cfg(feature = "ffi")]
+            if head.subject.is_informational() {
+                if let Some(callback) = ctx.on_informational {
+                    callback.call(head.into_response(crate::Body::empty()));
+                }
+            }
+
+            // Parsing a 1xx response could have consumed the buffer, check if
+            // it is empty now...
+            if buf.is_empty() {
+                return Ok(None);
+            }
+        }
+    }
+
+    fn encode(msg: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> crate::Result<Encoder> {
+        trace!(
+            "Client::encode method={:?}, body={:?}",
+            msg.head.subject.0,
+            msg.body
+        );
+
+        *msg.req_method = Some(msg.head.subject.0.clone());
+
+        let body = Client::set_length(msg.head, msg.body);
+
+        let init_cap = 30 + msg.head.headers.len() * AVERAGE_HEADER_SIZE;
+        dst.reserve(init_cap);
+
+        extend(dst, msg.head.subject.0.as_str().as_bytes());
+        extend(dst, b" ");
+        //TODO: add API to http::Uri to encode without std::fmt
+        let _ = write!(FastWrite(dst), "{} ", msg.head.subject.1);
+
+        match msg.head.version {
+            Version::HTTP_10 => extend(dst, b"HTTP/1.0"),
+            Version::HTTP_11 => extend(dst, b"HTTP/1.1"),
+            Version::HTTP_2 => {
+                debug!("request with HTTP2 version coerced to HTTP/1.1");
+                extend(dst, b"HTTP/1.1");
+            }
+            other => panic!("unexpected request version: {:?}", other),
+        }
+        extend(dst, b"\r\n");
+
+        if let Some(orig_headers) = msg.head.extensions.get::<HeaderCaseMap>() {
+            write_headers_original_case(
+                &msg.head.headers,
+                orig_headers,
+                dst,
+                msg.title_case_headers,
+            );
+        } else if msg.title_case_headers {
+            write_headers_title_case(&msg.head.headers, dst);
+        } else {
+            write_headers(&msg.head.headers, dst);
+        }
+
+        extend(dst, b"\r\n");
+        msg.head.headers.clear(); //TODO: remove when switching to drain()
+
+        Ok(body)
+    }
+
+    fn on_error(_err: &crate::Error) -> Option<MessageHead<Self::Outgoing>> {
+        // we can't tell the server about any errors it creates
+        None
+    }
+
+    fn is_client() -> bool {
+        true
+    }
+}
+
+#[cfg(feature = "client")]
+impl Client {
+    /// Returns Some(length, wants_upgrade) if successful.
+    ///
+    /// Returns None if this message head should be skipped (like a 100 status).
+    fn decoder(
+        inc: &MessageHead<StatusCode>,
+        method: &mut Option<Method>,
+    ) -> Result<Option<(DecodedLength, bool)>, Parse> {
+        // According to https://tools.ietf.org/html/rfc7230#section-3.3.3
+        // 1. HEAD responses, and Status 1xx, 204, and 304 cannot have a body.
+        // 2. Status 2xx to a CONNECT cannot have a body.
+        // 3. Transfer-Encoding: chunked has a chunked body.
+        // 4. If multiple differing Content-Length headers or invalid, close connection.
+        // 5. Content-Length header has a sized body.
+        // 6. (irrelevant to Response)
+        // 7. Read till EOF.
+
+        match inc.subject.as_u16() {
+            101 => {
+                return Ok(Some((DecodedLength::ZERO, true)));
+            }
+            100 | 102..=199 => {
+                trace!("ignoring informational response: {}", inc.subject.as_u16());
+                return Ok(None);
+            }
+            204 | 304 => return Ok(Some((DecodedLength::ZERO, false))),
+            _ => (),
+        }
+        match *method {
+            Some(Method::HEAD) => {
+                return Ok(Some((DecodedLength::ZERO, false)));
+            }
+            Some(Method::CONNECT) => {
+                if let 200..=299 = inc.subject.as_u16() {
+                    return Ok(Some((DecodedLength::ZERO, true)));
+                }
+            }
+            Some(_) => {}
+            None => {
+                trace!("Client::decoder is missing the Method");
+            }
+        }
+
+        if inc.headers.contains_key(header::TRANSFER_ENCODING) {
+            // https://tools.ietf.org/html/rfc7230#section-3.3.3
+            // If Transfer-Encoding header is present, and 'chunked' is
+            // not the final encoding, and this is a Request, then it is
+            // malformed. A server should respond with 400 Bad Request.
+            if inc.version == Version::HTTP_10 {
+                debug!("HTTP/1.0 cannot have Transfer-Encoding header");
+                Err(Parse::transfer_encoding_unexpected())
+            } else if headers::transfer_encoding_is_chunked(&inc.headers) {
+                Ok(Some((DecodedLength::CHUNKED, false)))
+            } else {
+                trace!("not chunked, read till eof");
+                Ok(Some((DecodedLength::CLOSE_DELIMITED, false)))
+            }
+        } else if let Some(len) = headers::content_length_parse_all(&inc.headers) {
+            Ok(Some((DecodedLength::checked_new(len)?, false)))
+        } else if inc.headers.contains_key(header::CONTENT_LENGTH) {
+            debug!("illegal Content-Length header");
+            Err(Parse::content_length_invalid())
+        } else {
+            trace!("neither Transfer-Encoding nor Content-Length");
+            Ok(Some((DecodedLength::CLOSE_DELIMITED, false)))
+        }
+    }
+    fn set_length(head: &mut RequestHead, body: Option<BodyLength>) -> Encoder {
+        let body = if let Some(body) = body {
+            body
+        } else {
+            head.headers.remove(header::TRANSFER_ENCODING);
+            return Encoder::length(0);
+        };
+
+        // HTTP/1.0 doesn't know about chunked
+        let can_chunked = head.version == Version::HTTP_11;
+        let headers = &mut head.headers;
+
+        // If the user already set specific headers, we should respect them, regardless
+        // of what the HttpBody knows about itself. They set them for a reason.
+
+        // Because of the borrow checker, we can't check the for an existing
+        // Content-Length header while holding an `Entry` for the Transfer-Encoding
+        // header, so unfortunately, we must do the check here, first.
+
+        let existing_con_len = headers::content_length_parse_all(headers);
+        let mut should_remove_con_len = false;
+
+        if !can_chunked {
+            // Chunked isn't legal, so if it is set, we need to remove it.
+            if headers.remove(header::TRANSFER_ENCODING).is_some() {
+                trace!("removing illegal transfer-encoding header");
+            }
+
+            return if let Some(len) = existing_con_len {
+                Encoder::length(len)
+            } else if let BodyLength::Known(len) = body {
+                set_content_length(headers, len)
+            } else {
+                // HTTP/1.0 client requests without a content-length
+                // cannot have any body at all.
+                Encoder::length(0)
+            };
+        }
+
+        // If the user set a transfer-encoding, respect that. Let's just
+        // make sure `chunked` is the final encoding.
+        let encoder = match headers.entry(header::TRANSFER_ENCODING) {
+            Entry::Occupied(te) => {
+                should_remove_con_len = true;
+                if headers::is_chunked(te.iter()) {
+                    Some(Encoder::chunked())
+                } else {
+                    warn!("user provided transfer-encoding does not end in 'chunked'");
+
+                    // There's a Transfer-Encoding, but it doesn't end in 'chunked'!
+                    // An example that could trigger this:
+                    //
+                    //     Transfer-Encoding: gzip
+                    //
+                    // This can be bad, depending on if this is a request or a
+                    // response.
+                    //
+                    // - A request is illegal if there is a `Transfer-Encoding`
+                    //   but it doesn't end in `chunked`.
+                    // - A response that has `Transfer-Encoding` but doesn't
+                    //   end in `chunked` isn't illegal, it just forces this
+                    //   to be close-delimited.
+                    //
+                    // We can try to repair this, by adding `chunked` ourselves.
+
+                    headers::add_chunked(te);
+                    Some(Encoder::chunked())
+                }
+            }
+            Entry::Vacant(te) => {
+                if let Some(len) = existing_con_len {
+                    Some(Encoder::length(len))
+                } else if let BodyLength::Unknown = body {
+                    // GET, HEAD, and CONNECT almost never have bodies.
+                    //
+                    // So instead of sending a "chunked" body with a 0-chunk,
+                    // assume no body here. If you *must* send a body,
+                    // set the headers explicitly.
+                    match head.subject.0 {
+                        Method::GET | Method::HEAD | Method::CONNECT => Some(Encoder::length(0)),
+                        _ => {
+                            te.insert(HeaderValue::from_static("chunked"));
+                            Some(Encoder::chunked())
+                        }
+                    }
+                } else {
+                    None
+                }
+            }
+        };
+
+        // This is because we need a second mutable borrow to remove
+        // content-length header.
+        if let Some(encoder) = encoder {
+            if should_remove_con_len && existing_con_len.is_some() {
+                headers.remove(header::CONTENT_LENGTH);
+            }
+            return encoder;
+        }
+
+        // User didn't set transfer-encoding, AND we know body length,
+        // so we can just set the Content-Length automatically.
+
+        let len = if let BodyLength::Known(len) = body {
+            len
+        } else {
+            unreachable!("BodyLength::Unknown would set chunked");
+        };
+
+        set_content_length(headers, len)
+    }
+}
+
+fn set_content_length(headers: &mut HeaderMap, len: u64) -> Encoder {
+    // At this point, there should not be a valid Content-Length
+    // header. However, since we'll be indexing in anyways, we can
+    // warn the user if there was an existing illegal header.
+    //
+    // Or at least, we can in theory. It's actually a little bit slower,
+    // so perhaps only do that while the user is developing/testing.
+
+    if cfg!(debug_assertions) {
+        match headers.entry(header::CONTENT_LENGTH) {
+            Entry::Occupied(mut cl) => {
+                // Internal sanity check, we should have already determined
+                // that the header was illegal before calling this function.
+                debug_assert!(headers::content_length_parse_all_values(cl.iter()).is_none());
+                // Uh oh, the user set `Content-Length` headers, but set bad ones.
+                // This would be an illegal message anyways, so let's try to repair
+                // with our known good length.
+                error!("user provided content-length header was invalid");
+
+                cl.insert(HeaderValue::from(len));
+                Encoder::length(len)
+            }
+            Entry::Vacant(cl) => {
+                cl.insert(HeaderValue::from(len));
+                Encoder::length(len)
+            }
+        }
+    } else {
+        headers.insert(header::CONTENT_LENGTH, HeaderValue::from(len));
+        Encoder::length(len)
+    }
+}
+
+#[derive(Clone, Copy)]
+struct HeaderIndices {
+    name: (usize, usize),
+    value: (usize, usize),
+}
+
+fn record_header_indices(
+    bytes: &[u8],
+    headers: &[httparse::Header<'_>],
+    indices: &mut [MaybeUninit<HeaderIndices>],
+) -> Result<(), crate::error::Parse> {
+    let bytes_ptr = bytes.as_ptr() as usize;
+
+    for (header, indices) in headers.iter().zip(indices.iter_mut()) {
+        if header.name.len() >= (1 << 16) {
+            debug!("header name larger than 64kb: {:?}", header.name);
+            return Err(crate::error::Parse::TooLarge);
+        }
+        let name_start = header.name.as_ptr() as usize - bytes_ptr;
+        let name_end = name_start + header.name.len();
+        let value_start = header.value.as_ptr() as usize - bytes_ptr;
+        let value_end = value_start + header.value.len();
+
+        // FIXME(maybe_uninit_extra)
+        // FIXME(addr_of)
+        // Currently we don't have `ptr::addr_of_mut` in stable rust or
+        // MaybeUninit::write, so this is some way of assigning into a MaybeUninit
+        // safely
+        let new_header_indices = HeaderIndices {
+            name: (name_start, name_end),
+            value: (value_start, value_end),
+        };
+        *indices = MaybeUninit::new(new_header_indices);
+    }
+
+    Ok(())
+}
+
+// Write header names as title case. The header name is assumed to be ASCII.
+fn title_case(dst: &mut Vec<u8>, name: &[u8]) {
+    dst.reserve(name.len());
+
+    // Ensure first character is uppercased
+    let mut prev = b'-';
+    for &(mut c) in name {
+        if prev == b'-' {
+            c.make_ascii_uppercase();
+        }
+        dst.push(c);
+        prev = c;
+    }
+}
+
+fn write_headers_title_case(headers: &HeaderMap, dst: &mut Vec<u8>) {
+    for (name, value) in headers {
+        title_case(dst, name.as_str().as_bytes());
+        extend(dst, b": ");
+        extend(dst, value.as_bytes());
+        extend(dst, b"\r\n");
+    }
+}
+
+fn write_headers(headers: &HeaderMap, dst: &mut Vec<u8>) {
+    for (name, value) in headers {
+        extend(dst, name.as_str().as_bytes());
+        extend(dst, b": ");
+        extend(dst, value.as_bytes());
+        extend(dst, b"\r\n");
+    }
+}
+
+#[cold]
+fn write_headers_original_case(
+    headers: &HeaderMap,
+    orig_case: &HeaderCaseMap,
+    dst: &mut Vec<u8>,
+    title_case_headers: bool,
+) {
+    // For each header name/value pair, there may be a value in the casemap
+    // that corresponds to the HeaderValue. So, we iterator all the keys,
+    // and for each one, try to pair the originally cased name with the value.
+    //
+    // TODO: consider adding http::HeaderMap::entries() iterator
+    for name in headers.keys() {
+        let mut names = orig_case.get_all(name);
+
+        for value in headers.get_all(name) {
+            if let Some(orig_name) = names.next() {
+                extend(dst, orig_name.as_ref());
+            } else if title_case_headers {
+                title_case(dst, name.as_str().as_bytes());
+            } else {
+                extend(dst, name.as_str().as_bytes());
+            }
+
+            // Wanted for curl test cases that send `X-Custom-Header:\r\n`
+            if value.is_empty() {
+                extend(dst, b":\r\n");
+            } else {
+                extend(dst, b": ");
+                extend(dst, value.as_bytes());
+                extend(dst, b"\r\n");
+            }
+        }
+    }
+}
+
+struct FastWrite<'a>(&'a mut Vec<u8>);
+
+impl<'a> fmt::Write for FastWrite<'a> {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        extend(self.0, s.as_bytes());
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
+        fmt::write(self, args)
+    }
+}
+
+#[inline]
+fn extend(dst: &mut Vec<u8>, data: &[u8]) {
+    dst.extend_from_slice(data);
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::BytesMut;
+
+    use super::*;
+
+    #[test]
+    fn test_parse_request() {
+        let _ = pretty_env_logger::try_init();
+        let mut raw = BytesMut::from("GET /echo HTTP/1.1\r\nHost: hyper.rs\r\n\r\n");
+        let mut method = None;
+        let msg = Server::parse(
+            &mut raw,
+            ParseContext {
+                cached_headers: &mut None,
+                req_method: &mut method,
+                h1_parser_config: Default::default(),
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout: None,
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout_fut: &mut None,
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout_running: &mut false,
+                preserve_header_case: false,
+                #[cfg(feature = "ffi")]
+                preserve_header_order: false,
+                h09_responses: false,
+                #[cfg(feature = "ffi")]
+                on_informational: &mut None,
+                #[cfg(feature = "ffi")]
+                raw_headers: false,
+            },
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(raw.len(), 0);
+        assert_eq!(msg.head.subject.0, crate::Method::GET);
+        assert_eq!(msg.head.subject.1, "/echo");
+        assert_eq!(msg.head.version, crate::Version::HTTP_11);
+        assert_eq!(msg.head.headers.len(), 1);
+        assert_eq!(msg.head.headers["Host"], "hyper.rs");
+        assert_eq!(method, Some(crate::Method::GET));
+    }
+
+    #[test]
+    fn test_parse_response() {
+        let _ = pretty_env_logger::try_init();
+        let mut raw = BytesMut::from("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
+        let ctx = ParseContext {
+            cached_headers: &mut None,
+            req_method: &mut Some(crate::Method::GET),
+            h1_parser_config: Default::default(),
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout: None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_fut: &mut None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_running: &mut false,
+            preserve_header_case: false,
+            #[cfg(feature = "ffi")]
+            preserve_header_order: false,
+            h09_responses: false,
+            #[cfg(feature = "ffi")]
+            on_informational: &mut None,
+            #[cfg(feature = "ffi")]
+            raw_headers: false,
+        };
+        let msg = Client::parse(&mut raw, ctx).unwrap().unwrap();
+        assert_eq!(raw.len(), 0);
+        assert_eq!(msg.head.subject, crate::StatusCode::OK);
+        assert_eq!(msg.head.version, crate::Version::HTTP_11);
+        assert_eq!(msg.head.headers.len(), 1);
+        assert_eq!(msg.head.headers["Content-Length"], "0");
+    }
+
+    #[test]
+    fn test_parse_request_errors() {
+        let mut raw = BytesMut::from("GET htt:p// HTTP/1.1\r\nHost: hyper.rs\r\n\r\n");
+        let ctx = ParseContext {
+            cached_headers: &mut None,
+            req_method: &mut None,
+            h1_parser_config: Default::default(),
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout: None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_fut: &mut None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_running: &mut false,
+            preserve_header_case: false,
+            #[cfg(feature = "ffi")]
+            preserve_header_order: false,
+            h09_responses: false,
+            #[cfg(feature = "ffi")]
+            on_informational: &mut None,
+            #[cfg(feature = "ffi")]
+            raw_headers: false,
+        };
+        Server::parse(&mut raw, ctx).unwrap_err();
+    }
+
+    const H09_RESPONSE: &'static str = "Baguettes are super delicious, don't you agree?";
+
+    #[test]
+    fn test_parse_response_h09_allowed() {
+        let _ = pretty_env_logger::try_init();
+        let mut raw = BytesMut::from(H09_RESPONSE);
+        let ctx = ParseContext {
+            cached_headers: &mut None,
+            req_method: &mut Some(crate::Method::GET),
+            h1_parser_config: Default::default(),
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout: None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_fut: &mut None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_running: &mut false,
+            preserve_header_case: false,
+            #[cfg(feature = "ffi")]
+            preserve_header_order: false,
+            h09_responses: true,
+            #[cfg(feature = "ffi")]
+            on_informational: &mut None,
+            #[cfg(feature = "ffi")]
+            raw_headers: false,
+        };
+        let msg = Client::parse(&mut raw, ctx).unwrap().unwrap();
+        assert_eq!(raw, H09_RESPONSE);
+        assert_eq!(msg.head.subject, crate::StatusCode::OK);
+        assert_eq!(msg.head.version, crate::Version::HTTP_09);
+        assert_eq!(msg.head.headers.len(), 0);
+    }
+
+    #[test]
+    fn test_parse_response_h09_rejected() {
+        let _ = pretty_env_logger::try_init();
+        let mut raw = BytesMut::from(H09_RESPONSE);
+        let ctx = ParseContext {
+            cached_headers: &mut None,
+            req_method: &mut Some(crate::Method::GET),
+            h1_parser_config: Default::default(),
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout: None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_fut: &mut None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_running: &mut false,
+            preserve_header_case: false,
+            #[cfg(feature = "ffi")]
+            preserve_header_order: false,
+            h09_responses: false,
+            #[cfg(feature = "ffi")]
+            on_informational: &mut None,
+            #[cfg(feature = "ffi")]
+            raw_headers: false,
+        };
+        Client::parse(&mut raw, ctx).unwrap_err();
+        assert_eq!(raw, H09_RESPONSE);
+    }
+
+    const RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON: &'static str =
+        "HTTP/1.1 200 OK\r\nAccess-Control-Allow-Credentials : true\r\n\r\n";
+
+    #[test]
+    fn test_parse_allow_response_with_spaces_before_colons() {
+        use httparse::ParserConfig;
+
+        let _ = pretty_env_logger::try_init();
+        let mut raw = BytesMut::from(RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON);
+        let mut h1_parser_config = ParserConfig::default();
+        h1_parser_config.allow_spaces_after_header_name_in_responses(true);
+        let ctx = ParseContext {
+            cached_headers: &mut None,
+            req_method: &mut Some(crate::Method::GET),
+            h1_parser_config,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout: None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_fut: &mut None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_running: &mut false,
+            preserve_header_case: false,
+            #[cfg(feature = "ffi")]
+            preserve_header_order: false,
+            h09_responses: false,
+            #[cfg(feature = "ffi")]
+            on_informational: &mut None,
+            #[cfg(feature = "ffi")]
+            raw_headers: false,
+        };
+        let msg = Client::parse(&mut raw, ctx).unwrap().unwrap();
+        assert_eq!(raw.len(), 0);
+        assert_eq!(msg.head.subject, crate::StatusCode::OK);
+        assert_eq!(msg.head.version, crate::Version::HTTP_11);
+        assert_eq!(msg.head.headers.len(), 1);
+        assert_eq!(msg.head.headers["Access-Control-Allow-Credentials"], "true");
+    }
+
+    #[test]
+    fn test_parse_reject_response_with_spaces_before_colons() {
+        let _ = pretty_env_logger::try_init();
+        let mut raw = BytesMut::from(RESPONSE_WITH_WHITESPACE_BETWEEN_HEADER_NAME_AND_COLON);
+        let ctx = ParseContext {
+            cached_headers: &mut None,
+            req_method: &mut Some(crate::Method::GET),
+            h1_parser_config: Default::default(),
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout: None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_fut: &mut None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_running: &mut false,
+            preserve_header_case: false,
+            #[cfg(feature = "ffi")]
+            preserve_header_order: false,
+            h09_responses: false,
+            #[cfg(feature = "ffi")]
+            on_informational: &mut None,
+            #[cfg(feature = "ffi")]
+            raw_headers: false,
+        };
+        Client::parse(&mut raw, ctx).unwrap_err();
+    }
+
+    #[test]
+    fn test_parse_preserve_header_case_in_request() {
+        let mut raw =
+            BytesMut::from("GET / HTTP/1.1\r\nHost: hyper.rs\r\nX-BREAD: baguette\r\n\r\n");
+        let ctx = ParseContext {
+            cached_headers: &mut None,
+            req_method: &mut None,
+            h1_parser_config: Default::default(),
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout: None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_fut: &mut None,
+            #[cfg(feature = "runtime")]
+            h1_header_read_timeout_running: &mut false,
+            preserve_header_case: true,
+            #[cfg(feature = "ffi")]
+            preserve_header_order: false,
+            h09_responses: false,
+            #[cfg(feature = "ffi")]
+            on_informational: &mut None,
+            #[cfg(feature = "ffi")]
+            raw_headers: false,
+        };
+        let parsed_message = Server::parse(&mut raw, ctx).unwrap().unwrap();
+        let orig_headers = parsed_message
+            .head
+            .extensions
+            .get::<HeaderCaseMap>()
+            .unwrap();
+        assert_eq!(
+            orig_headers
+                .get_all_internal(&HeaderName::from_static("host"))
+                .into_iter()
+                .collect::<Vec<_>>(),
+            vec![&Bytes::from("Host")]
+        );
+        assert_eq!(
+            orig_headers
+                .get_all_internal(&HeaderName::from_static("x-bread"))
+                .into_iter()
+                .collect::<Vec<_>>(),
+            vec![&Bytes::from("X-BREAD")]
+        );
+    }
+
+    #[test]
+    fn test_decoder_request() {
+        fn parse(s: &str) -> ParsedMessage<RequestLine> {
+            let mut bytes = BytesMut::from(s);
+            Server::parse(
+                &mut bytes,
+                ParseContext {
+                    cached_headers: &mut None,
+                    req_method: &mut None,
+                    h1_parser_config: Default::default(),
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout: None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_fut: &mut None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_running: &mut false,
+                    preserve_header_case: false,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: false,
+                    h09_responses: false,
+                    #[cfg(feature = "ffi")]
+                    on_informational: &mut None,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: false,
+                },
+            )
+            .expect("parse ok")
+            .expect("parse complete")
+        }
+
+        fn parse_err(s: &str, comment: &str) -> crate::error::Parse {
+            let mut bytes = BytesMut::from(s);
+            Server::parse(
+                &mut bytes,
+                ParseContext {
+                    cached_headers: &mut None,
+                    req_method: &mut None,
+                    h1_parser_config: Default::default(),
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout: None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_fut: &mut None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_running: &mut false,
+                    preserve_header_case: false,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: false,
+                    h09_responses: false,
+                    #[cfg(feature = "ffi")]
+                    on_informational: &mut None,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: false,
+                },
+            )
+            .expect_err(comment)
+        }
+
+        // no length or transfer-encoding means 0-length body
+        assert_eq!(
+            parse(
+                "\
+                 GET / HTTP/1.1\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::ZERO
+        );
+
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::ZERO
+        );
+
+        // transfer-encoding: chunked
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 transfer-encoding: chunked\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 transfer-encoding: gzip, chunked\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 transfer-encoding: gzip\r\n\
+                 transfer-encoding: chunked\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        // content-length
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 content-length: 10\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::new(10)
+        );
+
+        // transfer-encoding and content-length = chunked
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 content-length: 10\r\n\
+                 transfer-encoding: chunked\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 transfer-encoding: chunked\r\n\
+                 content-length: 10\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 transfer-encoding: gzip\r\n\
+                 content-length: 10\r\n\
+                 transfer-encoding: chunked\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        // multiple content-lengths of same value are fine
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.1\r\n\
+                 content-length: 10\r\n\
+                 content-length: 10\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::new(10)
+        );
+
+        // multiple content-lengths with different values is an error
+        parse_err(
+            "\
+             POST / HTTP/1.1\r\n\
+             content-length: 10\r\n\
+             content-length: 11\r\n\
+             \r\n\
+             ",
+            "multiple content-lengths",
+        );
+
+        // content-length with prefix is not allowed
+        parse_err(
+            "\
+             POST / HTTP/1.1\r\n\
+             content-length: +10\r\n\
+             \r\n\
+             ",
+            "prefixed content-length",
+        );
+
+        // transfer-encoding that isn't chunked is an error
+        parse_err(
+            "\
+             POST / HTTP/1.1\r\n\
+             transfer-encoding: gzip\r\n\
+             \r\n\
+             ",
+            "transfer-encoding but not chunked",
+        );
+
+        parse_err(
+            "\
+             POST / HTTP/1.1\r\n\
+             transfer-encoding: chunked, gzip\r\n\
+             \r\n\
+             ",
+            "transfer-encoding doesn't end in chunked",
+        );
+
+        parse_err(
+            "\
+             POST / HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\
+             transfer-encoding: afterlol\r\n\
+             \r\n\
+             ",
+            "transfer-encoding multiple lines doesn't end in chunked",
+        );
+
+        // http/1.0
+
+        assert_eq!(
+            parse(
+                "\
+                 POST / HTTP/1.0\r\n\
+                 content-length: 10\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::new(10)
+        );
+
+        // 1.0 doesn't understand chunked, so its an error
+        parse_err(
+            "\
+             POST / HTTP/1.0\r\n\
+             transfer-encoding: chunked\r\n\
+             \r\n\
+             ",
+            "1.0 chunked",
+        );
+    }
+
+    #[test]
+    fn test_decoder_response() {
+        fn parse(s: &str) -> ParsedMessage<StatusCode> {
+            parse_with_method(s, Method::GET)
+        }
+
+        fn parse_ignores(s: &str) {
+            let mut bytes = BytesMut::from(s);
+            assert!(Client::parse(
+                &mut bytes,
+                ParseContext {
+                    cached_headers: &mut None,
+                    req_method: &mut Some(Method::GET),
+                    h1_parser_config: Default::default(),
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout: None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_fut: &mut None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_running: &mut false,
+                    preserve_header_case: false,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: false,
+                    h09_responses: false,
+                    #[cfg(feature = "ffi")]
+                    on_informational: &mut None,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: false,
+                }
+            )
+            .expect("parse ok")
+            .is_none())
+        }
+
+        fn parse_with_method(s: &str, m: Method) -> ParsedMessage<StatusCode> {
+            let mut bytes = BytesMut::from(s);
+            Client::parse(
+                &mut bytes,
+                ParseContext {
+                    cached_headers: &mut None,
+                    req_method: &mut Some(m),
+                    h1_parser_config: Default::default(),
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout: None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_fut: &mut None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_running: &mut false,
+                    preserve_header_case: false,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: false,
+                    h09_responses: false,
+                    #[cfg(feature = "ffi")]
+                    on_informational: &mut None,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: false,
+                },
+            )
+            .expect("parse ok")
+            .expect("parse complete")
+        }
+
+        fn parse_err(s: &str) -> crate::error::Parse {
+            let mut bytes = BytesMut::from(s);
+            Client::parse(
+                &mut bytes,
+                ParseContext {
+                    cached_headers: &mut None,
+                    req_method: &mut Some(Method::GET),
+                    h1_parser_config: Default::default(),
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout: None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_fut: &mut None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_running: &mut false,
+                    preserve_header_case: false,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: false,
+                    h09_responses: false,
+                    #[cfg(feature = "ffi")]
+                    on_informational: &mut None,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: false,
+                },
+            )
+            .expect_err("parse should err")
+        }
+
+        // no content-length or transfer-encoding means close-delimited
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CLOSE_DELIMITED
+        );
+
+        // 204 and 304 never have a body
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 204 No Content\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::ZERO
+        );
+
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 304 Not Modified\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::ZERO
+        );
+
+        // content-length
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 content-length: 8\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::new(8)
+        );
+
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 content-length: 8\r\n\
+                 content-length: 8\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::new(8)
+        );
+
+        parse_err(
+            "\
+             HTTP/1.1 200 OK\r\n\
+             content-length: 8\r\n\
+             content-length: 9\r\n\
+             \r\n\
+             ",
+        );
+
+        parse_err(
+            "\
+             HTTP/1.1 200 OK\r\n\
+             content-length: +8\r\n\
+             \r\n\
+             ",
+        );
+
+        // transfer-encoding: chunked
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 transfer-encoding: chunked\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        // transfer-encoding not-chunked is close-delimited
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 transfer-encoding: yolo\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CLOSE_DELIMITED
+        );
+
+        // transfer-encoding and content-length = chunked
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 content-length: 10\r\n\
+                 transfer-encoding: chunked\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CHUNKED
+        );
+
+        // HEAD can have content-length, but not body
+        assert_eq!(
+            parse_with_method(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 content-length: 8\r\n\
+                 \r\n\
+                 ",
+                Method::HEAD
+            )
+            .decode,
+            DecodedLength::ZERO
+        );
+
+        // CONNECT with 200 never has body
+        {
+            let msg = parse_with_method(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 \r\n\
+                 ",
+                Method::CONNECT,
+            );
+            assert_eq!(msg.decode, DecodedLength::ZERO);
+            assert!(!msg.keep_alive, "should be upgrade");
+            assert!(msg.wants_upgrade, "should be upgrade");
+        }
+
+        // CONNECT receiving non 200 can have a body
+        assert_eq!(
+            parse_with_method(
+                "\
+                 HTTP/1.1 400 Bad Request\r\n\
+                 \r\n\
+                 ",
+                Method::CONNECT
+            )
+            .decode,
+            DecodedLength::CLOSE_DELIMITED
+        );
+
+        // 1xx status codes
+        parse_ignores(
+            "\
+             HTTP/1.1 100 Continue\r\n\
+             \r\n\
+             ",
+        );
+
+        parse_ignores(
+            "\
+             HTTP/1.1 103 Early Hints\r\n\
+             \r\n\
+             ",
+        );
+
+        // 101 upgrade not supported yet
+        {
+            let msg = parse(
+                "\
+                 HTTP/1.1 101 Switching Protocols\r\n\
+                 \r\n\
+                 ",
+            );
+            assert_eq!(msg.decode, DecodedLength::ZERO);
+            assert!(!msg.keep_alive, "should be last");
+            assert!(msg.wants_upgrade, "should be upgrade");
+        }
+
+        // http/1.0
+        assert_eq!(
+            parse(
+                "\
+                 HTTP/1.0 200 OK\r\n\
+                 \r\n\
+                 "
+            )
+            .decode,
+            DecodedLength::CLOSE_DELIMITED
+        );
+
+        // 1.0 doesn't understand chunked
+        parse_err(
+            "\
+             HTTP/1.0 200 OK\r\n\
+             transfer-encoding: chunked\r\n\
+             \r\n\
+             ",
+        );
+
+        // keep-alive
+        assert!(
+            parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 content-length: 0\r\n\
+                 \r\n\
+                 "
+            )
+            .keep_alive,
+            "HTTP/1.1 keep-alive is default"
+        );
+
+        assert!(
+            !parse(
+                "\
+                 HTTP/1.1 200 OK\r\n\
+                 content-length: 0\r\n\
+                 connection: foo, close, bar\r\n\
+                 \r\n\
+                 "
+            )
+            .keep_alive,
+            "connection close is always close"
+        );
+
+        assert!(
+            !parse(
+                "\
+                 HTTP/1.0 200 OK\r\n\
+                 content-length: 0\r\n\
+                 \r\n\
+                 "
+            )
+            .keep_alive,
+            "HTTP/1.0 close is default"
+        );
+
+        assert!(
+            parse(
+                "\
+                 HTTP/1.0 200 OK\r\n\
+                 content-length: 0\r\n\
+                 connection: foo, keep-alive, bar\r\n\
+                 \r\n\
+                 "
+            )
+            .keep_alive,
+            "connection keep-alive is always keep-alive"
+        );
+    }
+
+    #[test]
+    fn test_client_request_encode_title_case() {
+        use crate::proto::BodyLength;
+        use http::header::HeaderValue;
+
+        let mut head = MessageHead::default();
+        head.headers
+            .insert("content-length", HeaderValue::from_static("10"));
+        head.headers
+            .insert("content-type", HeaderValue::from_static("application/json"));
+        head.headers.insert("*-*", HeaderValue::from_static("o_o"));
+
+        let mut vec = Vec::new();
+        Client::encode(
+            Encode {
+                head: &mut head,
+                body: Some(BodyLength::Known(10)),
+                keep_alive: true,
+                req_method: &mut None,
+                title_case_headers: true,
+            },
+            &mut vec,
+        )
+        .unwrap();
+
+        assert_eq!(vec, b"GET / HTTP/1.1\r\nContent-Length: 10\r\nContent-Type: application/json\r\n*-*: o_o\r\n\r\n".to_vec());
+    }
+
+    #[test]
+    fn test_client_request_encode_orig_case() {
+        use crate::proto::BodyLength;
+        use http::header::{HeaderValue, CONTENT_LENGTH};
+
+        let mut head = MessageHead::default();
+        head.headers
+            .insert("content-length", HeaderValue::from_static("10"));
+        head.headers
+            .insert("content-type", HeaderValue::from_static("application/json"));
+
+        let mut orig_headers = HeaderCaseMap::default();
+        orig_headers.insert(CONTENT_LENGTH, "CONTENT-LENGTH".into());
+        head.extensions.insert(orig_headers);
+
+        let mut vec = Vec::new();
+        Client::encode(
+            Encode {
+                head: &mut head,
+                body: Some(BodyLength::Known(10)),
+                keep_alive: true,
+                req_method: &mut None,
+                title_case_headers: false,
+            },
+            &mut vec,
+        )
+        .unwrap();
+
+        assert_eq!(
+            &*vec,
+            b"GET / HTTP/1.1\r\nCONTENT-LENGTH: 10\r\ncontent-type: application/json\r\n\r\n"
+                .as_ref(),
+        );
+    }
+    #[test]
+    fn test_client_request_encode_orig_and_title_case() {
+        use crate::proto::BodyLength;
+        use http::header::{HeaderValue, CONTENT_LENGTH};
+
+        let mut head = MessageHead::default();
+        head.headers
+            .insert("content-length", HeaderValue::from_static("10"));
+        head.headers
+            .insert("content-type", HeaderValue::from_static("application/json"));
+
+        let mut orig_headers = HeaderCaseMap::default();
+        orig_headers.insert(CONTENT_LENGTH, "CONTENT-LENGTH".into());
+        head.extensions.insert(orig_headers);
+
+        let mut vec = Vec::new();
+        Client::encode(
+            Encode {
+                head: &mut head,
+                body: Some(BodyLength::Known(10)),
+                keep_alive: true,
+                req_method: &mut None,
+                title_case_headers: true,
+            },
+            &mut vec,
+        )
+        .unwrap();
+
+        assert_eq!(
+            &*vec,
+            b"GET / HTTP/1.1\r\nCONTENT-LENGTH: 10\r\nContent-Type: application/json\r\n\r\n"
+                .as_ref(),
+        );
+    }
+
+    #[test]
+    fn test_server_encode_connect_method() {
+        let mut head = MessageHead::default();
+
+        let mut vec = Vec::new();
+        let encoder = Server::encode(
+            Encode {
+                head: &mut head,
+                body: None,
+                keep_alive: true,
+                req_method: &mut Some(Method::CONNECT),
+                title_case_headers: false,
+            },
+            &mut vec,
+        )
+        .unwrap();
+
+        assert!(encoder.is_last());
+    }
+
+    #[test]
+    fn test_server_response_encode_title_case() {
+        use crate::proto::BodyLength;
+        use http::header::HeaderValue;
+
+        let mut head = MessageHead::default();
+        head.headers
+            .insert("content-length", HeaderValue::from_static("10"));
+        head.headers
+            .insert("content-type", HeaderValue::from_static("application/json"));
+        head.headers
+            .insert("weird--header", HeaderValue::from_static(""));
+
+        let mut vec = Vec::new();
+        Server::encode(
+            Encode {
+                head: &mut head,
+                body: Some(BodyLength::Known(10)),
+                keep_alive: true,
+                req_method: &mut None,
+                title_case_headers: true,
+            },
+            &mut vec,
+        )
+        .unwrap();
+
+        let expected_response =
+            b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\nContent-Type: application/json\r\nWeird--Header: \r\n";
+
+        assert_eq!(&vec[..expected_response.len()], &expected_response[..]);
+    }
+
+    #[test]
+    fn test_server_response_encode_orig_case() {
+        use crate::proto::BodyLength;
+        use http::header::{HeaderValue, CONTENT_LENGTH};
+
+        let mut head = MessageHead::default();
+        head.headers
+            .insert("content-length", HeaderValue::from_static("10"));
+        head.headers
+            .insert("content-type", HeaderValue::from_static("application/json"));
+
+        let mut orig_headers = HeaderCaseMap::default();
+        orig_headers.insert(CONTENT_LENGTH, "CONTENT-LENGTH".into());
+        head.extensions.insert(orig_headers);
+
+        let mut vec = Vec::new();
+        Server::encode(
+            Encode {
+                head: &mut head,
+                body: Some(BodyLength::Known(10)),
+                keep_alive: true,
+                req_method: &mut None,
+                title_case_headers: false,
+            },
+            &mut vec,
+        )
+        .unwrap();
+
+        let expected_response =
+            b"HTTP/1.1 200 OK\r\nCONTENT-LENGTH: 10\r\ncontent-type: application/json\r\ndate: ";
+
+        assert_eq!(&vec[..expected_response.len()], &expected_response[..]);
+    }
+
+    #[test]
+    fn test_server_response_encode_orig_and_title_case() {
+        use crate::proto::BodyLength;
+        use http::header::{HeaderValue, CONTENT_LENGTH};
+
+        let mut head = MessageHead::default();
+        head.headers
+            .insert("content-length", HeaderValue::from_static("10"));
+        head.headers
+            .insert("content-type", HeaderValue::from_static("application/json"));
+
+        let mut orig_headers = HeaderCaseMap::default();
+        orig_headers.insert(CONTENT_LENGTH, "CONTENT-LENGTH".into());
+        head.extensions.insert(orig_headers);
+
+        let mut vec = Vec::new();
+        Server::encode(
+            Encode {
+                head: &mut head,
+                body: Some(BodyLength::Known(10)),
+                keep_alive: true,
+                req_method: &mut None,
+                title_case_headers: true,
+            },
+            &mut vec,
+        )
+        .unwrap();
+
+        let expected_response =
+            b"HTTP/1.1 200 OK\r\nCONTENT-LENGTH: 10\r\nContent-Type: application/json\r\nDate: ";
+
+        assert_eq!(&vec[..expected_response.len()], &expected_response[..]);
+    }
+
+    #[test]
+    fn parse_header_htabs() {
+        let mut bytes = BytesMut::from("HTTP/1.1 200 OK\r\nserver: hello\tworld\r\n\r\n");
+        let parsed = Client::parse(
+            &mut bytes,
+            ParseContext {
+                cached_headers: &mut None,
+                req_method: &mut Some(Method::GET),
+                h1_parser_config: Default::default(),
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout: None,
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout_fut: &mut None,
+                #[cfg(feature = "runtime")]
+                h1_header_read_timeout_running: &mut false,
+                preserve_header_case: false,
+                #[cfg(feature = "ffi")]
+                preserve_header_order: false,
+                h09_responses: false,
+                #[cfg(feature = "ffi")]
+                on_informational: &mut None,
+                #[cfg(feature = "ffi")]
+                raw_headers: false,
+            },
+        )
+        .expect("parse ok")
+        .expect("parse complete");
+
+        assert_eq!(parsed.head.headers["server"], "hello\tworld");
+    }
+
+    #[test]
+    fn test_write_headers_orig_case_empty_value() {
+        let mut headers = HeaderMap::new();
+        let name = http::header::HeaderName::from_static("x-empty");
+        headers.insert(&name, "".parse().expect("parse empty"));
+        let mut orig_cases = HeaderCaseMap::default();
+        orig_cases.insert(name, Bytes::from_static(b"X-EmptY"));
+
+        let mut dst = Vec::new();
+        super::write_headers_original_case(&headers, &orig_cases, &mut dst, false);
+
+        assert_eq!(
+            dst, b"X-EmptY:\r\n",
+            "there should be no space between the colon and CRLF"
+        );
+    }
+
+    #[test]
+    fn test_write_headers_orig_case_multiple_entries() {
+        let mut headers = HeaderMap::new();
+        let name = http::header::HeaderName::from_static("x-empty");
+        headers.insert(&name, "a".parse().unwrap());
+        headers.append(&name, "b".parse().unwrap());
+
+        let mut orig_cases = HeaderCaseMap::default();
+        orig_cases.insert(name.clone(), Bytes::from_static(b"X-Empty"));
+        orig_cases.append(name, Bytes::from_static(b"X-EMPTY"));
+
+        let mut dst = Vec::new();
+        super::write_headers_original_case(&headers, &orig_cases, &mut dst, false);
+
+        assert_eq!(dst, b"X-Empty: a\r\nX-EMPTY: b\r\n");
+    }
+
+    #[cfg(feature = "nightly")]
+    use test::Bencher;
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_parse_incoming(b: &mut Bencher) {
+        let mut raw = BytesMut::from(
+            &b"GET /super_long_uri/and_whatever?what_should_we_talk_about/\
+            I_wonder/Hard_to_write_in_an_uri_after_all/you_have_to_make\
+            _up_the_punctuation_yourself/how_fun_is_that?test=foo&test1=\
+            foo1&test2=foo2&test3=foo3&test4=foo4 HTTP/1.1\r\nHost: \
+            hyper.rs\r\nAccept: a lot of things\r\nAccept-Charset: \
+            utf8\r\nAccept-Encoding: *\r\nAccess-Control-Allow-\
+            Credentials: None\r\nAccess-Control-Allow-Origin: None\r\n\
+            Access-Control-Allow-Methods: None\r\nAccess-Control-Allow-\
+            Headers: None\r\nContent-Encoding: utf8\r\nContent-Security-\
+            Policy: None\r\nContent-Type: text/html\r\nOrigin: hyper\
+            \r\nSec-Websocket-Extensions: It looks super important!\r\n\
+            Sec-Websocket-Origin: hyper\r\nSec-Websocket-Version: 4.3\r\
+            \nStrict-Transport-Security: None\r\nUser-Agent: hyper\r\n\
+            X-Content-Duration: None\r\nX-Content-Security-Policy: None\
+            \r\nX-DNSPrefetch-Control: None\r\nX-Frame-Options: \
+            Something important obviously\r\nX-Requested-With: Nothing\
+            \r\n\r\n"[..],
+        );
+        let len = raw.len();
+        let mut headers = Some(HeaderMap::new());
+
+        b.bytes = len as u64;
+        b.iter(|| {
+            let mut msg = Server::parse(
+                &mut raw,
+                ParseContext {
+                    cached_headers: &mut headers,
+                    req_method: &mut None,
+                    h1_parser_config: Default::default(),
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout: None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_fut: &mut None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_running: &mut false,
+                    preserve_header_case: false,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: false,
+                    h09_responses: false,
+                    #[cfg(feature = "ffi")]
+                    on_informational: &mut None,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: false,
+                },
+            )
+            .unwrap()
+            .unwrap();
+            ::test::black_box(&msg);
+            msg.head.headers.clear();
+            headers = Some(msg.head.headers);
+            restart(&mut raw, len);
+        });
+
+        fn restart(b: &mut BytesMut, len: usize) {
+            b.reserve(1);
+            unsafe {
+                b.set_len(len);
+            }
+        }
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_parse_short(b: &mut Bencher) {
+        let s = &b"GET / HTTP/1.1\r\nHost: localhost:8080\r\n\r\n"[..];
+        let mut raw = BytesMut::from(s);
+        let len = raw.len();
+        let mut headers = Some(HeaderMap::new());
+
+        b.bytes = len as u64;
+        b.iter(|| {
+            let mut msg = Server::parse(
+                &mut raw,
+                ParseContext {
+                    cached_headers: &mut headers,
+                    req_method: &mut None,
+                    h1_parser_config: Default::default(),
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout: None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_fut: &mut None,
+                    #[cfg(feature = "runtime")]
+                    h1_header_read_timeout_running: &mut false,
+                    preserve_header_case: false,
+                    #[cfg(feature = "ffi")]
+                    preserve_header_order: false,
+                    h09_responses: false,
+                    #[cfg(feature = "ffi")]
+                    on_informational: &mut None,
+                    #[cfg(feature = "ffi")]
+                    raw_headers: false,
+                },
+            )
+            .unwrap()
+            .unwrap();
+            ::test::black_box(&msg);
+            msg.head.headers.clear();
+            headers = Some(msg.head.headers);
+            restart(&mut raw, len);
+        });
+
+        fn restart(b: &mut BytesMut, len: usize) {
+            b.reserve(1);
+            unsafe {
+                b.set_len(len);
+            }
+        }
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_server_encode_headers_preset(b: &mut Bencher) {
+        use crate::proto::BodyLength;
+        use http::header::HeaderValue;
+
+        let len = 108;
+        b.bytes = len as u64;
+
+        let mut head = MessageHead::default();
+        let mut headers = HeaderMap::new();
+        headers.insert("content-length", HeaderValue::from_static("10"));
+        headers.insert("content-type", HeaderValue::from_static("application/json"));
+
+        b.iter(|| {
+            let mut vec = Vec::new();
+            head.headers = headers.clone();
+            Server::encode(
+                Encode {
+                    head: &mut head,
+                    body: Some(BodyLength::Known(10)),
+                    keep_alive: true,
+                    req_method: &mut Some(Method::GET),
+                    title_case_headers: false,
+                },
+                &mut vec,
+            )
+            .unwrap();
+            assert_eq!(vec.len(), len);
+            ::test::black_box(vec);
+        })
+    }
+
+    #[cfg(feature = "nightly")]
+    #[bench]
+    fn bench_server_encode_no_headers(b: &mut Bencher) {
+        use crate::proto::BodyLength;
+
+        let len = 76;
+        b.bytes = len as u64;
+
+        let mut head = MessageHead::default();
+        let mut vec = Vec::with_capacity(128);
+
+        b.iter(|| {
+            Server::encode(
+                Encode {
+                    head: &mut head,
+                    body: Some(BodyLength::Known(10)),
+                    keep_alive: true,
+                    req_method: &mut Some(Method::GET),
+                    title_case_headers: false,
+                },
+                &mut vec,
+            )
+            .unwrap();
+            assert_eq!(vec.len(), len);
+            ::test::black_box(&vec);
+
+            vec.clear();
+        })
+    }
+}
diff --git a/hyper/src/proto/h2/client.rs b/hyper/src/proto/h2/client.rs
new file mode 100644
index 0000000..bac8ece
--- /dev/null
+++ b/hyper/src/proto/h2/client.rs
@@ -0,0 +1,450 @@
+use std::error::Error as StdError;
+#[cfg(feature = "runtime")]
+use std::time::Duration;
+
+use bytes::Bytes;
+use futures_channel::{mpsc, oneshot};
+use futures_util::future::{self, Either, FutureExt as _, TryFutureExt as _};
+use futures_util::stream::StreamExt as _;
+use h2::client::{Builder, SendRequest};
+use h2::SendStream;
+use http::{Method, StatusCode};
+use tokio::io::{AsyncRead, AsyncWrite};
+use tracing::{debug, trace, warn};
+
+use super::{ping, H2Upgraded, PipeToSendStream, SendBuf};
+use crate::body::HttpBody;
+use crate::client::dispatch::Callback;
+use crate::common::{exec::Exec, task, Future, Never, Pin, Poll};
+use crate::ext::Protocol;
+use crate::headers;
+use crate::proto::h2::UpgradedSendStream;
+use crate::proto::Dispatched;
+use crate::upgrade::Upgraded;
+use crate::{Body, Request, Response};
+use h2::client::ResponseFuture;
+
+type ClientRx<B> = crate::client::dispatch::Receiver<Request<B>, Response<Body>>;
+
+///// An mpsc channel is used to help notify the `Connection` task when *all*
+///// other handles to it have been dropped, so that it can shutdown.
+type ConnDropRef = mpsc::Sender<Never>;
+
+///// A oneshot channel watches the `Connection` task, and when it completes,
+///// the "dispatch" task will be notified and can shutdown sooner.
+type ConnEof = oneshot::Receiver<Never>;
+
+// Our defaults are chosen for the "majority" case, which usually are not
+// resource constrained, and so the spec default of 64kb can be too limiting
+// for performance.
+const DEFAULT_CONN_WINDOW: u32 = 1024 * 1024 * 5; // 5mb
+const DEFAULT_STREAM_WINDOW: u32 = 1024 * 1024 * 2; // 2mb
+const DEFAULT_MAX_FRAME_SIZE: u32 = 1024 * 16; // 16kb
+const DEFAULT_MAX_SEND_BUF_SIZE: usize = 1024 * 1024; // 1mb
+
+#[derive(Clone, Debug)]
+pub(crate) struct Config {
+    pub(crate) adaptive_window: bool,
+    pub(crate) initial_conn_window_size: u32,
+    pub(crate) initial_stream_window_size: u32,
+    pub(crate) max_frame_size: u32,
+    #[cfg(feature = "runtime")]
+    pub(crate) keep_alive_interval: Option<Duration>,
+    #[cfg(feature = "runtime")]
+    pub(crate) keep_alive_timeout: Duration,
+    #[cfg(feature = "runtime")]
+    pub(crate) keep_alive_while_idle: bool,
+    pub(crate) max_concurrent_reset_streams: Option<usize>,
+    pub(crate) max_send_buffer_size: usize,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            adaptive_window: false,
+            initial_conn_window_size: DEFAULT_CONN_WINDOW,
+            initial_stream_window_size: DEFAULT_STREAM_WINDOW,
+            max_frame_size: DEFAULT_MAX_FRAME_SIZE,
+            #[cfg(feature = "runtime")]
+            keep_alive_interval: None,
+            #[cfg(feature = "runtime")]
+            keep_alive_timeout: Duration::from_secs(20),
+            #[cfg(feature = "runtime")]
+            keep_alive_while_idle: false,
+            max_concurrent_reset_streams: None,
+            max_send_buffer_size: DEFAULT_MAX_SEND_BUF_SIZE,
+        }
+    }
+}
+
+fn new_builder(config: &Config) -> Builder {
+    let mut builder = Builder::default();
+    builder
+        .initial_window_size(config.initial_stream_window_size)
+        .initial_connection_window_size(config.initial_conn_window_size)
+        .max_frame_size(config.max_frame_size)
+        .max_send_buffer_size(config.max_send_buffer_size)
+        .enable_push(false);
+    if let Some(max) = config.max_concurrent_reset_streams {
+        builder.max_concurrent_reset_streams(max);
+    }
+    builder
+}
+
+fn new_ping_config(config: &Config) -> ping::Config {
+    ping::Config {
+        bdp_initial_window: if config.adaptive_window {
+            Some(config.initial_stream_window_size)
+        } else {
+            None
+        },
+        #[cfg(feature = "runtime")]
+        keep_alive_interval: config.keep_alive_interval,
+        #[cfg(feature = "runtime")]
+        keep_alive_timeout: config.keep_alive_timeout,
+        #[cfg(feature = "runtime")]
+        keep_alive_while_idle: config.keep_alive_while_idle,
+    }
+}
+
+pub(crate) async fn handshake<T, B>(
+    io: T,
+    req_rx: ClientRx<B>,
+    config: &Config,
+    exec: Exec,
+) -> crate::Result<ClientTask<B>>
+where
+    T: AsyncRead + AsyncWrite + Send + Unpin + 'static,
+    B: HttpBody,
+    B::Data: Send + 'static,
+{
+    let (h2_tx, mut conn) = new_builder(config)
+        .handshake::<_, SendBuf<B::Data>>(io)
+        .await
+        .map_err(crate::Error::new_h2)?;
+
+    // An mpsc channel is used entirely to detect when the
+    // 'Client' has been dropped. This is to get around a bug
+    // in h2 where dropping all SendRequests won't notify a
+    // parked Connection.
+    let (conn_drop_ref, rx) = mpsc::channel(1);
+    let (cancel_tx, conn_eof) = oneshot::channel();
+
+    let conn_drop_rx = rx.into_future().map(|(item, _rx)| {
+        if let Some(never) = item {
+            match never {}
+        }
+    });
+
+    let ping_config = new_ping_config(&config);
+
+    let (conn, ping) = if ping_config.is_enabled() {
+        let pp = conn.ping_pong().expect("conn.ping_pong");
+        let (recorder, mut ponger) = ping::channel(pp, ping_config);
+
+        let conn = future::poll_fn(move |cx| {
+            match ponger.poll(cx) {
+                Poll::Ready(ping::Ponged::SizeUpdate(wnd)) => {
+                    conn.set_target_window_size(wnd);
+                    conn.set_initial_window_size(wnd)?;
+                }
+                #[cfg(feature = "runtime")]
+                Poll::Ready(ping::Ponged::KeepAliveTimedOut) => {
+                    debug!("connection keep-alive timed out");
+                    return Poll::Ready(Ok(()));
+                }
+                Poll::Pending => {}
+            }
+
+            Pin::new(&mut conn).poll(cx)
+        });
+        (Either::Left(conn), recorder)
+    } else {
+        (Either::Right(conn), ping::disabled())
+    };
+    let conn = conn.map_err(|e| debug!("connection error: {}", e));
+
+    exec.execute(conn_task(conn, conn_drop_rx, cancel_tx));
+
+    Ok(ClientTask {
+        ping,
+        conn_drop_ref,
+        conn_eof,
+        executor: exec,
+        h2_tx,
+        req_rx,
+        fut_ctx: None,
+    })
+}
+
+async fn conn_task<C, D>(conn: C, drop_rx: D, cancel_tx: oneshot::Sender<Never>)
+where
+    C: Future + Unpin,
+    D: Future<Output = ()> + Unpin,
+{
+    match future::select(conn, drop_rx).await {
+        Either::Left(_) => {
+            // ok or err, the `conn` has finished
+        }
+        Either::Right(((), conn)) => {
+            // mpsc has been dropped, hopefully polling
+            // the connection some more should start shutdown
+            // and then close
+            trace!("send_request dropped, starting conn shutdown");
+            drop(cancel_tx);
+            let _ = conn.await;
+        }
+    }
+}
+
+struct FutCtx<B>
+where
+    B: HttpBody,
+{
+    is_connect: bool,
+    eos: bool,
+    fut: ResponseFuture,
+    body_tx: SendStream<SendBuf<B::Data>>,
+    body: B,
+    cb: Callback<Request<B>, Response<Body>>,
+}
+
+impl<B: HttpBody> Unpin for FutCtx<B> {}
+
+pub(crate) struct ClientTask<B>
+where
+    B: HttpBody,
+{
+    ping: ping::Recorder,
+    conn_drop_ref: ConnDropRef,
+    conn_eof: ConnEof,
+    executor: Exec,
+    h2_tx: SendRequest<SendBuf<B::Data>>,
+    req_rx: ClientRx<B>,
+    fut_ctx: Option<FutCtx<B>>,
+}
+
+impl<B> ClientTask<B>
+where
+    B: HttpBody + 'static,
+{
+    pub(crate) fn is_extended_connect_protocol_enabled(&self) -> bool {
+        self.h2_tx.is_extended_connect_protocol_enabled()
+    }
+}
+
+impl<B> ClientTask<B>
+where
+    B: HttpBody + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    fn poll_pipe(&mut self, f: FutCtx<B>, cx: &mut task::Context<'_>) {
+        let ping = self.ping.clone();
+        let send_stream = if !f.is_connect {
+            if !f.eos {
+                let mut pipe = Box::pin(PipeToSendStream::new(f.body, f.body_tx)).map(|res| {
+                    if let Err(e) = res {
+                        debug!("client request body error: {}", e);
+                    }
+                });
+
+                // eagerly see if the body pipe is ready and
+                // can thus skip allocating in the executor
+                match Pin::new(&mut pipe).poll(cx) {
+                    Poll::Ready(_) => (),
+                    Poll::Pending => {
+                        let conn_drop_ref = self.conn_drop_ref.clone();
+                        // keep the ping recorder's knowledge of an
+                        // "open stream" alive while this body is
+                        // still sending...
+                        let ping = ping.clone();
+                        let pipe = pipe.map(move |x| {
+                            drop(conn_drop_ref);
+                            drop(ping);
+                            x
+                        });
+                        // Clear send task
+                        self.executor.execute(pipe);
+                    }
+                }
+            }
+
+            None
+        } else {
+            Some(f.body_tx)
+        };
+
+        let fut = f.fut.map(move |result| match result {
+            Ok(res) => {
+                // record that we got the response headers
+                ping.record_non_data();
+
+                let content_length = headers::content_length_parse_all(res.headers());
+                if let (Some(mut send_stream), StatusCode::OK) = (send_stream, res.status()) {
+                    if content_length.map_or(false, |len| len != 0) {
+                        warn!("h2 connect response with non-zero body not supported");
+
+                        send_stream.send_reset(h2::Reason::INTERNAL_ERROR);
+                        return Err((
+                            crate::Error::new_h2(h2::Reason::INTERNAL_ERROR.into()),
+                            None,
+                        ));
+                    }
+                    let (parts, recv_stream) = res.into_parts();
+                    let mut res = Response::from_parts(parts, Body::empty());
+
+                    let (pending, on_upgrade) = crate::upgrade::pending();
+                    let io = H2Upgraded {
+                        ping,
+                        send_stream: unsafe { UpgradedSendStream::new(send_stream) },
+                        recv_stream,
+                        buf: Bytes::new(),
+                    };
+                    let upgraded = Upgraded::new(io, Bytes::new());
+
+                    pending.fulfill(upgraded);
+                    res.extensions_mut().insert(on_upgrade);
+
+                    Ok(res)
+                } else {
+                    let res = res.map(|stream| {
+                        let ping = ping.for_stream(&stream);
+                        crate::Body::h2(stream, content_length.into(), ping)
+                    });
+                    Ok(res)
+                }
+            }
+            Err(err) => {
+                ping.ensure_not_timed_out().map_err(|e| (e, None))?;
+
+                debug!("client response error: {}", err);
+                Err((crate::Error::new_h2(err), None))
+            }
+        });
+        self.executor.execute(f.cb.send_when(fut));
+    }
+}
+
+impl<B> Future for ClientTask<B>
+where
+    B: HttpBody + Send + 'static,
+    B::Data: Send,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Output = crate::Result<Dispatched>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        loop {
+            match ready!(self.h2_tx.poll_ready(cx)) {
+                Ok(()) => (),
+                Err(err) => {
+                    self.ping.ensure_not_timed_out()?;
+                    return if err.reason() == Some(::h2::Reason::NO_ERROR) {
+                        trace!("connection gracefully shutdown");
+                        Poll::Ready(Ok(Dispatched::Shutdown))
+                    } else {
+                        Poll::Ready(Err(crate::Error::new_h2(err)))
+                    };
+                }
+            };
+
+            match self.fut_ctx.take() {
+                // If we were waiting on pending open
+                // continue where we left off.
+                Some(f) => {
+                    self.poll_pipe(f, cx);
+                    continue;
+                }
+                None => (),
+            }
+
+            match self.req_rx.poll_recv(cx) {
+                Poll::Ready(Some((req, cb))) => {
+                    // check that future hasn't been canceled already
+                    if cb.is_canceled() {
+                        trace!("request callback is canceled");
+                        continue;
+                    }
+                    let (head, body) = req.into_parts();
+                    let mut req = ::http::Request::from_parts(head, ());
+                    super::strip_connection_headers(req.headers_mut(), true);
+                    if let Some(len) = body.size_hint().exact() {
+                        if len != 0 || headers::method_has_defined_payload_semantics(req.method()) {
+                            headers::set_content_length_if_missing(req.headers_mut(), len);
+                        }
+                    }
+
+                    let is_connect = req.method() == Method::CONNECT;
+                    let eos = body.is_end_stream();
+
+                    if is_connect {
+                        if headers::content_length_parse_all(req.headers())
+                            .map_or(false, |len| len != 0)
+                        {
+                            warn!("h2 connect request with non-zero body not supported");
+                            cb.send(Err((
+                                crate::Error::new_h2(h2::Reason::INTERNAL_ERROR.into()),
+                                None,
+                            )));
+                            continue;
+                        }
+                    }
+
+                    if let Some(protocol) = req.extensions_mut().remove::<Protocol>() {
+                        req.extensions_mut().insert(protocol.into_inner());
+                    }
+
+                    let (fut, body_tx) = match self.h2_tx.send_request(req, !is_connect && eos) {
+                        Ok(ok) => ok,
+                        Err(err) => {
+                            debug!("client send request error: {}", err);
+                            cb.send(Err((crate::Error::new_h2(err), None)));
+                            continue;
+                        }
+                    };
+
+                    let f = FutCtx {
+                        is_connect,
+                        eos,
+                        fut,
+                        body_tx,
+                        body,
+                        cb,
+                    };
+
+                    // Check poll_ready() again.
+                    // If the call to send_request() resulted in the new stream being pending open
+                    // we have to wait for the open to complete before accepting new requests.
+                    match self.h2_tx.poll_ready(cx) {
+                        Poll::Pending => {
+                            // Save Context
+                            self.fut_ctx = Some(f);
+                            return Poll::Pending;
+                        }
+                        Poll::Ready(Ok(())) => (),
+                        Poll::Ready(Err(err)) => {
+                            f.cb.send(Err((crate::Error::new_h2(err), None)));
+                            continue;
+                        }
+                    }
+                    self.poll_pipe(f, cx);
+                    continue;
+                }
+
+                Poll::Ready(None) => {
+                    trace!("client::dispatch::Sender dropped");
+                    return Poll::Ready(Ok(Dispatched::Shutdown));
+                }
+
+                Poll::Pending => match ready!(Pin::new(&mut self.conn_eof).poll(cx)) {
+                    Ok(never) => match never {},
+                    Err(_conn_is_eof) => {
+                        trace!("connection task is closed, closing dispatch task");
+                        return Poll::Ready(Ok(Dispatched::Shutdown));
+                    }
+                },
+            }
+        }
+    }
+}
diff --git a/hyper/src/proto/h2/mod.rs b/hyper/src/proto/h2/mod.rs
new file mode 100644
index 0000000..5857c91
--- /dev/null
+++ b/hyper/src/proto/h2/mod.rs
@@ -0,0 +1,471 @@
+use bytes::{Buf, Bytes};
+use h2::{Reason, RecvStream, SendStream};
+use http::header::{HeaderName, CONNECTION, TE, TRAILER, TRANSFER_ENCODING, UPGRADE};
+use http::HeaderMap;
+use pin_project_lite::pin_project;
+use std::error::Error as StdError;
+use std::io::{self, Cursor, IoSlice};
+use std::mem;
+use std::task::Context;
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tracing::{debug, trace, warn};
+
+use crate::body::HttpBody;
+use crate::common::{task, Future, Pin, Poll};
+use crate::proto::h2::ping::Recorder;
+
+pub(crate) mod ping;
+
+cfg_client! {
+    pub(crate) mod client;
+    pub(crate) use self::client::ClientTask;
+}
+
+cfg_server! {
+    pub(crate) mod server;
+    pub(crate) use self::server::Server;
+}
+
+/// Default initial stream window size defined in HTTP2 spec.
+pub(crate) const SPEC_WINDOW_SIZE: u32 = 65_535;
+
+fn strip_connection_headers(headers: &mut HeaderMap, is_request: bool) {
+    // List of connection headers from:
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection
+    //
+    // TE headers are allowed in HTTP/2 requests as long as the value is "trailers", so they're
+    // tested separately.
+    let connection_headers = [
+        HeaderName::from_lowercase(b"keep-alive").unwrap(),
+        HeaderName::from_lowercase(b"proxy-connection").unwrap(),
+        TRAILER,
+        TRANSFER_ENCODING,
+        UPGRADE,
+    ];
+
+    for header in connection_headers.iter() {
+        if headers.remove(header).is_some() {
+            warn!("Connection header illegal in HTTP/2: {}", header.as_str());
+        }
+    }
+
+    if is_request {
+        if headers
+            .get(TE)
+            .map(|te_header| te_header != "trailers")
+            .unwrap_or(false)
+        {
+            warn!("TE headers not set to \"trailers\" are illegal in HTTP/2 requests");
+            headers.remove(TE);
+        }
+    } else if headers.remove(TE).is_some() {
+        warn!("TE headers illegal in HTTP/2 responses");
+    }
+
+    if let Some(header) = headers.remove(CONNECTION) {
+        warn!(
+            "Connection header illegal in HTTP/2: {}",
+            CONNECTION.as_str()
+        );
+        let header_contents = header.to_str().unwrap();
+
+        // A `Connection` header may have a comma-separated list of names of other headers that
+        // are meant for only this specific connection.
+        //
+        // Iterate these names and remove them as headers. Connection-specific headers are
+        // forbidden in HTTP2, as that information has been moved into frame types of the h2
+        // protocol.
+        for name in header_contents.split(',') {
+            let name = name.trim();
+            headers.remove(name);
+        }
+    }
+}
+
+// body adapters used by both Client and Server
+
+pin_project! {
+    struct PipeToSendStream<S>
+    where
+        S: HttpBody,
+    {
+        body_tx: SendStream<SendBuf<S::Data>>,
+        data_done: bool,
+        #[pin]
+        stream: S,
+    }
+}
+
+impl<S> PipeToSendStream<S>
+where
+    S: HttpBody,
+{
+    fn new(stream: S, tx: SendStream<SendBuf<S::Data>>) -> PipeToSendStream<S> {
+        PipeToSendStream {
+            body_tx: tx,
+            data_done: false,
+            stream,
+        }
+    }
+}
+
+impl<S> Future for PipeToSendStream<S>
+where
+    S: HttpBody,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Output = crate::Result<()>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut me = self.project();
+        loop {
+            if !*me.data_done {
+                // we don't have the next chunk of data yet, so just reserve 1 byte to make
+                // sure there's some capacity available. h2 will handle the capacity management
+                // for the actual body chunk.
+                me.body_tx.reserve_capacity(1);
+
+                if me.body_tx.capacity() == 0 {
+                    loop {
+                        match ready!(me.body_tx.poll_capacity(cx)) {
+                            Some(Ok(0)) => {}
+                            Some(Ok(_)) => break,
+                            Some(Err(e)) => {
+                                return Poll::Ready(Err(crate::Error::new_body_write(e)))
+                            }
+                            None => {
+                                // None means the stream is no longer in a
+                                // streaming state, we either finished it
+                                // somehow, or the remote reset us.
+                                return Poll::Ready(Err(crate::Error::new_body_write(
+                                    "send stream capacity unexpectedly closed",
+                                )));
+                            }
+                        }
+                    }
+                } else if let Poll::Ready(reason) = me
+                    .body_tx
+                    .poll_reset(cx)
+                    .map_err(crate::Error::new_body_write)?
+                {
+                    debug!("stream received RST_STREAM: {:?}", reason);
+                    return Poll::Ready(Err(crate::Error::new_body_write(::h2::Error::from(
+                        reason,
+                    ))));
+                }
+
+                match ready!(me.stream.as_mut().poll_data(cx)) {
+                    Some(Ok(chunk)) => {
+                        let is_eos = me.stream.is_end_stream();
+                        trace!(
+                            "send body chunk: {} bytes, eos={}",
+                            chunk.remaining(),
+                            is_eos,
+                        );
+
+                        let buf = SendBuf::Buf(chunk);
+                        me.body_tx
+                            .send_data(buf, is_eos)
+                            .map_err(crate::Error::new_body_write)?;
+
+                        if is_eos {
+                            return Poll::Ready(Ok(()));
+                        }
+                    }
+                    Some(Err(e)) => return Poll::Ready(Err(me.body_tx.on_user_err(e))),
+                    None => {
+                        me.body_tx.reserve_capacity(0);
+                        let is_eos = me.stream.is_end_stream();
+                        if is_eos {
+                            return Poll::Ready(me.body_tx.send_eos_frame());
+                        } else {
+                            *me.data_done = true;
+                            // loop again to poll_trailers
+                        }
+                    }
+                }
+            } else {
+                if let Poll::Ready(reason) = me
+                    .body_tx
+                    .poll_reset(cx)
+                    .map_err(crate::Error::new_body_write)?
+                {
+                    debug!("stream received RST_STREAM: {:?}", reason);
+                    return Poll::Ready(Err(crate::Error::new_body_write(::h2::Error::from(
+                        reason,
+                    ))));
+                }
+
+                match ready!(me.stream.poll_trailers(cx)) {
+                    Ok(Some(trailers)) => {
+                        me.body_tx
+                            .send_trailers(trailers)
+                            .map_err(crate::Error::new_body_write)?;
+                        return Poll::Ready(Ok(()));
+                    }
+                    Ok(None) => {
+                        // There were no trailers, so send an empty DATA frame...
+                        return Poll::Ready(me.body_tx.send_eos_frame());
+                    }
+                    Err(e) => return Poll::Ready(Err(me.body_tx.on_user_err(e))),
+                }
+            }
+        }
+    }
+}
+
+trait SendStreamExt {
+    fn on_user_err<E>(&mut self, err: E) -> crate::Error
+    where
+        E: Into<Box<dyn std::error::Error + Send + Sync>>;
+    fn send_eos_frame(&mut self) -> crate::Result<()>;
+}
+
+impl<B: Buf> SendStreamExt for SendStream<SendBuf<B>> {
+    fn on_user_err<E>(&mut self, err: E) -> crate::Error
+    where
+        E: Into<Box<dyn std::error::Error + Send + Sync>>,
+    {
+        let err = crate::Error::new_user_body(err);
+        debug!("send body user stream error: {}", err);
+        self.send_reset(err.h2_reason());
+        err
+    }
+
+    fn send_eos_frame(&mut self) -> crate::Result<()> {
+        trace!("send body eos");
+        self.send_data(SendBuf::None, true)
+            .map_err(crate::Error::new_body_write)
+    }
+}
+
+#[repr(usize)]
+enum SendBuf<B> {
+    Buf(B),
+    Cursor(Cursor<Box<[u8]>>),
+    None,
+}
+
+impl<B: Buf> Buf for SendBuf<B> {
+    #[inline]
+    fn remaining(&self) -> usize {
+        match *self {
+            Self::Buf(ref b) => b.remaining(),
+            Self::Cursor(ref c) => Buf::remaining(c),
+            Self::None => 0,
+        }
+    }
+
+    #[inline]
+    fn chunk(&self) -> &[u8] {
+        match *self {
+            Self::Buf(ref b) => b.chunk(),
+            Self::Cursor(ref c) => c.chunk(),
+            Self::None => &[],
+        }
+    }
+
+    #[inline]
+    fn advance(&mut self, cnt: usize) {
+        match *self {
+            Self::Buf(ref mut b) => b.advance(cnt),
+            Self::Cursor(ref mut c) => c.advance(cnt),
+            Self::None => {}
+        }
+    }
+
+    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
+        match *self {
+            Self::Buf(ref b) => b.chunks_vectored(dst),
+            Self::Cursor(ref c) => c.chunks_vectored(dst),
+            Self::None => 0,
+        }
+    }
+}
+
+struct H2Upgraded<B>
+where
+    B: Buf,
+{
+    ping: Recorder,
+    send_stream: UpgradedSendStream<B>,
+    recv_stream: RecvStream,
+    buf: Bytes,
+}
+
+impl<B> AsyncRead for H2Upgraded<B>
+where
+    B: Buf,
+{
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        read_buf: &mut ReadBuf<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        if self.buf.is_empty() {
+            self.buf = loop {
+                match ready!(self.recv_stream.poll_data(cx)) {
+                    None => return Poll::Ready(Ok(())),
+                    Some(Ok(buf)) if buf.is_empty() && !self.recv_stream.is_end_stream() => {
+                        continue
+                    }
+                    Some(Ok(buf)) => {
+                        self.ping.record_data(buf.len());
+                        break buf;
+                    }
+                    Some(Err(e)) => {
+                        return Poll::Ready(match e.reason() {
+                            Some(Reason::NO_ERROR) | Some(Reason::CANCEL) => Ok(()),
+                            Some(Reason::STREAM_CLOSED) => {
+                                Err(io::Error::new(io::ErrorKind::BrokenPipe, e))
+                            }
+                            _ => Err(h2_to_io_error(e)),
+                        })
+                    }
+                }
+            };
+        }
+        let cnt = std::cmp::min(self.buf.len(), read_buf.remaining());
+        read_buf.put_slice(&self.buf[..cnt]);
+        self.buf.advance(cnt);
+        let _ = self.recv_stream.flow_control().release_capacity(cnt);
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl<B> AsyncWrite for H2Upgraded<B>
+where
+    B: Buf,
+{
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        if buf.is_empty() {
+            return Poll::Ready(Ok(0));
+        }
+        self.send_stream.reserve_capacity(buf.len());
+
+        // We ignore all errors returned by `poll_capacity` and `write`, as we
+        // will get the correct from `poll_reset` anyway.
+        let cnt = match ready!(self.send_stream.poll_capacity(cx)) {
+            None => Some(0),
+            Some(Ok(cnt)) => self
+                .send_stream
+                .write(&buf[..cnt], false)
+                .ok()
+                .map(|()| cnt),
+            Some(Err(_)) => None,
+        };
+
+        if let Some(cnt) = cnt {
+            return Poll::Ready(Ok(cnt));
+        }
+
+        Poll::Ready(Err(h2_to_io_error(
+            match ready!(self.send_stream.poll_reset(cx)) {
+                Ok(Reason::NO_ERROR) | Ok(Reason::CANCEL) | Ok(Reason::STREAM_CLOSED) => {
+                    return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()))
+                }
+                Ok(reason) => reason.into(),
+                Err(e) => e,
+            },
+        )))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        if self.send_stream.write(&[], true).is_ok() {
+            return Poll::Ready(Ok(()))
+        }
+
+        Poll::Ready(Err(h2_to_io_error(
+            match ready!(self.send_stream.poll_reset(cx)) {
+                Ok(Reason::NO_ERROR) => {
+                    return Poll::Ready(Ok(()))
+                }
+                Ok(Reason::CANCEL) | Ok(Reason::STREAM_CLOSED) => {
+                    return Poll::Ready(Err(io::ErrorKind::BrokenPipe.into()))
+                }
+                Ok(reason) => reason.into(),
+                Err(e) => e,
+            },
+        )))
+    }
+}
+
+fn h2_to_io_error(e: h2::Error) -> io::Error {
+    if e.is_io() {
+        e.into_io().unwrap()
+    } else {
+        io::Error::new(io::ErrorKind::Other, e)
+    }
+}
+
+struct UpgradedSendStream<B>(SendStream<SendBuf<Neutered<B>>>);
+
+impl<B> UpgradedSendStream<B>
+where
+    B: Buf,
+{
+    unsafe fn new(inner: SendStream<SendBuf<B>>) -> Self {
+        assert_eq!(mem::size_of::<B>(), mem::size_of::<Neutered<B>>());
+        Self(mem::transmute(inner))
+    }
+
+    fn reserve_capacity(&mut self, cnt: usize) {
+        unsafe { self.as_inner_unchecked().reserve_capacity(cnt) }
+    }
+
+    fn poll_capacity(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<usize, h2::Error>>> {
+        unsafe { self.as_inner_unchecked().poll_capacity(cx) }
+    }
+
+    fn poll_reset(&mut self, cx: &mut Context<'_>) -> Poll<Result<h2::Reason, h2::Error>> {
+        unsafe { self.as_inner_unchecked().poll_reset(cx) }
+    }
+
+    fn write(&mut self, buf: &[u8], end_of_stream: bool) -> Result<(), io::Error> {
+        let send_buf = SendBuf::Cursor(Cursor::new(buf.into()));
+        unsafe {
+            self.as_inner_unchecked()
+                .send_data(send_buf, end_of_stream)
+                .map_err(h2_to_io_error)
+        }
+    }
+
+    unsafe fn as_inner_unchecked(&mut self) -> &mut SendStream<SendBuf<B>> {
+        &mut *(&mut self.0 as *mut _ as *mut _)
+    }
+}
+
+#[repr(transparent)]
+struct Neutered<B> {
+    _inner: B,
+    impossible: Impossible,
+}
+
+enum Impossible {}
+
+unsafe impl<B> Send for Neutered<B> {}
+
+impl<B> Buf for Neutered<B> {
+    fn remaining(&self) -> usize {
+        match self.impossible {}
+    }
+
+    fn chunk(&self) -> &[u8] {
+        match self.impossible {}
+    }
+
+    fn advance(&mut self, _cnt: usize) {
+        match self.impossible {}
+    }
+}
diff --git a/hyper/src/proto/h2/ping.rs b/hyper/src/proto/h2/ping.rs
new file mode 100644
index 0000000..1e83864
--- /dev/null
+++ b/hyper/src/proto/h2/ping.rs
@@ -0,0 +1,555 @@
+/// HTTP2 Ping usage
+///
+/// hyper uses HTTP2 pings for two purposes:
+///
+/// 1. Adaptive flow control using BDP
+/// 2. Connection keep-alive
+///
+/// Both cases are optional.
+///
+/// # BDP Algorithm
+///
+/// 1. When receiving a DATA frame, if a BDP ping isn't outstanding:
+///   1a. Record current time.
+///   1b. Send a BDP ping.
+/// 2. Increment the number of received bytes.
+/// 3. When the BDP ping ack is received:
+///   3a. Record duration from sent time.
+///   3b. Merge RTT with a running average.
+///   3c. Calculate bdp as bytes/rtt.
+///   3d. If bdp is over 2/3 max, set new max to bdp and update windows.
+
+#[cfg(feature = "runtime")]
+use std::fmt;
+#[cfg(feature = "runtime")]
+use std::future::Future;
+#[cfg(feature = "runtime")]
+use std::pin::Pin;
+use std::sync::{Arc, Mutex};
+use std::task::{self, Poll};
+use std::time::Duration;
+#[cfg(not(feature = "runtime"))]
+use std::time::Instant;
+
+use h2::{Ping, PingPong};
+#[cfg(feature = "runtime")]
+use tokio::time::{Instant, Sleep};
+use tracing::{debug, trace};
+
+type WindowSize = u32;
+
+pub(super) fn disabled() -> Recorder {
+    Recorder { shared: None }
+}
+
+pub(super) fn channel(ping_pong: PingPong, config: Config) -> (Recorder, Ponger) {
+    debug_assert!(
+        config.is_enabled(),
+        "ping channel requires bdp or keep-alive config",
+    );
+
+    let bdp = config.bdp_initial_window.map(|wnd| Bdp {
+        bdp: wnd,
+        max_bandwidth: 0.0,
+        rtt: 0.0,
+        ping_delay: Duration::from_millis(100),
+        stable_count: 0,
+    });
+
+    let (bytes, next_bdp_at) = if bdp.is_some() {
+        (Some(0), Some(Instant::now()))
+    } else {
+        (None, None)
+    };
+
+    #[cfg(feature = "runtime")]
+    let keep_alive = config.keep_alive_interval.map(|interval| KeepAlive {
+        interval,
+        timeout: config.keep_alive_timeout,
+        while_idle: config.keep_alive_while_idle,
+        timer: Box::pin(tokio::time::sleep(interval)),
+        state: KeepAliveState::Init,
+    });
+
+    #[cfg(feature = "runtime")]
+    let last_read_at = keep_alive.as_ref().map(|_| Instant::now());
+
+    let shared = Arc::new(Mutex::new(Shared {
+        bytes,
+        #[cfg(feature = "runtime")]
+        last_read_at,
+        #[cfg(feature = "runtime")]
+        is_keep_alive_timed_out: false,
+        ping_pong,
+        ping_sent_at: None,
+        next_bdp_at,
+    }));
+
+    (
+        Recorder {
+            shared: Some(shared.clone()),
+        },
+        Ponger {
+            bdp,
+            #[cfg(feature = "runtime")]
+            keep_alive,
+            shared,
+        },
+    )
+}
+
+#[derive(Clone)]
+pub(super) struct Config {
+    pub(super) bdp_initial_window: Option<WindowSize>,
+    /// If no frames are received in this amount of time, a PING frame is sent.
+    #[cfg(feature = "runtime")]
+    pub(super) keep_alive_interval: Option<Duration>,
+    /// After sending a keepalive PING, the connection will be closed if
+    /// a pong is not received in this amount of time.
+    #[cfg(feature = "runtime")]
+    pub(super) keep_alive_timeout: Duration,
+    /// If true, sends pings even when there are no active streams.
+    #[cfg(feature = "runtime")]
+    pub(super) keep_alive_while_idle: bool,
+}
+
+#[derive(Clone)]
+pub(crate) struct Recorder {
+    shared: Option<Arc<Mutex<Shared>>>,
+}
+
+pub(super) struct Ponger {
+    bdp: Option<Bdp>,
+    #[cfg(feature = "runtime")]
+    keep_alive: Option<KeepAlive>,
+    shared: Arc<Mutex<Shared>>,
+}
+
+struct Shared {
+    ping_pong: PingPong,
+    ping_sent_at: Option<Instant>,
+
+    // bdp
+    /// If `Some`, bdp is enabled, and this tracks how many bytes have been
+    /// read during the current sample.
+    bytes: Option<usize>,
+    /// We delay a variable amount of time between BDP pings. This allows us
+    /// to send less pings as the bandwidth stabilizes.
+    next_bdp_at: Option<Instant>,
+
+    // keep-alive
+    /// If `Some`, keep-alive is enabled, and the Instant is how long ago
+    /// the connection read the last frame.
+    #[cfg(feature = "runtime")]
+    last_read_at: Option<Instant>,
+
+    #[cfg(feature = "runtime")]
+    is_keep_alive_timed_out: bool,
+}
+
+struct Bdp {
+    /// Current BDP in bytes
+    bdp: u32,
+    /// Largest bandwidth we've seen so far.
+    max_bandwidth: f64,
+    /// Round trip time in seconds
+    rtt: f64,
+    /// Delay the next ping by this amount.
+    ///
+    /// This will change depending on how stable the current bandwidth is.
+    ping_delay: Duration,
+    /// The count of ping round trips where BDP has stayed the same.
+    stable_count: u32,
+}
+
+#[cfg(feature = "runtime")]
+struct KeepAlive {
+    /// If no frames are received in this amount of time, a PING frame is sent.
+    interval: Duration,
+    /// After sending a keepalive PING, the connection will be closed if
+    /// a pong is not received in this amount of time.
+    timeout: Duration,
+    /// If true, sends pings even when there are no active streams.
+    while_idle: bool,
+
+    state: KeepAliveState,
+    timer: Pin<Box<Sleep>>,
+}
+
+#[cfg(feature = "runtime")]
+enum KeepAliveState {
+    Init,
+    Scheduled,
+    PingSent,
+}
+
+pub(super) enum Ponged {
+    SizeUpdate(WindowSize),
+    #[cfg(feature = "runtime")]
+    KeepAliveTimedOut,
+}
+
+#[cfg(feature = "runtime")]
+#[derive(Debug)]
+pub(super) struct KeepAliveTimedOut;
+
+// ===== impl Config =====
+
+impl Config {
+    pub(super) fn is_enabled(&self) -> bool {
+        #[cfg(feature = "runtime")]
+        {
+            self.bdp_initial_window.is_some() || self.keep_alive_interval.is_some()
+        }
+
+        #[cfg(not(feature = "runtime"))]
+        {
+            self.bdp_initial_window.is_some()
+        }
+    }
+}
+
+// ===== impl Recorder =====
+
+impl Recorder {
+    pub(crate) fn record_data(&self, len: usize) {
+        let shared = if let Some(ref shared) = self.shared {
+            shared
+        } else {
+            return;
+        };
+
+        let mut locked = shared.lock().unwrap();
+
+        #[cfg(feature = "runtime")]
+        locked.update_last_read_at();
+
+        // are we ready to send another bdp ping?
+        // if not, we don't need to record bytes either
+
+        if let Some(ref next_bdp_at) = locked.next_bdp_at {
+            if Instant::now() < *next_bdp_at {
+                return;
+            } else {
+                locked.next_bdp_at = None;
+            }
+        }
+
+        if let Some(ref mut bytes) = locked.bytes {
+            *bytes += len;
+        } else {
+            // no need to send bdp ping if bdp is disabled
+            return;
+        }
+
+        if !locked.is_ping_sent() {
+            locked.send_ping();
+        }
+    }
+
+    pub(crate) fn record_non_data(&self) {
+        #[cfg(feature = "runtime")]
+        {
+            let shared = if let Some(ref shared) = self.shared {
+                shared
+            } else {
+                return;
+            };
+
+            let mut locked = shared.lock().unwrap();
+
+            locked.update_last_read_at();
+        }
+    }
+
+    /// If the incoming stream is already closed, convert self into
+    /// a disabled reporter.
+    #[cfg(feature = "client")]
+    pub(super) fn for_stream(self, stream: &h2::RecvStream) -> Self {
+        if stream.is_end_stream() {
+            disabled()
+        } else {
+            self
+        }
+    }
+
+    pub(super) fn ensure_not_timed_out(&self) -> crate::Result<()> {
+        #[cfg(feature = "runtime")]
+        {
+            if let Some(ref shared) = self.shared {
+                let locked = shared.lock().unwrap();
+                if locked.is_keep_alive_timed_out {
+                    return Err(KeepAliveTimedOut.crate_error());
+                }
+            }
+        }
+
+        // else
+        Ok(())
+    }
+}
+
+// ===== impl Ponger =====
+
+impl Ponger {
+    pub(super) fn poll(&mut self, cx: &mut task::Context<'_>) -> Poll<Ponged> {
+        let now = Instant::now();
+        let mut locked = self.shared.lock().unwrap();
+        #[cfg(feature = "runtime")]
+        let is_idle = self.is_idle();
+
+        #[cfg(feature = "runtime")]
+        {
+            if let Some(ref mut ka) = self.keep_alive {
+                ka.schedule(is_idle, &locked);
+                ka.maybe_ping(cx, &mut locked);
+            }
+        }
+
+        if !locked.is_ping_sent() {
+            // XXX: this doesn't register a waker...?
+            return Poll::Pending;
+        }
+
+        match locked.ping_pong.poll_pong(cx) {
+            Poll::Ready(Ok(_pong)) => {
+                let start = locked
+                    .ping_sent_at
+                    .expect("pong received implies ping_sent_at");
+                locked.ping_sent_at = None;
+                let rtt = now - start;
+                trace!("recv pong");
+
+                #[cfg(feature = "runtime")]
+                {
+                    if let Some(ref mut ka) = self.keep_alive {
+                        locked.update_last_read_at();
+                        ka.schedule(is_idle, &locked);
+                    }
+                }
+
+                if let Some(ref mut bdp) =  self.bdp {
+                    let bytes = locked.bytes.expect("bdp enabled implies bytes");
+                    locked.bytes = Some(0); // reset
+                    trace!("received BDP ack; bytes = {}, rtt = {:?}", bytes, rtt);
+
+                    let update = bdp.calculate(bytes, rtt);
+                    locked.next_bdp_at = Some(now + bdp.ping_delay);
+                    if let Some(update) = update {
+                        return Poll::Ready(Ponged::SizeUpdate(update))
+                    }
+                }
+            }
+            Poll::Ready(Err(e)) => {
+                debug!("pong error: {}", e);
+            }
+            Poll::Pending => {
+                #[cfg(feature = "runtime")]
+                {
+                    if let Some(ref mut ka) = self.keep_alive {
+                        if let Err(KeepAliveTimedOut) = ka.maybe_timeout(cx) {
+                            self.keep_alive = None;
+                            locked.is_keep_alive_timed_out = true;
+                            return Poll::Ready(Ponged::KeepAliveTimedOut);
+                        }
+                    }
+                }
+            }
+        }
+
+        // XXX: this doesn't register a waker...?
+        Poll::Pending
+    }
+
+    #[cfg(feature = "runtime")]
+    fn is_idle(&self) -> bool {
+        Arc::strong_count(&self.shared) <= 2
+    }
+}
+
+// ===== impl Shared =====
+
+impl Shared {
+    fn send_ping(&mut self) {
+        match self.ping_pong.send_ping(Ping::opaque()) {
+            Ok(()) => {
+                self.ping_sent_at = Some(Instant::now());
+                trace!("sent ping");
+            }
+            Err(err) => {
+                debug!("error sending ping: {}", err);
+            }
+        }
+    }
+
+    fn is_ping_sent(&self) -> bool {
+        self.ping_sent_at.is_some()
+    }
+
+    #[cfg(feature = "runtime")]
+    fn update_last_read_at(&mut self) {
+        if self.last_read_at.is_some() {
+            self.last_read_at = Some(Instant::now());
+        }
+    }
+
+    #[cfg(feature = "runtime")]
+    fn last_read_at(&self) -> Instant {
+        self.last_read_at.expect("keep_alive expects last_read_at")
+    }
+}
+
+// ===== impl Bdp =====
+
+/// Any higher than this likely will be hitting the TCP flow control.
+const BDP_LIMIT: usize = 1024 * 1024 * 16;
+
+impl Bdp {
+    fn calculate(&mut self, bytes: usize, rtt: Duration) -> Option<WindowSize> {
+        // No need to do any math if we're at the limit.
+        if self.bdp as usize == BDP_LIMIT {
+            self.stabilize_delay();
+            return None;
+        }
+
+        // average the rtt
+        let rtt = seconds(rtt);
+        if self.rtt == 0.0 {
+            // First sample means rtt is first rtt.
+            self.rtt = rtt;
+        } else {
+            // Weigh this rtt as 1/8 for a moving average.
+            self.rtt += (rtt - self.rtt) * 0.125;
+        }
+
+        // calculate the current bandwidth
+        let bw = (bytes as f64) / (self.rtt * 1.5);
+        trace!("current bandwidth = {:.1}B/s", bw);
+
+        if bw < self.max_bandwidth {
+            // not a faster bandwidth, so don't update
+            self.stabilize_delay();
+            return None;
+        } else {
+            self.max_bandwidth = bw;
+        }
+
+        // if the current `bytes` sample is at least 2/3 the previous
+        // bdp, increase to double the current sample.
+        if bytes >= self.bdp as usize * 2 / 3 {
+            self.bdp = (bytes * 2).min(BDP_LIMIT) as WindowSize;
+            trace!("BDP increased to {}", self.bdp);
+
+            self.stable_count = 0;
+            self.ping_delay /= 2;
+            Some(self.bdp)
+        } else {
+            self.stabilize_delay();
+            None
+        }
+    }
+
+    fn stabilize_delay(&mut self) {
+        if self.ping_delay < Duration::from_secs(10) {
+            self.stable_count += 1;
+
+            if self.stable_count >= 2 {
+                self.ping_delay *= 4;
+                self.stable_count = 0;
+            }
+        }
+    }
+}
+
+fn seconds(dur: Duration) -> f64 {
+    const NANOS_PER_SEC: f64 = 1_000_000_000.0;
+    let secs = dur.as_secs() as f64;
+    secs + (dur.subsec_nanos() as f64) / NANOS_PER_SEC
+}
+
+// ===== impl KeepAlive =====
+
+#[cfg(feature = "runtime")]
+impl KeepAlive {
+    fn schedule(&mut self, is_idle: bool, shared: &Shared) {
+        match self.state {
+            KeepAliveState::Init => {
+                if !self.while_idle && is_idle {
+                    return;
+                }
+
+                self.state = KeepAliveState::Scheduled;
+                let interval = shared.last_read_at() + self.interval;
+                self.timer.as_mut().reset(interval);
+            }
+            KeepAliveState::PingSent => {
+                if shared.is_ping_sent() {
+                    return;
+                }
+
+                self.state = KeepAliveState::Scheduled;
+                let interval = shared.last_read_at() + self.interval;
+                self.timer.as_mut().reset(interval);
+            }
+            KeepAliveState::Scheduled => (),
+        }
+    }
+
+    fn maybe_ping(&mut self, cx: &mut task::Context<'_>, shared: &mut Shared) {
+        match self.state {
+            KeepAliveState::Scheduled => {
+                if Pin::new(&mut self.timer).poll(cx).is_pending() {
+                    return;
+                }
+                // check if we've received a frame while we were scheduled
+                if shared.last_read_at() + self.interval > self.timer.deadline() {
+                    self.state = KeepAliveState::Init;
+                    cx.waker().wake_by_ref(); // schedule us again
+                    return;
+                }
+                trace!("keep-alive interval ({:?}) reached", self.interval);
+                shared.send_ping();
+                self.state = KeepAliveState::PingSent;
+                let timeout = Instant::now() + self.timeout;
+                self.timer.as_mut().reset(timeout);
+            }
+            KeepAliveState::Init | KeepAliveState::PingSent => (),
+        }
+    }
+
+    fn maybe_timeout(&mut self, cx: &mut task::Context<'_>) -> Result<(), KeepAliveTimedOut> {
+        match self.state {
+            KeepAliveState::PingSent => {
+                if Pin::new(&mut self.timer).poll(cx).is_pending() {
+                    return Ok(());
+                }
+                trace!("keep-alive timeout ({:?}) reached", self.timeout);
+                Err(KeepAliveTimedOut)
+            }
+            KeepAliveState::Init | KeepAliveState::Scheduled => Ok(()),
+        }
+    }
+}
+
+// ===== impl KeepAliveTimedOut =====
+
+#[cfg(feature = "runtime")]
+impl KeepAliveTimedOut {
+    pub(super) fn crate_error(self) -> crate::Error {
+        crate::Error::new(crate::error::Kind::Http2).with(self)
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl fmt::Display for KeepAliveTimedOut {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("keep-alive timed out")
+    }
+}
+
+#[cfg(feature = "runtime")]
+impl std::error::Error for KeepAliveTimedOut {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        Some(&crate::error::TimedOut)
+    }
+}
diff --git a/hyper/src/proto/h2/server.rs b/hyper/src/proto/h2/server.rs
new file mode 100644
index 0000000..d24e6ba
--- /dev/null
+++ b/hyper/src/proto/h2/server.rs
@@ -0,0 +1,548 @@
+use std::error::Error as StdError;
+use std::marker::Unpin;
+#[cfg(feature = "runtime")]
+use std::time::Duration;
+
+use bytes::Bytes;
+use h2::server::{Connection, Handshake, SendResponse};
+use h2::{Reason, RecvStream};
+use http::{Method, Request};
+use pin_project_lite::pin_project;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tracing::{debug, trace, warn};
+
+use super::{ping, PipeToSendStream, SendBuf};
+use crate::body::HttpBody;
+use crate::common::exec::ConnStreamExec;
+use crate::common::{date, task, Future, Pin, Poll};
+use crate::ext::Protocol;
+use crate::headers;
+use crate::proto::h2::ping::Recorder;
+use crate::proto::h2::{H2Upgraded, UpgradedSendStream};
+use crate::proto::Dispatched;
+use crate::service::HttpService;
+
+use crate::upgrade::{OnUpgrade, Pending, Upgraded};
+use crate::{Body, Response};
+
+// Our defaults are chosen for the "majority" case, which usually are not
+// resource constrained, and so the spec default of 64kb can be too limiting
+// for performance.
+//
+// At the same time, a server more often has multiple clients connected, and
+// so is more likely to use more resources than a client would.
+const DEFAULT_CONN_WINDOW: u32 = 1024 * 1024; // 1mb
+const DEFAULT_STREAM_WINDOW: u32 = 1024 * 1024; // 1mb
+const DEFAULT_MAX_FRAME_SIZE: u32 = 1024 * 16; // 16kb
+const DEFAULT_MAX_SEND_BUF_SIZE: usize = 1024 * 400; // 400kb
+// 16 MB "sane default" taken from golang http2
+const DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE: u32 = 16 << 20;
+
+#[derive(Clone, Debug)]
+pub(crate) struct Config {
+    pub(crate) adaptive_window: bool,
+    pub(crate) initial_conn_window_size: u32,
+    pub(crate) initial_stream_window_size: u32,
+    pub(crate) max_frame_size: u32,
+    pub(crate) enable_connect_protocol: bool,
+    pub(crate) max_concurrent_streams: Option<u32>,
+    #[cfg(feature = "runtime")]
+    pub(crate) keep_alive_interval: Option<Duration>,
+    #[cfg(feature = "runtime")]
+    pub(crate) keep_alive_timeout: Duration,
+    pub(crate) max_send_buffer_size: usize,
+    pub(crate) max_header_list_size: u32,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            adaptive_window: false,
+            initial_conn_window_size: DEFAULT_CONN_WINDOW,
+            initial_stream_window_size: DEFAULT_STREAM_WINDOW,
+            max_frame_size: DEFAULT_MAX_FRAME_SIZE,
+            enable_connect_protocol: false,
+            max_concurrent_streams: None,
+            #[cfg(feature = "runtime")]
+            keep_alive_interval: None,
+            #[cfg(feature = "runtime")]
+            keep_alive_timeout: Duration::from_secs(20),
+            max_send_buffer_size: DEFAULT_MAX_SEND_BUF_SIZE,
+            max_header_list_size: DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE,
+        }
+    }
+}
+
+pin_project! {
+    pub(crate) struct Server<T, S, B, E>
+    where
+        S: HttpService<Body>,
+        B: HttpBody,
+    {
+        exec: E,
+        service: S,
+        state: State<T, B>,
+    }
+}
+
+enum State<T, B>
+where
+    B: HttpBody,
+{
+    Handshaking {
+        ping_config: ping::Config,
+        hs: Handshake<T, SendBuf<B::Data>>,
+    },
+    Serving(Serving<T, B>),
+    Closed,
+}
+
+struct Serving<T, B>
+where
+    B: HttpBody,
+{
+    ping: Option<(ping::Recorder, ping::Ponger)>,
+    conn: Connection<T, SendBuf<B::Data>>,
+    closing: Option<crate::Error>,
+}
+
+impl<T, S, B, E> Server<T, S, B, E>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: HttpService<Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    B: HttpBody + 'static,
+    E: ConnStreamExec<S::Future, B>,
+{
+    pub(crate) fn new(io: T, service: S, config: &Config, exec: E) -> Server<T, S, B, E> {
+        let mut builder = h2::server::Builder::default();
+        builder
+            .initial_window_size(config.initial_stream_window_size)
+            .initial_connection_window_size(config.initial_conn_window_size)
+            .max_frame_size(config.max_frame_size)
+            .max_header_list_size(config.max_header_list_size)
+            .max_send_buffer_size(config.max_send_buffer_size);
+        if let Some(max) = config.max_concurrent_streams {
+            builder.max_concurrent_streams(max);
+        }
+        if config.enable_connect_protocol {
+            builder.enable_connect_protocol();
+        }
+        let handshake = builder.handshake(io);
+
+        let bdp = if config.adaptive_window {
+            Some(config.initial_stream_window_size)
+        } else {
+            None
+        };
+
+        let ping_config = ping::Config {
+            bdp_initial_window: bdp,
+            #[cfg(feature = "runtime")]
+            keep_alive_interval: config.keep_alive_interval,
+            #[cfg(feature = "runtime")]
+            keep_alive_timeout: config.keep_alive_timeout,
+            // If keep-alive is enabled for servers, always enabled while
+            // idle, so it can more aggressively close dead connections.
+            #[cfg(feature = "runtime")]
+            keep_alive_while_idle: true,
+        };
+
+        Server {
+            exec,
+            state: State::Handshaking {
+                ping_config,
+                hs: handshake,
+            },
+            service,
+        }
+    }
+
+    pub(crate) fn graceful_shutdown(&mut self) {
+        trace!("graceful_shutdown");
+        match self.state {
+            State::Handshaking { .. } => {
+                // fall-through, to replace state with Closed
+            }
+            State::Serving(ref mut srv) => {
+                if srv.closing.is_none() {
+                    srv.conn.graceful_shutdown();
+                }
+                return;
+            }
+            State::Closed => {
+                return;
+            }
+        }
+        self.state = State::Closed;
+    }
+}
+
+impl<T, S, B, E> Future for Server<T, S, B, E>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: HttpService<Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    B: HttpBody + 'static,
+    E: ConnStreamExec<S::Future, B>,
+{
+    type Output = crate::Result<Dispatched>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let me = &mut *self;
+        loop {
+            let next = match me.state {
+                State::Handshaking {
+                    ref mut hs,
+                    ref ping_config,
+                } => {
+                    let mut conn = ready!(Pin::new(hs).poll(cx).map_err(crate::Error::new_h2))?;
+                    let ping = if ping_config.is_enabled() {
+                        let pp = conn.ping_pong().expect("conn.ping_pong");
+                        Some(ping::channel(pp, ping_config.clone()))
+                    } else {
+                        None
+                    };
+                    State::Serving(Serving {
+                        ping,
+                        conn,
+                        closing: None,
+                    })
+                }
+                State::Serving(ref mut srv) => {
+                    ready!(srv.poll_server(cx, &mut me.service, &mut me.exec))?;
+                    return Poll::Ready(Ok(Dispatched::Shutdown));
+                }
+                State::Closed => {
+                    // graceful_shutdown was called before handshaking finished,
+                    // nothing to do here...
+                    return Poll::Ready(Ok(Dispatched::Shutdown));
+                }
+            };
+            me.state = next;
+        }
+    }
+}
+
+impl<T, B> Serving<T, B>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    B: HttpBody + 'static,
+{
+    fn poll_server<S, E>(
+        &mut self,
+        cx: &mut task::Context<'_>,
+        service: &mut S,
+        exec: &mut E,
+    ) -> Poll<crate::Result<()>>
+    where
+        S: HttpService<Body, ResBody = B>,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        E: ConnStreamExec<S::Future, B>,
+    {
+        if self.closing.is_none() {
+            loop {
+                self.poll_ping(cx);
+
+                // Check that the service is ready to accept a new request.
+                //
+                // - If not, just drive the connection some.
+                // - If ready, try to accept a new request from the connection.
+                match service.poll_ready(cx) {
+                    Poll::Ready(Ok(())) => (),
+                    Poll::Pending => {
+                        // use `poll_closed` instead of `poll_accept`,
+                        // in order to avoid accepting a request.
+                        ready!(self.conn.poll_closed(cx).map_err(crate::Error::new_h2))?;
+                        trace!("incoming connection complete");
+                        return Poll::Ready(Ok(()));
+                    }
+                    Poll::Ready(Err(err)) => {
+                        let err = crate::Error::new_user_service(err);
+                        debug!("service closed: {}", err);
+
+                        let reason = err.h2_reason();
+                        if reason == Reason::NO_ERROR {
+                            // NO_ERROR is only used for graceful shutdowns...
+                            trace!("interpreting NO_ERROR user error as graceful_shutdown");
+                            self.conn.graceful_shutdown();
+                        } else {
+                            trace!("abruptly shutting down with {:?}", reason);
+                            self.conn.abrupt_shutdown(reason);
+                        }
+                        self.closing = Some(err);
+                        break;
+                    }
+                }
+
+                // When the service is ready, accepts an incoming request.
+                match ready!(self.conn.poll_accept(cx)) {
+                    Some(Ok((req, mut respond))) => {
+                        trace!("incoming request");
+                        let content_length = headers::content_length_parse_all(req.headers());
+                        let ping = self
+                            .ping
+                            .as_ref()
+                            .map(|ping| ping.0.clone())
+                            .unwrap_or_else(ping::disabled);
+
+                        // Record the headers received
+                        ping.record_non_data();
+
+                        let is_connect = req.method() == Method::CONNECT;
+                        let (mut parts, stream) = req.into_parts();
+                        let (mut req, connect_parts) = if !is_connect {
+                            (
+                                Request::from_parts(
+                                    parts,
+                                    crate::Body::h2(stream, content_length.into(), ping),
+                                ),
+                                None,
+                            )
+                        } else {
+                            if content_length.map_or(false, |len| len != 0) {
+                                warn!("h2 connect request with non-zero body not supported");
+                                respond.send_reset(h2::Reason::INTERNAL_ERROR);
+                                return Poll::Ready(Ok(()));
+                            }
+                            let (pending, upgrade) = crate::upgrade::pending();
+                            debug_assert!(parts.extensions.get::<OnUpgrade>().is_none());
+                            parts.extensions.insert(upgrade);
+                            (
+                                Request::from_parts(parts, crate::Body::empty()),
+                                Some(ConnectParts {
+                                    pending,
+                                    ping,
+                                    recv_stream: stream,
+                                }),
+                            )
+                        };
+
+                        if let Some(protocol) = req.extensions_mut().remove::<h2::ext::Protocol>() {
+                            req.extensions_mut().insert(Protocol::from_inner(protocol));
+                        }
+
+                        let fut = H2Stream::new(service.call(req), connect_parts, respond);
+                        exec.execute_h2stream(fut);
+                    }
+                    Some(Err(e)) => {
+                        return Poll::Ready(Err(crate::Error::new_h2(e)));
+                    }
+                    None => {
+                        // no more incoming streams...
+                        if let Some((ref ping, _)) = self.ping {
+                            ping.ensure_not_timed_out()?;
+                        }
+
+                        trace!("incoming connection complete");
+                        return Poll::Ready(Ok(()));
+                    }
+                }
+            }
+        }
+
+        debug_assert!(
+            self.closing.is_some(),
+            "poll_server broke loop without closing"
+        );
+
+        ready!(self.conn.poll_closed(cx).map_err(crate::Error::new_h2))?;
+
+        Poll::Ready(Err(self.closing.take().expect("polled after error")))
+    }
+
+    fn poll_ping(&mut self, cx: &mut task::Context<'_>) {
+        if let Some((_, ref mut estimator)) = self.ping {
+            match estimator.poll(cx) {
+                Poll::Ready(ping::Ponged::SizeUpdate(wnd)) => {
+                    self.conn.set_target_window_size(wnd);
+                    let _ = self.conn.set_initial_window_size(wnd);
+                }
+                #[cfg(feature = "runtime")]
+                Poll::Ready(ping::Ponged::KeepAliveTimedOut) => {
+                    debug!("keep-alive timed out, closing connection");
+                    self.conn.abrupt_shutdown(h2::Reason::NO_ERROR);
+                }
+                Poll::Pending => {}
+            }
+        }
+    }
+}
+
+pin_project! {
+    #[allow(missing_debug_implementations)]
+    pub struct H2Stream<F, B>
+    where
+        B: HttpBody,
+    {
+        reply: SendResponse<SendBuf<B::Data>>,
+        #[pin]
+        state: H2StreamState<F, B>,
+    }
+}
+
+pin_project! {
+    #[project = H2StreamStateProj]
+    enum H2StreamState<F, B>
+    where
+        B: HttpBody,
+    {
+        Service {
+            #[pin]
+            fut: F,
+            connect_parts: Option<ConnectParts>,
+        },
+        Body {
+            #[pin]
+            pipe: PipeToSendStream<B>,
+        },
+    }
+}
+
+struct ConnectParts {
+    pending: Pending,
+    ping: Recorder,
+    recv_stream: RecvStream,
+}
+
+impl<F, B> H2Stream<F, B>
+where
+    B: HttpBody,
+{
+    fn new(
+        fut: F,
+        connect_parts: Option<ConnectParts>,
+        respond: SendResponse<SendBuf<B::Data>>,
+    ) -> H2Stream<F, B> {
+        H2Stream {
+            reply: respond,
+            state: H2StreamState::Service { fut, connect_parts },
+        }
+    }
+}
+
+macro_rules! reply {
+    ($me:expr, $res:expr, $eos:expr) => {{
+        match $me.reply.send_response($res, $eos) {
+            Ok(tx) => tx,
+            Err(e) => {
+                debug!("send response error: {}", e);
+                $me.reply.send_reset(Reason::INTERNAL_ERROR);
+                return Poll::Ready(Err(crate::Error::new_h2(e)));
+            }
+        }
+    }};
+}
+
+impl<F, B, E> H2Stream<F, B>
+where
+    F: Future<Output = Result<Response<B>, E>>,
+    B: HttpBody,
+    B::Data: 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: Into<Box<dyn StdError + Send + Sync>>,
+{
+    fn poll2(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<crate::Result<()>> {
+        let mut me = self.project();
+        loop {
+            let next = match me.state.as_mut().project() {
+                H2StreamStateProj::Service {
+                    fut: h,
+                    connect_parts,
+                } => {
+                    let res = match h.poll(cx) {
+                        Poll::Ready(Ok(r)) => r,
+                        Poll::Pending => {
+                            // Response is not yet ready, so we want to check if the client has sent a
+                            // RST_STREAM frame which would cancel the current request.
+                            if let Poll::Ready(reason) =
+                                me.reply.poll_reset(cx).map_err(crate::Error::new_h2)?
+                            {
+                                debug!("stream received RST_STREAM: {:?}", reason);
+                                return Poll::Ready(Err(crate::Error::new_h2(reason.into())));
+                            }
+                            return Poll::Pending;
+                        }
+                        Poll::Ready(Err(e)) => {
+                            let err = crate::Error::new_user_service(e);
+                            warn!("http2 service errored: {}", err);
+                            me.reply.send_reset(err.h2_reason());
+                            return Poll::Ready(Err(err));
+                        }
+                    };
+
+                    let (head, body) = res.into_parts();
+                    let mut res = ::http::Response::from_parts(head, ());
+                    super::strip_connection_headers(res.headers_mut(), false);
+
+                    // set Date header if it isn't already set...
+                    res.headers_mut()
+                        .entry(::http::header::DATE)
+                        .or_insert_with(date::update_and_header_value);
+
+                    if let Some(connect_parts) = connect_parts.take() {
+                        if res.status().is_success() {
+                            if headers::content_length_parse_all(res.headers())
+                                .map_or(false, |len| len != 0)
+                            {
+                                warn!("h2 successful response to CONNECT request with body not supported");
+                                me.reply.send_reset(h2::Reason::INTERNAL_ERROR);
+                                return Poll::Ready(Err(crate::Error::new_user_header()));
+                            }
+                            let send_stream = reply!(me, res, false);
+                            connect_parts.pending.fulfill(Upgraded::new(
+                                H2Upgraded {
+                                    ping: connect_parts.ping,
+                                    recv_stream: connect_parts.recv_stream,
+                                    send_stream: unsafe { UpgradedSendStream::new(send_stream) },
+                                    buf: Bytes::new(),
+                                },
+                                Bytes::new(),
+                            ));
+                            return Poll::Ready(Ok(()));
+                        }
+                    }
+
+
+                    if !body.is_end_stream() {
+                        // automatically set Content-Length from body...
+                        if let Some(len) = body.size_hint().exact() {
+                            headers::set_content_length_if_missing(res.headers_mut(), len);
+                        }
+
+                        let body_tx = reply!(me, res, false);
+                        H2StreamState::Body {
+                            pipe: PipeToSendStream::new(body, body_tx),
+                        }
+                    } else {
+                        reply!(me, res, true);
+                        return Poll::Ready(Ok(()));
+                    }
+                }
+                H2StreamStateProj::Body { pipe } => {
+                    return pipe.poll(cx);
+                }
+            };
+            me.state.set(next);
+        }
+    }
+}
+
+impl<F, B, E> Future for H2Stream<F, B>
+where
+    F: Future<Output = Result<Response<B>, E>>,
+    B: HttpBody,
+    B::Data: 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        self.poll2(cx).map(|res| {
+            if let Err(e) = res {
+                debug!("stream error: {}", e);
+            }
+        })
+    }
+}
diff --git a/hyper/src/proto/mod.rs b/hyper/src/proto/mod.rs
new file mode 100644
index 0000000..f938bf5
--- /dev/null
+++ b/hyper/src/proto/mod.rs
@@ -0,0 +1,71 @@
+//! Pieces pertaining to the HTTP message protocol.
+
+cfg_feature! {
+    #![feature = "http1"]
+
+    pub(crate) mod h1;
+
+    pub(crate) use self::h1::Conn;
+
+    #[cfg(feature = "client")]
+    pub(crate) use self::h1::dispatch;
+    #[cfg(feature = "server")]
+    pub(crate) use self::h1::ServerTransaction;
+}
+
+#[cfg(feature = "http2")]
+pub(crate) mod h2;
+
+/// An Incoming Message head. Includes request/status line, and headers.
+#[derive(Debug, Default)]
+pub(crate) struct MessageHead<S> {
+    /// HTTP version of the message.
+    pub(crate) version: http::Version,
+    /// Subject (request line or status line) of Incoming message.
+    pub(crate) subject: S,
+    /// Headers of the Incoming message.
+    pub(crate) headers: http::HeaderMap,
+    /// Extensions.
+    extensions: http::Extensions,
+}
+
+/// An incoming request message.
+#[cfg(feature = "http1")]
+pub(crate) type RequestHead = MessageHead<RequestLine>;
+
+#[derive(Debug, Default, PartialEq)]
+#[cfg(feature = "http1")]
+pub(crate) struct RequestLine(pub(crate) http::Method, pub(crate) http::Uri);
+
+/// An incoming response message.
+#[cfg(all(feature = "http1", feature = "client"))]
+pub(crate) type ResponseHead = MessageHead<http::StatusCode>;
+
+#[derive(Debug)]
+#[cfg(feature = "http1")]
+pub(crate) enum BodyLength {
+    /// Content-Length
+    Known(u64),
+    /// Transfer-Encoding: chunked (if h1)
+    Unknown,
+}
+
+/// Status of when a Disaptcher future completes.
+pub(crate) enum Dispatched {
+    /// Dispatcher completely shutdown connection.
+    Shutdown,
+    /// Dispatcher has pending upgrade, and so did not shutdown.
+    #[cfg(feature = "http1")]
+    Upgrade(crate::upgrade::Pending),
+}
+
+impl MessageHead<http::StatusCode> {
+    fn into_response<B>(self, body: B) -> http::Response<B> {
+        let mut res = http::Response::new(body);
+        *res.status_mut() = self.subject;
+        *res.headers_mut() = self.headers;
+        *res.version_mut() = self.version;
+        *res.extensions_mut() = self.extensions;
+        res
+    }
+}
diff --git a/hyper/src/rt.rs b/hyper/src/rt.rs
new file mode 100644
index 0000000..2614b59
--- /dev/null
+++ b/hyper/src/rt.rs
@@ -0,0 +1,12 @@
+//! Runtime components
+//!
+//! By default, hyper includes the [tokio](https://tokio.rs) runtime.
+//!
+//! If the `runtime` feature is disabled, the types in this module can be used
+//! to plug in other runtimes.
+
+/// An executor of futures.
+pub trait Executor<Fut> {
+    /// Place the future into the executor to be run.
+    fn execute(&self, fut: Fut);
+}
diff --git a/hyper/src/server/accept.rs b/hyper/src/server/accept.rs
new file mode 100644
index 0000000..708cdd1
--- /dev/null
+++ b/hyper/src/server/accept.rs
@@ -0,0 +1,96 @@
+//! The `Accept` trait and supporting types.
+//!
+//! This module contains:
+//!
+//! - The [`Accept`](Accept) trait used to asynchronously accept incoming
+//!   connections.
+//! - Utilities like `poll_fn` to ease creating a custom `Accept`.
+#[cfg(feature = "stream")]
+use futures_core::Stream;
+#[cfg(feature = "stream")]
+use pin_project_lite::pin_project;
+use crate::common::{
+    task::{self, Poll},
+    Pin,
+};
+/// Asynchronously accept incoming connections.
+pub trait Accept {
+    /// The connection type that can be accepted.
+    type Conn;
+    /// The error type that can occur when accepting a connection.
+    type Error;
+    /// Poll to accept the next connection.
+    fn poll_accept(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<Result<Self::Conn, Self::Error>>>;
+}
+/// Create an `Accept` with a polling function.
+///
+/// # Example
+///
+/// ```
+/// use std::task::Poll;
+/// use hyper::server::{accept, Server};
+///
+/// # let mock_conn = ();
+/// // If we created some mocked connection...
+/// let mut conn = Some(mock_conn);
+///
+/// // And accept just the mocked conn once...
+/// let once = accept::poll_fn(move |cx| {
+///     Poll::Ready(conn.take().map(Ok::<_, ()>))
+/// });
+///
+/// let builder = Server::builder(once);
+/// ```
+pub(crate) fn poll_fn<F, IO, E>(func: F) -> impl Accept<Conn = IO, Error = E>
+where
+    F: FnMut(&mut task::Context<'_>) -> Poll<Option<Result<IO, E>>>,
+{
+    struct PollFn<F>(F);
+    impl<F> Unpin for PollFn<F> {}
+    impl<F, IO, E> Accept for PollFn<F>
+    where
+        F: FnMut(&mut task::Context<'_>) -> Poll<Option<Result<IO, E>>>,
+    {
+        type Conn = IO;
+        type Error = E;
+        fn poll_accept(
+            self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+        ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
+            (self.get_mut().0)(cx)
+        }
+    }
+    PollFn(func)
+}
+/// Adapt a `Stream` of incoming connections into an `Accept`.
+///
+/// # Optional
+///
+/// This function requires enabling the `stream` feature in your
+/// `Cargo.toml`.
+#[cfg(feature = "stream")]
+pub fn from_stream<S, IO, E>(stream: S) -> impl Accept<Conn = IO, Error = E>
+where
+    S: Stream<Item = Result<IO, E>>,
+{
+    pin_project! {
+        struct FromStream < S > { #[pin] stream : S, }
+    }
+    impl<S, IO, E> Accept for FromStream<S>
+    where
+        S: Stream<Item = Result<IO, E>>,
+    {
+        type Conn = IO;
+        type Error = E;
+        fn poll_accept(
+            self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+        ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
+            self.project().stream.poll_next(cx)
+        }
+    }
+    FromStream { stream }
+}
diff --git a/hyper/src/server/conn.rs b/hyper/src/server/conn.rs
new file mode 100644
index 0000000..7a0df11
--- /dev/null
+++ b/hyper/src/server/conn.rs
@@ -0,0 +1,961 @@
+//! Lower-level Server connection API.
+//!
+//! The types in this module are to provide a lower-level API based around a
+//! single connection. Accepting a connection and binding it with a service
+//! are not handled at this level. This module provides the building blocks to
+//! customize those things externally.
+//!
+//! If you don't have need to manage connections yourself, consider using the
+//! higher-level [Server](super) API.
+//!
+//! ## Example
+//! A simple example that uses the `Http` struct to talk HTTP over a Tokio TCP stream
+//! ```no_run
+//! # #[cfg(all(feature = "http1", feature = "runtime"))]
+//! # mod rt {
+//! use http::{Request, Response, StatusCode};
+//! use hyper::{server::conn::Http, service::service_fn, Body};
+//! use std::{net::SocketAddr, convert::Infallible};
+//! use tokio::net::TcpListener;
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+//!     let addr: SocketAddr = ([127, 0, 0, 1], 8080).into();
+//!
+//!     let mut tcp_listener = TcpListener::bind(addr).await?;
+//!     loop {
+//!         let (tcp_stream, _) = tcp_listener.accept().await?;
+//!         tokio::task::spawn(async move {
+//!             if let Err(http_err) = Http::new()
+//!                     .http1_only(true)
+//!                     .http1_keep_alive(true)
+//!                     .serve_connection(tcp_stream, service_fn(hello))
+//!                     .await {
+//!                 eprintln!("Error while serving HTTP connection: {}", http_err);
+//!             }
+//!         });
+//!     }
+//! }
+//!
+//! async fn hello(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
+//!    Ok(Response::new(Body::from("Hello World!")))
+//! }
+//! # }
+//! ```
+#[cfg(
+    all(
+        any(feature = "http1", feature = "http2"),
+        not(all(feature = "http1", feature = "http2"))
+    )
+)]
+use std::marker::PhantomData;
+#[cfg(all(any(feature = "http1", feature = "http2"), feature = "runtime"))]
+use std::time::Duration;
+#[cfg(feature = "http2")]
+use crate::common::io::Rewind;
+#[cfg(all(feature = "http1", feature = "http2"))]
+use crate::error::{Kind, Parse};
+#[cfg(feature = "http1")]
+use crate::upgrade::Upgraded;
+cfg_feature! {
+    #![any(feature = "http1", feature = "http2")] use std::error::Error as StdError; use
+    std::fmt; use bytes::Bytes; use pin_project_lite::pin_project; use tokio::io:: {
+    AsyncRead, AsyncWrite }; use tracing::trace; pub use super::server::Connecting; use
+    crate ::body:: { Body, HttpBody }; use crate ::common:: { task, Future, Pin, Poll,
+    Unpin }; #[cfg(not(all(feature = "http1", feature = "http2")))] use crate
+    ::common::Never; use crate ::common::exec:: { ConnStreamExec, Exec }; use crate
+    ::proto; use crate ::service::HttpService; pub (super) use
+    self::upgrades::UpgradeableConnection;
+}
+#[cfg(feature = "tcp")]
+pub use super::tcp::{AddrIncoming, AddrStream};
+/// A lower-level configuration of the HTTP protocol.
+///
+/// This structure is used to configure options for an HTTP server connection.
+///
+/// If you don't have need to manage connections yourself, consider using the
+/// higher-level [Server](super) API.
+#[derive(Clone, Debug)]
+#[cfg(any(feature = "http1", feature = "http2"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+pub(crate) struct Http<E = Exec> {
+    pub(crate) exec: E,
+    h1_half_close: bool,
+    h1_keep_alive: bool,
+    h1_title_case_headers: bool,
+    h1_preserve_header_case: bool,
+    #[cfg(all(feature = "http1", feature = "runtime"))]
+    h1_header_read_timeout: Option<Duration>,
+    h1_writev: Option<bool>,
+    #[cfg(feature = "http2")]
+    h2_builder: proto::h2::server::Config,
+    mode: ConnectionMode,
+    max_buf_size: Option<usize>,
+    pipeline_flush: bool,
+}
+/// The internal mode of HTTP protocol which indicates the behavior when a parse error occurs.
+#[cfg(any(feature = "http1", feature = "http2"))]
+#[derive(Clone, Debug, PartialEq)]
+enum ConnectionMode {
+    /// Always use HTTP/1 and do not upgrade when a parse error occurs.
+    #[cfg(feature = "http1")]
+    H1Only,
+    /// Always use HTTP/2.
+    #[cfg(feature = "http2")]
+    H2Only,
+    /// Use HTTP/1 and try to upgrade to h2 when a parse error occurs.
+    #[cfg(all(feature = "http1", feature = "http2"))]
+    Fallback,
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+pin_project! {
+    #[doc = " A future binding a connection with a Service."] #[doc = ""] #[doc =
+    " Polling this future will drive HTTP forward."] #[must_use =
+    "futures do nothing unless polled"] #[cfg_attr(docsrs, doc(cfg(any(feature = "http1",
+    feature = "http2"))))] pub struct Connection < T, S, E = Exec > where S : HttpService
+    < Body >, { pub (super) conn : Option < ProtoServer < T, S::ResBody, S, E >>,
+    fallback : Fallback < E >, }
+}
+#[cfg(feature = "http1")]
+type Http1Dispatcher<T, B, S> = proto::h1::Dispatcher<
+    proto::h1::dispatch::Server<S, Body>,
+    B,
+    T,
+    proto::ServerTransaction,
+>;
+#[cfg(all(not(feature = "http1"), feature = "http2"))]
+type Http1Dispatcher<T, B, S> = (Never, PhantomData<(T, Box<Pin<B>>, Box<Pin<S>>)>);
+#[cfg(feature = "http2")]
+type Http2Server<T, B, S, E> = proto::h2::Server<Rewind<T>, S, B, E>;
+#[cfg(all(not(feature = "http2"), feature = "http1"))]
+type Http2Server<T, B, S, E> = (
+    Never,
+    PhantomData<(T, Box<Pin<S>>, Box<Pin<B>>, Box<Pin<E>>)>,
+);
+#[cfg(any(feature = "http1", feature = "http2"))]
+pin_project! {
+    #[project = ProtoServerProj] pub (super) enum ProtoServer < T, B, S, E = Exec > where
+    S : HttpService < Body >, B : HttpBody, { H1 { #[pin] h1 : Http1Dispatcher < T, B, S
+    >, }, H2 { #[pin] h2 : Http2Server < T, B, S, E >, }, }
+}
+#[cfg(all(feature = "http1", feature = "http2"))]
+#[derive(Clone, Debug)]
+enum Fallback<E> {
+    ToHttp2(proto::h2::server::Config, E),
+    Http1Only,
+}
+#[cfg(
+    all(
+        any(feature = "http1", feature = "http2"),
+        not(all(feature = "http1", feature = "http2"))
+    )
+)]
+type Fallback<E> = PhantomData<E>;
+#[cfg(all(feature = "http1", feature = "http2"))]
+impl<E> Fallback<E> {
+    fn to_h2(&self) -> bool {
+        match *self {
+            Fallback::ToHttp2(..) => true,
+            Fallback::Http1Only => false,
+        }
+    }
+}
+#[cfg(all(feature = "http1", feature = "http2"))]
+impl<E> Unpin for Fallback<E> {}
+/// Deconstructed parts of a `Connection`.
+///
+/// This allows taking apart a `Connection` at a later time, in order to
+/// reclaim the IO object, and additional related pieces.
+#[derive(Debug)]
+#[cfg(any(feature = "http1", feature = "http2"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+pub(crate) struct Parts<T, S> {
+    /// The original IO object used in the handshake.
+    pub(crate) io: T,
+    /// A buffer of bytes that have been read but not processed as HTTP.
+    ///
+    /// If the client sent additional bytes after its last request, and
+    /// this connection "ended" with an upgrade, the read buffer will contain
+    /// those bytes.
+    ///
+    /// You will want to check for any existing bytes if you plan to continue
+    /// communicating on the IO object.
+    pub(crate) read_buf: Bytes,
+    /// The `Service` used to serve this connection.
+    pub(crate) service: S,
+    _inner: (),
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl Http {
+    /// Creates a new instance of the HTTP protocol, ready to spawn a server or
+    /// start accepting connections.
+    pub(crate) fn new() -> Http {
+        Http {
+            exec: Exec::Default,
+            h1_half_close: false,
+            h1_keep_alive: true,
+            h1_title_case_headers: false,
+            h1_preserve_header_case: false,
+            #[cfg(all(feature = "http1", feature = "runtime"))]
+            h1_header_read_timeout: None,
+            h1_writev: None,
+            #[cfg(feature = "http2")]
+            h2_builder: Default::default(),
+            mode: ConnectionMode::default(),
+            max_buf_size: None,
+            pipeline_flush: false,
+        }
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl<E> Http<E> {
+    /// Sets whether HTTP1 is required.
+    ///
+    /// Default is false
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_only(&mut self, val: bool) -> &mut Self {
+        if val {
+            self.mode = ConnectionMode::H1Only;
+        } else {
+            #[cfg(feature = "http2")]
+            {
+                self.mode = ConnectionMode::Fallback;
+            }
+        }
+        self
+    }
+    /// Set whether HTTP/1 connections should support half-closures.
+    ///
+    /// Clients can chose to shutdown their write-side while waiting
+    /// for the server to respond. Setting this to `true` will
+    /// prevent closing the connection immediately if `read`
+    /// detects an EOF in the middle of a request.
+    ///
+    /// Default is `false`.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_half_close(&mut self, val: bool) -> &mut Self {
+        self.h1_half_close = val;
+        self
+    }
+    /// Enables or disables HTTP/1 keep-alive.
+    ///
+    /// Default is true.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_keep_alive(&mut self, val: bool) -> &mut Self {
+        self.h1_keep_alive = val;
+        self
+    }
+    /// Set whether HTTP/1 connections will write header names as title case at
+    /// the socket level.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_title_case_headers(&mut self, enabled: bool) -> &mut Self {
+        self.h1_title_case_headers = enabled;
+        self
+    }
+    /// Set whether to support preserving original header cases.
+    ///
+    /// Currently, this will record the original cases received, and store them
+    /// in a private extension on the `Request`. It will also look for and use
+    /// such an extension in any provided `Response`.
+    ///
+    /// Since the relevant extension is still private, there is no way to
+    /// interact with the original cases. The only effect this can have now is
+    /// to forward the cases in a proxy-like fashion.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_preserve_header_case(&mut self, enabled: bool) -> &mut Self {
+        self.h1_preserve_header_case = enabled;
+        self
+    }
+    /// Set a timeout for reading client request headers. If a client does not
+    /// transmit the entire header within this time, the connection is closed.
+    ///
+    /// Default is None.
+    #[cfg(all(feature = "http1", feature = "runtime"))]
+    #[cfg_attr(docsrs, doc(cfg(all(feature = "http1", feature = "runtime"))))]
+    pub(crate) fn http1_header_read_timeout(
+        &mut self,
+        read_timeout: Duration,
+    ) -> &mut Self {
+        self.h1_header_read_timeout = Some(read_timeout);
+        self
+    }
+    /// Set whether HTTP/1 connections should try to use vectored writes,
+    /// or always flatten into a single buffer.
+    ///
+    /// Note that setting this to false may mean more copies of body data,
+    /// but may also improve performance when an IO transport doesn't
+    /// support vectored writes well, such as most TLS implementations.
+    ///
+    /// Setting this to true will force hyper to use queued strategy
+    /// which may eliminate unnecessary cloning on some TLS backends
+    ///
+    /// Default is `auto`. In this mode hyper will try to guess which
+    /// mode to use
+    #[inline]
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_writev(&mut self, val: bool) -> &mut Self {
+        self.h1_writev = Some(val);
+        self
+    }
+    /// Sets whether HTTP2 is required.
+    ///
+    /// Default is false
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_only(&mut self, val: bool) -> &mut Self {
+        if val {
+            self.mode = ConnectionMode::H2Only;
+        } else {
+            #[cfg(feature = "http1")]
+            {
+                self.mode = ConnectionMode::Fallback;
+            }
+        }
+        self
+    }
+    /// Sets the [`SETTINGS_INITIAL_WINDOW_SIZE`][spec] option for HTTP2
+    /// stream-level flow control.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    ///
+    /// [spec]: https://http2.github.io/http2-spec/#SETTINGS_INITIAL_WINDOW_SIZE
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_stream_window_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        if let Some(sz) = sz.into() {
+            self.h2_builder.adaptive_window = false;
+            self.h2_builder.initial_stream_window_size = sz;
+        }
+        self
+    }
+    /// Sets the max connection-level flow control for HTTP2.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_connection_window_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        if let Some(sz) = sz.into() {
+            self.h2_builder.adaptive_window = false;
+            self.h2_builder.initial_conn_window_size = sz;
+        }
+        self
+    }
+    /// Sets whether to use an adaptive flow control.
+    ///
+    /// Enabling this will override the limits set in
+    /// `http2_initial_stream_window_size` and
+    /// `http2_initial_connection_window_size`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_adaptive_window(&mut self, enabled: bool) -> &mut Self {
+        use proto::h2::SPEC_WINDOW_SIZE;
+        self.h2_builder.adaptive_window = enabled;
+        if enabled {
+            self.h2_builder.initial_conn_window_size = SPEC_WINDOW_SIZE;
+            self.h2_builder.initial_stream_window_size = SPEC_WINDOW_SIZE;
+        }
+        self
+    }
+    /// Sets the maximum frame size to use for HTTP2.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_frame_size(
+        &mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        if let Some(sz) = sz.into() {
+            self.h2_builder.max_frame_size = sz;
+        }
+        self
+    }
+    /// Sets the [`SETTINGS_MAX_CONCURRENT_STREAMS`][spec] option for HTTP2
+    /// connections.
+    ///
+    /// Default is no limit (`std::u32::MAX`). Passing `None` will do nothing.
+    ///
+    /// [spec]: https://http2.github.io/http2-spec/#SETTINGS_MAX_CONCURRENT_STREAMS
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_concurrent_streams(
+        &mut self,
+        max: impl Into<Option<u32>>,
+    ) -> &mut Self {
+        self.h2_builder.max_concurrent_streams = max.into();
+        self
+    }
+    /// Sets an interval for HTTP2 Ping frames should be sent to keep a
+    /// connection alive.
+    ///
+    /// Pass `None` to disable HTTP2 keep-alive.
+    ///
+    /// Default is currently disabled.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_interval(
+        &mut self,
+        interval: impl Into<Option<Duration>>,
+    ) -> &mut Self {
+        self.h2_builder.keep_alive_interval = interval.into();
+        self
+    }
+    /// Sets a timeout for receiving an acknowledgement of the keep-alive ping.
+    ///
+    /// If the ping is not acknowledged within the timeout, the connection will
+    /// be closed. Does nothing if `http2_keep_alive_interval` is disabled.
+    ///
+    /// Default is 20 seconds.
+    ///
+    /// # Cargo Feature
+    ///
+    /// Requires the `runtime` cargo feature to be enabled.
+    #[cfg(feature = "runtime")]
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_keep_alive_timeout(&mut self, timeout: Duration) -> &mut Self {
+        self.h2_builder.keep_alive_timeout = timeout;
+        self
+    }
+    /// Set the maximum write buffer size for each HTTP/2 stream.
+    ///
+    /// Default is currently ~400KB, but may change.
+    ///
+    /// # Panics
+    ///
+    /// The value must be no larger than `u32::MAX`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_send_buf_size(&mut self, max: usize) -> &mut Self {
+        assert!(max <= std::u32::MAX as usize);
+        self.h2_builder.max_send_buffer_size = max;
+        self
+    }
+    /// Enables the [extended CONNECT protocol].
+    ///
+    /// [extended CONNECT protocol]: https://datatracker.ietf.org/doc/html/rfc8441#section-4
+    #[cfg(feature = "http2")]
+    pub(crate) fn http2_enable_connect_protocol(&mut self) -> &mut Self {
+        self.h2_builder.enable_connect_protocol = true;
+        self
+    }
+    /// Sets the max size of received header frames.
+    ///
+    /// Default is currently ~16MB, but may change.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_header_list_size(&mut self, max: u32) -> &mut Self {
+        self.h2_builder.max_header_list_size = max;
+        self
+    }
+    /// Set the maximum buffer size for the connection.
+    ///
+    /// Default is ~400kb.
+    ///
+    /// # Panics
+    ///
+    /// The minimum value allowed is 8192. This method panics if the passed `max` is less than the minimum.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn max_buf_size(&mut self, max: usize) -> &mut Self {
+        assert!(
+            max >= proto::h1::MINIMUM_MAX_BUFFER_SIZE,
+            "the max_buf_size cannot be smaller than the minimum that h1 specifies."
+        );
+        self.max_buf_size = Some(max);
+        self
+    }
+    /// Aggregates flushes to better support pipelined responses.
+    ///
+    /// Experimental, may have bugs.
+    ///
+    /// Default is false.
+    pub(crate) fn pipeline_flush(&mut self, enabled: bool) -> &mut Self {
+        self.pipeline_flush = enabled;
+        self
+    }
+    /// Set the executor used to spawn background tasks.
+    ///
+    /// Default uses implicit default (like `tokio::spawn`).
+    pub(crate) fn with_executor<E2>(self, exec: E2) -> Http<E2> {
+        Http {
+            exec,
+            h1_half_close: self.h1_half_close,
+            h1_keep_alive: self.h1_keep_alive,
+            h1_title_case_headers: self.h1_title_case_headers,
+            h1_preserve_header_case: self.h1_preserve_header_case,
+            #[cfg(all(feature = "http1", feature = "runtime"))]
+            h1_header_read_timeout: self.h1_header_read_timeout,
+            h1_writev: self.h1_writev,
+            #[cfg(feature = "http2")]
+            h2_builder: self.h2_builder,
+            mode: self.mode,
+            max_buf_size: self.max_buf_size,
+            pipeline_flush: self.pipeline_flush,
+        }
+    }
+    /// Bind a connection together with a [`Service`](crate::service::Service).
+    ///
+    /// This returns a Future that must be polled in order for HTTP to be
+    /// driven on the connection.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use hyper::{Body, Request, Response};
+    /// # use hyper::service::Service;
+    /// # use hyper::server::conn::Http;
+    /// # use tokio::io::{AsyncRead, AsyncWrite};
+    /// # async fn run<I, S>(some_io: I, some_service: S)
+    /// # where
+    /// #     I: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    /// #     S: Service<hyper::Request<Body>, Response=hyper::Response<Body>> + Send + 'static,
+    /// #     S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    /// #     S::Future: Send,
+    /// # {
+    /// let http = Http::new();
+    /// let conn = http.serve_connection(some_io, some_service);
+    ///
+    /// if let Err(e) = conn.await {
+    ///     eprintln!("server connection error: {}", e);
+    /// }
+    /// # }
+    /// # fn main() {}
+    /// ```
+    pub(crate) fn serve_connection<S, I, Bd>(
+        &self,
+        io: I,
+        service: S,
+    ) -> Connection<I, S, E>
+    where
+        S: HttpService<Body, ResBody = Bd>,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        Bd: HttpBody + 'static,
+        Bd::Error: Into<Box<dyn StdError + Send + Sync>>,
+        I: AsyncRead + AsyncWrite + Unpin,
+        E: ConnStreamExec<S::Future, Bd>,
+    {
+        #[cfg(feature = "http1")]
+        macro_rules! h1 {
+            () => {
+                { let mut conn = proto::Conn::new(io); if ! self.h1_keep_alive { conn
+                .disable_keep_alive(); } if self.h1_half_close { conn
+                .set_allow_half_close(); } if self.h1_title_case_headers { conn
+                .set_title_case_headers(); } if self.h1_preserve_header_case { conn
+                .set_preserve_header_case(); } #[cfg(all(feature = "http1", feature =
+                "runtime"))] if let Some(header_read_timeout) = self
+                .h1_header_read_timeout { conn
+                .set_http1_header_read_timeout(header_read_timeout); } if let
+                Some(writev) = self.h1_writev { if writev { conn
+                .set_write_strategy_queue(); } else { conn.set_write_strategy_flatten();
+                } } conn.set_flush_pipeline(self.pipeline_flush); if let Some(max) = self
+                .max_buf_size { conn.set_max_buf_size(max); } let sd =
+                proto::h1::dispatch::Server::new(service); ProtoServer::H1 { h1 :
+                proto::h1::Dispatcher::new(sd, conn), } }
+            };
+        }
+        let proto = match self.mode {
+            #[cfg(feature = "http1")]
+            #[cfg(not(feature = "http2"))]
+            ConnectionMode::H1Only => h1!(),
+            #[cfg(feature = "http2")]
+            #[cfg(feature = "http1")]
+            ConnectionMode::H1Only | ConnectionMode::Fallback => h1!(),
+            #[cfg(feature = "http2")]
+            ConnectionMode::H2Only => {
+                let rewind_io = Rewind::new(io);
+                let h2 = proto::h2::Server::new(
+                    rewind_io,
+                    service,
+                    &self.h2_builder,
+                    self.exec.clone(),
+                );
+                ProtoServer::H2 { h2 }
+            }
+        };
+        Connection {
+            conn: Some(proto),
+            #[cfg(all(feature = "http1", feature = "http2"))]
+            fallback: if self.mode == ConnectionMode::Fallback {
+                Fallback::ToHttp2(self.h2_builder.clone(), self.exec.clone())
+            } else {
+                Fallback::Http1Only
+            },
+            #[cfg(not(all(feature = "http1", feature = "http2")))]
+            fallback: PhantomData,
+        }
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl<I, B, S, E> Connection<I, S, E>
+where
+    S: HttpService<Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    I: AsyncRead + AsyncWrite + Unpin,
+    B: HttpBody + 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: ConnStreamExec<S::Future, B>,
+{
+    /// Start a graceful shutdown process for this connection.
+    ///
+    /// This `Connection` should continue to be polled until shutdown
+    /// can finish.
+    ///
+    /// # Note
+    ///
+    /// This should only be called while the `Connection` future is still
+    /// pending. If called after `Connection::poll` has resolved, this does
+    /// nothing.
+    pub(crate) fn graceful_shutdown(mut self: Pin<&mut Self>) {
+        match self.conn {
+            #[cfg(feature = "http1")]
+            Some(ProtoServer::H1 { ref mut h1, .. }) => {
+                h1.disable_keep_alive();
+            }
+            #[cfg(feature = "http2")]
+            Some(ProtoServer::H2 { ref mut h2 }) => {
+                h2.graceful_shutdown();
+            }
+            None => {}
+            #[cfg(not(feature = "http1"))]
+            Some(ProtoServer::H1 { ref mut h1, .. }) => match h1.0 {}
+            #[cfg(not(feature = "http2"))]
+            Some(ProtoServer::H2 { ref mut h2 }) => match h2.0 {}
+        }
+    }
+    /// Return the inner IO object, and additional information.
+    ///
+    /// If the IO object has been "rewound" the io will not contain those bytes rewound.
+    /// This should only be called after `poll_without_shutdown` signals
+    /// that the connection is "done". Otherwise, it may not have finished
+    /// flushing all necessary HTTP bytes.
+    ///
+    /// # Panics
+    /// This method will panic if this connection is using an h2 protocol.
+    pub(crate) fn into_parts(self) -> Parts<I, S> {
+        self.try_into_parts().unwrap_or_else(|| panic!("h2 cannot into_inner"))
+    }
+    /// Return the inner IO object, and additional information, if available.
+    ///
+    /// This method will return a `None` if this connection is using an h2 protocol.
+    pub(crate) fn try_into_parts(self) -> Option<Parts<I, S>> {
+        match self.conn.unwrap() {
+            #[cfg(feature = "http1")]
+            ProtoServer::H1 { h1, .. } => {
+                let (io, read_buf, dispatch) = h1.into_inner();
+                Some(Parts {
+                    io,
+                    read_buf,
+                    service: dispatch.into_service(),
+                    _inner: (),
+                })
+            }
+            ProtoServer::H2 { .. } => None,
+            #[cfg(not(feature = "http1"))]
+            ProtoServer::H1 { h1, .. } => match h1.0 {}
+        }
+    }
+    /// Poll the connection for completion, but without calling `shutdown`
+    /// on the underlying IO.
+    ///
+    /// This is useful to allow running a connection while doing an HTTP
+    /// upgrade. Once the upgrade is completed, the connection would be "done",
+    /// but it is not desired to actually shutdown the IO object. Instead you
+    /// would take it back using `into_parts`.
+    pub(crate) fn poll_without_shutdown(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<crate::Result<()>>
+    where
+        S: Unpin,
+        S::Future: Unpin,
+        B: Unpin,
+    {
+        loop {
+            match *self.conn.as_mut().unwrap() {
+                #[cfg(feature = "http1")]
+                ProtoServer::H1 { ref mut h1, .. } => {
+                    match ready!(h1.poll_without_shutdown(cx)) {
+                        Ok(()) => return Poll::Ready(Ok(())),
+                        Err(e) => {
+                            #[cfg(feature = "http2")]
+                            match *e.kind() {
+                                Kind::Parse(Parse::VersionH2) if self.fallback.to_h2() => {
+                                    self.upgrade_h2();
+                                    continue;
+                                }
+                                _ => {}
+                            }
+                            return Poll::Ready(Err(e));
+                        }
+                    }
+                }
+                #[cfg(feature = "http2")]
+                ProtoServer::H2 { ref mut h2 } => {
+                    return Pin::new(h2).poll(cx).map_ok(|_| ());
+                }
+                #[cfg(not(feature = "http1"))]
+                ProtoServer::H1 { ref mut h1, .. } => match h1.0 {}
+                #[cfg(not(feature = "http2"))]
+                ProtoServer::H2 { ref mut h2 } => match h2.0 {}
+            };
+        }
+    }
+    /// Prevent shutdown of the underlying IO object at the end of service the request,
+    /// instead run `into_parts`. This is a convenience wrapper over `poll_without_shutdown`.
+    ///
+    /// # Error
+    ///
+    /// This errors if the underlying connection protocol is not HTTP/1.
+    pub(crate) fn without_shutdown(
+        self,
+    ) -> impl Future<Output = crate::Result<Parts<I, S>>>
+    where
+        S: Unpin,
+        S::Future: Unpin,
+        B: Unpin,
+    {
+        let mut conn = Some(self);
+        futures_util::future::poll_fn(move |cx| {
+            ready!(conn.as_mut().unwrap().poll_without_shutdown(cx))?;
+            Poll::Ready(
+                conn
+                    .take()
+                    .unwrap()
+                    .try_into_parts()
+                    .ok_or_else(crate::Error::new_without_shutdown_not_h1),
+            )
+        })
+    }
+    #[cfg(all(feature = "http1", feature = "http2"))]
+    fn upgrade_h2(&mut self) {
+        trace!("Trying to upgrade connection to h2");
+        let conn = self.conn.take();
+        let (io, read_buf, dispatch) = match conn.unwrap() {
+            ProtoServer::H1 { h1, .. } => h1.into_inner(),
+            ProtoServer::H2 { .. } => {
+                panic!("h2 cannot into_inner");
+            }
+        };
+        let mut rewind_io = Rewind::new(io);
+        rewind_io.rewind(read_buf);
+        let (builder, exec) = match self.fallback {
+            Fallback::ToHttp2(ref builder, ref exec) => (builder, exec),
+            Fallback::Http1Only => unreachable!("upgrade_h2 with Fallback::Http1Only"),
+        };
+        let h2 = proto::h2::Server::new(
+            rewind_io,
+            dispatch.into_service(),
+            builder,
+            exec.clone(),
+        );
+        debug_assert!(self.conn.is_none());
+        self.conn = Some(ProtoServer::H2 { h2 });
+    }
+    /// Enable this connection to support higher-level HTTP upgrades.
+    ///
+    /// See [the `upgrade` module](crate::upgrade) for more.
+    pub(crate) fn with_upgrades(self) -> UpgradeableConnection<I, S, E>
+    where
+        I: Send,
+    {
+        UpgradeableConnection {
+            inner: self,
+        }
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl<I, B, S, E> Future for Connection<I, S, E>
+where
+    S: HttpService<Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    I: AsyncRead + AsyncWrite + Unpin + 'static,
+    B: HttpBody + 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: ConnStreamExec<S::Future, B>,
+{
+    type Output = crate::Result<()>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        loop {
+            match ready!(Pin::new(self.conn.as_mut().unwrap()).poll(cx)) {
+                Ok(done) => {
+                    match done {
+                        proto::Dispatched::Shutdown => {}
+                        #[cfg(feature = "http1")]
+                        proto::Dispatched::Upgrade(pending) => {
+                            pending.manual();
+                        }
+                    };
+                    return Poll::Ready(Ok(()));
+                }
+                Err(e) => {
+                    #[cfg(feature = "http1")] #[cfg(feature = "http2")]
+                    match *e.kind() {
+                        Kind::Parse(Parse::VersionH2) if self.fallback.to_h2() => {
+                            self.upgrade_h2();
+                            continue;
+                        }
+                        _ => {}
+                    }
+                    return Poll::Ready(Err(e));
+                }
+            }
+        }
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl<I, S> fmt::Debug for Connection<I, S>
+where
+    S: HttpService<Body>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Connection").finish()
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl Default for ConnectionMode {
+    #[cfg(all(feature = "http1", feature = "http2"))]
+    fn default() -> ConnectionMode {
+        ConnectionMode::Fallback
+    }
+    #[cfg(all(feature = "http1", not(feature = "http2")))]
+    fn default() -> ConnectionMode {
+        ConnectionMode::H1Only
+    }
+    #[cfg(all(not(feature = "http1"), feature = "http2"))]
+    fn default() -> ConnectionMode {
+        ConnectionMode::H2Only
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl<T, B, S, E> Future for ProtoServer<T, B, S, E>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: HttpService<Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    B: HttpBody + 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: ConnStreamExec<S::Future, B>,
+{
+    type Output = crate::Result<proto::Dispatched>;
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        match self.project() {
+            #[cfg(feature = "http1")]
+            ProtoServerProj::H1 { h1, .. } => h1.poll(cx),
+            #[cfg(feature = "http2")]
+            ProtoServerProj::H2 { h2 } => h2.poll(cx),
+            #[cfg(not(feature = "http1"))]
+            ProtoServerProj::H1 { h1, .. } => match h1.0 {}
+            #[cfg(not(feature = "http2"))]
+            ProtoServerProj::H2 { h2 } => match h2.0 {}
+        }
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+mod upgrades {
+    use super::*;
+    #[must_use = "futures do nothing unless polled"]
+    #[allow(missing_debug_implementations)]
+    pub struct UpgradeableConnection<T, S, E>
+    where
+        S: HttpService<Body>,
+    {
+        pub(super) inner: Connection<T, S, E>,
+    }
+    impl<I, B, S, E> UpgradeableConnection<I, S, E>
+    where
+        S: HttpService<Body, ResBody = B>,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        I: AsyncRead + AsyncWrite + Unpin,
+        B: HttpBody + 'static,
+        B::Error: Into<Box<dyn StdError + Send + Sync>>,
+        E: ConnStreamExec<S::Future, B>,
+    {
+        /// Start a graceful shutdown process for this connection.
+        ///
+        /// This `Connection` should continue to be polled until shutdown
+        /// can finish.
+        pub(crate) fn graceful_shutdown(mut self: Pin<&mut Self>) {
+            Pin::new(&mut self.inner).graceful_shutdown()
+        }
+    }
+    impl<I, B, S, E> Future for UpgradeableConnection<I, S, E>
+    where
+        S: HttpService<Body, ResBody = B>,
+        S::Error: Into<Box<dyn StdError + Send + Sync>>,
+        I: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+        B: HttpBody + 'static,
+        B::Error: Into<Box<dyn StdError + Send + Sync>>,
+        E: ConnStreamExec<S::Future, B>,
+    {
+        type Output = crate::Result<()>;
+        fn poll(
+            mut self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+        ) -> Poll<Self::Output> {
+            loop {
+                match ready!(Pin::new(self.inner.conn.as_mut().unwrap()).poll(cx)) {
+                    Ok(proto::Dispatched::Shutdown) => return Poll::Ready(Ok(())),
+                    #[cfg(feature = "http1")]
+                    Ok(proto::Dispatched::Upgrade(pending)) => {
+                        match self.inner.conn.take() {
+                            Some(ProtoServer::H1 { h1, .. }) => {
+                                let (io, buf, _) = h1.into_inner();
+                                pending.fulfill(Upgraded::new(io, buf));
+                                return Poll::Ready(Ok(()));
+                            }
+                            _ => {
+                                drop(pending);
+                                unreachable!("Upgrade expects h1")
+                            }
+                        };
+                    }
+                    Err(e) => {
+                        #[cfg(feature = "http1")] #[cfg(feature = "http2")]
+                        match *e.kind() {
+                            Kind::Parse(
+                                Parse::VersionH2,
+                            ) if self.inner.fallback.to_h2() => {
+                                self.inner.upgrade_h2();
+                                continue;
+                            }
+                            _ => {}
+                        }
+                        return Poll::Ready(Err(e));
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/hyper/src/server/mod.rs b/hyper/src/server/mod.rs
new file mode 100644
index 0000000..e763d0e
--- /dev/null
+++ b/hyper/src/server/mod.rs
@@ -0,0 +1,172 @@
+//! HTTP Server
+//!
+//! A `Server` is created to listen on a port, parse HTTP requests, and hand
+//! them off to a `Service`.
+//!
+//! There are two levels of APIs provide for constructing HTTP servers:
+//!
+//! - The higher-level [`Server`](Server) type.
+//! - The lower-level [`conn`](conn) module.
+//!
+//! # Server
+//!
+//! The [`Server`](Server) is main way to start listening for HTTP requests.
+//! It wraps a listener with a [`MakeService`](crate::service), and then should
+//! be executed to start serving requests.
+//!
+//! [`Server`](Server) accepts connections in both HTTP1 and HTTP2 by default.
+//!
+//! ## Examples
+//!
+//! ```no_run
+//! use std::convert::Infallible;
+//! use std::net::SocketAddr;
+//! use hyper::{Body, Request, Response, Server};
+//! use hyper::service::{make_service_fn, service_fn};
+//!
+//! async fn handle(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
+//!     Ok(Response::new(Body::from("Hello World")))
+//! }
+//!
+//! # #[cfg(feature = "runtime")]
+//! #[tokio::main]
+//! async fn main() {
+//!     // Construct our SocketAddr to listen on...
+//!     let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+//!
+//!     // And a MakeService to handle each connection...
+//!     let make_service = make_service_fn(|_conn| async {
+//!         Ok::<_, Infallible>(service_fn(handle))
+//!     });
+//!
+//!     // Then bind and serve...
+//!     let server = Server::bind(&addr).serve(make_service);
+//!
+//!     // And run forever...
+//!     if let Err(e) = server.await {
+//!         eprintln!("server error: {}", e);
+//!     }
+//! }
+//! # #[cfg(not(feature = "runtime"))]
+//! # fn main() {}
+//! ```
+//!
+//! If you don't need the connection and your service implements `Clone` you can use
+//! [`tower::make::Shared`] instead of `make_service_fn` which is a bit simpler:
+//!
+//! ```no_run
+//! # use std::convert::Infallible;
+//! # use std::net::SocketAddr;
+//! # use hyper::{Body, Request, Response, Server};
+//! # use hyper::service::{make_service_fn, service_fn};
+//! # use tower::make::Shared;
+//! # async fn handle(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
+//! #     Ok(Response::new(Body::from("Hello World")))
+//! # }
+//! # #[cfg(feature = "runtime")]
+//! #[tokio::main]
+//! async fn main() {
+//!     // Construct our SocketAddr to listen on...
+//!     let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+//!
+//!     // Shared is a MakeService that produces services by cloning an inner service...
+//!     let make_service = Shared::new(service_fn(handle));
+//!
+//!     // Then bind and serve...
+//!     let server = Server::bind(&addr).serve(make_service);
+//!
+//!     // And run forever...
+//!     if let Err(e) = server.await {
+//!         eprintln!("server error: {}", e);
+//!     }
+//! }
+//! # #[cfg(not(feature = "runtime"))]
+//! # fn main() {}
+//! ```
+//!
+//! Passing data to your request handler can be done like so:
+//!
+//! ```no_run
+//! use std::convert::Infallible;
+//! use std::net::SocketAddr;
+//! use hyper::{Body, Request, Response, Server};
+//! use hyper::service::{make_service_fn, service_fn};
+//! # #[cfg(feature = "runtime")]
+//! use hyper::server::conn::AddrStream;
+//!
+//! #[derive(Clone)]
+//! struct AppContext {
+//!     // Whatever data your application needs can go here
+//! }
+//!
+//! async fn handle(
+//!     context: AppContext,
+//!     addr: SocketAddr,
+//!     req: Request<Body>
+//! ) -> Result<Response<Body>, Infallible> {
+//!     Ok(Response::new(Body::from("Hello World")))
+//! }
+//!
+//! # #[cfg(feature = "runtime")]
+//! #[tokio::main]
+//! async fn main() {
+//!     let context = AppContext {
+//!         // ...
+//!     };
+//!
+//!     // A `MakeService` that produces a `Service` to handle each connection.
+//!     let make_service = make_service_fn(move |conn: &AddrStream| {
+//!         // We have to clone the context to share it with each invocation of
+//!         // `make_service`. If your data doesn't implement `Clone` consider using
+//!         // an `std::sync::Arc`.
+//!         let context = context.clone();
+//!
+//!         // You can grab the address of the incoming connection like so.
+//!         let addr = conn.remote_addr();
+//!
+//!         // Create a `Service` for responding to the request.
+//!         let service = service_fn(move |req| {
+//!             handle(context.clone(), addr, req)
+//!         });
+//!
+//!         // Return the service to hyper.
+//!         async move { Ok::<_, Infallible>(service) }
+//!     });
+//!
+//!     // Run the server like above...
+//!     let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+//!
+//!     let server = Server::bind(&addr).serve(make_service);
+//!
+//!     if let Err(e) = server.await {
+//!         eprintln!("server error: {}", e);
+//!     }
+//! }
+//! # #[cfg(not(feature = "runtime"))]
+//! # fn main() {}
+//! ```
+//!
+//! [`tower::make::Shared`]: https://docs.rs/tower/latest/tower/make/struct.Shared.html
+
+pub mod accept;
+pub mod conn;
+#[cfg(feature = "tcp")]
+mod tcp;
+
+pub use self::server::Server;
+
+cfg_feature! {
+    #![any(feature = "http1", feature = "http2")]
+
+    pub(crate) mod server;
+    pub use self::server::Builder;
+
+    mod shutdown;
+}
+
+cfg_feature! {
+    #![not(any(feature = "http1", feature = "http2"))]
+
+    mod server_stub;
+    use server_stub as server;
+}
diff --git a/hyper/src/server/server.rs b/hyper/src/server/server.rs
new file mode 100644
index 0000000..b6c0c0d
--- /dev/null
+++ b/hyper/src/server/server.rs
@@ -0,0 +1,598 @@
+use std::error::Error as StdError;
+use std::fmt;
+#[cfg(feature = "tcp")]
+use std::net::{SocketAddr, TcpListener as StdTcpListener};
+#[cfg(feature = "tcp")]
+use std::time::Duration;
+use pin_project_lite::pin_project;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tracing::trace;
+use super::accept::Accept;
+#[cfg(all(feature = "tcp"))]
+use super::tcp::AddrIncoming;
+use crate::body::{Body, HttpBody};
+use crate::common::exec::Exec;
+use crate::common::exec::{ConnStreamExec, NewSvcExec};
+use crate::common::{task, Future, Pin, Poll, Unpin};
+use super::conn::{Connection, Http as Http_, UpgradeableConnection};
+use super::shutdown::{Graceful, GracefulWatcher};
+use crate::service::{HttpService, MakeServiceRef};
+use self::new_svc::NewSvcTask;
+pin_project! {
+    #[doc =
+    " A listening HTTP server that accepts connections in both HTTP1 and HTTP2 by default."]
+    #[doc = ""] #[doc =
+    " `Server` is a `Future` mapping a bound listener with a set of service"] #[doc =
+    " handlers. It is built using the [`Builder`](Builder), and the future"] #[doc =
+    " completes when the server has been shutdown. It should be run by an"] #[doc =
+    " `Executor`."] pub struct Server < I, S, E = Exec > { #[pin] incoming : I,
+    make_service : S, protocol : Http_ < E >, }
+}
+/// A builder for a [`Server`](Server).
+#[derive(Debug)]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+pub struct Builder<I, E = Exec> {
+    incoming: I,
+    protocol: Http_<E>,
+}
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+impl<I> Server<I, ()> {
+    /// Starts a [`Builder`](Builder) with the provided incoming stream.
+    pub fn builder(incoming: I) -> Builder<I> {
+        Builder {
+            incoming,
+            protocol: Http_::new(),
+        }
+    }
+}
+#[cfg(feature = "tcp")]
+#[cfg_attr(
+    docsrs,
+    doc(cfg(all(feature = "tcp", any(feature = "http1", feature = "http2"))))
+)]
+impl Server<AddrIncoming, ()> {
+    /// Binds to the provided address, and returns a [`Builder`](Builder).
+    ///
+    /// # Panics
+    ///
+    /// This method will panic if binding to the address fails. For a method
+    /// to bind to an address and return a `Result`, see `Server::try_bind`.
+    pub fn bind(addr: &SocketAddr) -> Builder<AddrIncoming> {
+        loop {}
+    }
+    /// Tries to bind to the provided address, and returns a [`Builder`](Builder).
+    pub(crate) fn try_bind(addr: &SocketAddr) -> crate::Result<Builder<AddrIncoming>> {
+        AddrIncoming::new(addr).map(Server::builder)
+    }
+    /// Create a new instance from a `std::net::TcpListener` instance.
+    pub(crate) fn from_tcp(
+        listener: StdTcpListener,
+    ) -> Result<Builder<AddrIncoming>, crate::Error> {
+        AddrIncoming::from_std(listener).map(Server::builder)
+    }
+}
+#[cfg(feature = "tcp")]
+#[cfg_attr(
+    docsrs,
+    doc(cfg(all(feature = "tcp", any(feature = "http1", feature = "http2"))))
+)]
+impl<S, E> Server<AddrIncoming, S, E> {
+    /// Returns the local address that this server is bound to.
+    pub(crate) fn local_addr(&self) -> SocketAddr {
+        self.incoming.local_addr()
+    }
+}
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+impl<I, IO, IE, S, E, B> Server<I, S, E>
+where
+    I: Accept<Conn = IO, Error = IE>,
+    IE: Into<Box<dyn StdError + Send + Sync>>,
+    IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    S: MakeServiceRef<IO, Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    B: HttpBody + 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
+{
+    /// Prepares a server to handle graceful shutdown when the provided future
+    /// completes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # fn main() {}
+    /// # #[cfg(feature = "tcp")]
+    /// # async fn run() {
+    /// # use hyper::{Body, Response, Server, Error};
+    /// # use hyper::service::{make_service_fn, service_fn};
+    /// # let make_service = make_service_fn(|_| async {
+    /// #     Ok::<_, Error>(service_fn(|_req| async {
+    /// #         Ok::<_, Error>(Response::new(Body::from("Hello World")))
+    /// #     }))
+    /// # });
+    /// // Make a server from the previous examples...
+    /// let server = Server::bind(&([127, 0, 0, 1], 3000).into())
+    ///     .serve(make_service);
+    ///
+    /// // Prepare some signal for when the server should start shutting down...
+    /// let (tx, rx) = tokio::sync::oneshot::channel::<()>();
+    /// let graceful = server
+    ///     .with_graceful_shutdown(async {
+    ///         rx.await.ok();
+    ///     });
+    ///
+    /// // Await the `server` receiving the signal...
+    /// if let Err(e) = graceful.await {
+    ///     eprintln!("server error: {}", e);
+    /// }
+    ///
+    /// // And later, trigger the signal by calling `tx.send(())`.
+    /// let _ = tx.send(());
+    /// # }
+    /// ```
+    pub fn with_graceful_shutdown<F>(self, signal: F) -> Graceful<I, S, F, E>
+    where
+        F: Future<Output = ()>,
+        E: NewSvcExec<IO, S::Future, S::Service, E, GracefulWatcher>,
+    {
+        Graceful::new(self, signal)
+    }
+    fn poll_next_(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<crate::Result<Connecting<IO, S::Future, E>>>> {
+        let me = self.project();
+        match ready!(me.make_service.poll_ready_ref(cx)) {
+            Ok(()) => {}
+            Err(e) => {
+                trace!("make_service closed");
+                return Poll::Ready(Some(Err(crate::Error::new_user_make_service(e))));
+            }
+        }
+        if let Some(item) = ready!(me.incoming.poll_accept(cx)) {
+            let io = item.map_err(crate::Error::new_accept)?;
+            let new_fut = me.make_service.make_service_ref(&io);
+            Poll::Ready(
+                Some(
+                    Ok(Connecting {
+                        future: new_fut,
+                        io: Some(io),
+                        protocol: me.protocol.clone(),
+                    }),
+                ),
+            )
+        } else {
+            Poll::Ready(None)
+        }
+    }
+    pub(super) fn poll_watch<W>(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        watcher: &W,
+    ) -> Poll<crate::Result<()>>
+    where
+        E: NewSvcExec<IO, S::Future, S::Service, E, W>,
+        W: Watcher<IO, S::Service, E>,
+    {
+        loop {
+            if let Some(connecting) = ready!(self.as_mut().poll_next_(cx) ?) {
+                let fut = NewSvcTask::new(connecting, watcher.clone());
+                self.as_mut().project().protocol.exec.execute_new_svc(fut);
+            } else {
+                return Poll::Ready(Ok(()));
+            }
+        }
+    }
+}
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+impl<I, IO, IE, S, B, E> Future for Server<I, S, E>
+where
+    I: Accept<Conn = IO, Error = IE>,
+    IE: Into<Box<dyn StdError + Send + Sync>>,
+    IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    S: MakeServiceRef<IO, Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    B: HttpBody + 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
+    E: NewSvcExec<IO, S::Future, S::Service, E, NoopWatcher>,
+{
+    type Output = crate::Result<()>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        loop {
+            if let Some(connecting) = ready!(self.as_mut().poll_next_(cx) ?) {
+                let fut = NewSvcTask::new(connecting, NoopWatcher);
+                self.as_mut().project().protocol.exec.execute_new_svc(fut);
+            } else {
+                loop {}
+            }
+        }
+    }
+}
+impl<I: fmt::Debug, S: fmt::Debug> fmt::Debug for Server<I, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut st = f.debug_struct("Server");
+        st.field("listener", &self.incoming);
+        st.finish()
+    }
+}
+#[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))]
+impl<I, E> Builder<I, E> {
+    /// Start a new builder, wrapping an incoming stream and low-level options.
+    ///
+    /// For a more convenient constructor, see [`Server::bind`](Server::bind).
+    pub(crate) fn new(incoming: I, protocol: Http_<E>) -> Self {
+        Builder { incoming, protocol }
+    }
+    /// Sets whether to use keep-alive for HTTP/1 connections.
+    ///
+    /// Default is `true`.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_keepalive(mut self, val: bool) -> Self {
+        self.protocol.http1_keep_alive(val);
+        self
+    }
+    /// Set whether HTTP/1 connections should support half-closures.
+    ///
+    /// Clients can chose to shutdown their write-side while waiting
+    /// for the server to respond. Setting this to `true` will
+    /// prevent closing the connection immediately if `read`
+    /// detects an EOF in the middle of a request.
+    ///
+    /// Default is `false`.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_half_close(mut self, val: bool) -> Self {
+        self.protocol.http1_half_close(val);
+        self
+    }
+    /// Set the maximum buffer size.
+    ///
+    /// Default is ~ 400kb.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_max_buf_size(mut self, val: usize) -> Self {
+        self.protocol.max_buf_size(val);
+        self
+    }
+    #[doc(hidden)]
+    #[cfg(feature = "http1")]
+    pub fn http1_pipeline_flush(mut self, val: bool) -> Self {
+        self.protocol.pipeline_flush(val);
+        self
+    }
+    /// Set whether HTTP/1 connections should try to use vectored writes,
+    /// or always flatten into a single buffer.
+    ///
+    /// Note that setting this to false may mean more copies of body data,
+    /// but may also improve performance when an IO transport doesn't
+    /// support vectored writes well, such as most TLS implementations.
+    ///
+    /// Setting this to true will force hyper to use queued strategy
+    /// which may eliminate unnecessary cloning on some TLS backends
+    ///
+    /// Default is `auto`. In this mode hyper will try to guess which
+    /// mode to use
+    #[cfg(feature = "http1")]
+    pub(crate) fn http1_writev(mut self, enabled: bool) -> Self {
+        self.protocol.http1_writev(enabled);
+        self
+    }
+    /// Set whether HTTP/1 connections will write header names as title case at
+    /// the socket level.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_title_case_headers(mut self, val: bool) -> Self {
+        self.protocol.http1_title_case_headers(val);
+        self
+    }
+    /// Set whether to support preserving original header cases.
+    ///
+    /// Currently, this will record the original cases received, and store them
+    /// in a private extension on the `Request`. It will also look for and use
+    /// such an extension in any provided `Response`.
+    ///
+    /// Since the relevant extension is still private, there is no way to
+    /// interact with the original cases. The only effect this can have now is
+    /// to forward the cases in a proxy-like fashion.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_preserve_header_case(mut self, val: bool) -> Self {
+        self.protocol.http1_preserve_header_case(val);
+        self
+    }
+    /// Set a timeout for reading client request headers. If a client does not
+    /// transmit the entire header within this time, the connection is closed.
+    ///
+    /// Default is None.
+    #[cfg(all(feature = "http1", feature = "runtime"))]
+    #[cfg_attr(docsrs, doc(cfg(all(feature = "http1", feature = "runtime"))))]
+    pub(crate) fn http1_header_read_timeout(mut self, read_timeout: Duration) -> Self {
+        self.protocol.http1_header_read_timeout(read_timeout);
+        self
+    }
+    /// Sets whether HTTP/1 is required.
+    ///
+    /// Default is `false`.
+    #[cfg(feature = "http1")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http1")))]
+    pub(crate) fn http1_only(mut self, val: bool) -> Self {
+        self.protocol.http1_only(val);
+        self
+    }
+    /// Sets whether HTTP/2 is required.
+    ///
+    /// Default is `false`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_only(mut self, val: bool) -> Self {
+        self.protocol.http2_only(val);
+        self
+    }
+    /// Sets the [`SETTINGS_INITIAL_WINDOW_SIZE`][spec] option for HTTP2
+    /// stream-level flow control.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    ///
+    /// [spec]: https://http2.github.io/http2-spec/#SETTINGS_INITIAL_WINDOW_SIZE
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_stream_window_size(
+        mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> Self {
+        self.protocol.http2_initial_stream_window_size(sz.into());
+        self
+    }
+    /// Sets the max connection-level flow control for HTTP2
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_initial_connection_window_size(
+        mut self,
+        sz: impl Into<Option<u32>>,
+    ) -> Self {
+        self.protocol.http2_initial_connection_window_size(sz.into());
+        self
+    }
+    /// Sets whether to use an adaptive flow control.
+    ///
+    /// Enabling this will override the limits set in
+    /// `http2_initial_stream_window_size` and
+    /// `http2_initial_connection_window_size`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_adaptive_window(mut self, enabled: bool) -> Self {
+        self.protocol.http2_adaptive_window(enabled);
+        self
+    }
+    /// Sets the maximum frame size to use for HTTP2.
+    ///
+    /// Passing `None` will do nothing.
+    ///
+    /// If not set, hyper will use a default.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_frame_size(mut self, sz: impl Into<Option<u32>>) -> Self {
+        self.protocol.http2_max_frame_size(sz);
+        self
+    }
+    /// Sets the max size of received header frames.
+    ///
+    /// Default is currently ~16MB, but may change.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_header_list_size(mut self, max: u32) -> Self {
+        self.protocol.http2_max_header_list_size(max);
+        self
+    }
+    /// Sets the [`SETTINGS_MAX_CONCURRENT_STREAMS`][spec] option for HTTP2
+    /// connections.
+    ///
+    /// Default is no limit (`std::u32::MAX`). Passing `None` will do nothing.
+    ///
+    /// [spec]: https://http2.github.io/http2-spec/#SETTINGS_MAX_CONCURRENT_STREAMS
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_concurrent_streams(
+        mut self,
+        max: impl Into<Option<u32>>,
+    ) -> Self {
+        self.protocol.http2_max_concurrent_streams(max.into());
+        self
+    }
+    /// Set the maximum write buffer size for each HTTP/2 stream.
+    ///
+    /// Default is currently ~400KB, but may change.
+    ///
+    /// # Panics
+    ///
+    /// The value must be no larger than `u32::MAX`.
+    #[cfg(feature = "http2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "http2")))]
+    pub(crate) fn http2_max_send_buf_size(mut self, max: usize) -> Self {
+        self.protocol.http2_max_send_buf_size(max);
+        self
+    }
+    /// Enables the [extended CONNECT protocol].
+    ///
+    /// [extended CONNECT protocol]: https://datatracker.ietf.org/doc/html/rfc8441#section-4
+    #[cfg(feature = "http2")]
+    pub(crate) fn http2_enable_connect_protocol(mut self) -> Self {
+        self.protocol.http2_enable_connect_protocol();
+        self
+    }
+    /// Sets the `Executor` to deal with connection tasks.
+    ///
+    /// Default is `tokio::spawn`.
+    pub(crate) fn executor<E2>(self, executor: E2) -> Builder<I, E2> {
+        Builder {
+            incoming: self.incoming,
+            protocol: self.protocol.with_executor(executor),
+        }
+    }
+    ///
+    pub fn serve<S, B>(self, _: S) -> Server<I, S>
+    where
+        I: Accept,
+        I::Error: Into<Box<dyn StdError + Send + Sync>>,
+        S: MakeServiceRef<I::Conn, Body, ResBody = B>,
+    {
+        loop {}
+    }
+}
+#[cfg(feature = "tcp")]
+#[cfg_attr(
+    docsrs,
+    doc(cfg(all(feature = "tcp", any(feature = "http1", feature = "http2"))))
+)]
+impl<E> Builder<AddrIncoming, E> {
+    /// Set the duration to remain idle before sending TCP keepalive probes.
+    ///
+    /// If `None` is specified, keepalive is disabled.
+    pub(crate) fn tcp_keepalive(mut self, keepalive: Option<Duration>) -> Self {
+        self.incoming.set_keepalive(keepalive);
+        self
+    }
+    /// Set the duration between two successive TCP keepalive retransmissions,
+    /// if acknowledgement to the previous keepalive transmission is not received.
+    pub(crate) fn tcp_keepalive_interval(mut self, interval: Option<Duration>) -> Self {
+        self.incoming.set_keepalive_interval(interval);
+        self
+    }
+    /// Set the number of retransmissions to be carried out before declaring that remote end is not available.
+    pub(crate) fn tcp_keepalive_retries(mut self, retries: Option<u32>) -> Self {
+        self.incoming.set_keepalive_retries(retries);
+        self
+    }
+    /// Set the value of `TCP_NODELAY` option for accepted connections.
+    pub(crate) fn tcp_nodelay(mut self, enabled: bool) -> Self {
+        self.incoming.set_nodelay(enabled);
+        self
+    }
+    /// Set whether to sleep on accept errors.
+    ///
+    /// A possible scenario is that the process has hit the max open files
+    /// allowed, and so trying to accept a new connection will fail with
+    /// EMFILE. In some cases, it's preferable to just wait for some time, if
+    /// the application will likely close some files (or connections), and try
+    /// to accept the connection again. If this option is true, the error will
+    /// be logged at the error level, since it is still a big deal, and then
+    /// the listener will sleep for 1 second.
+    ///
+    /// In other cases, hitting the max open files should be treat similarly
+    /// to being out-of-memory, and simply error (and shutdown). Setting this
+    /// option to false will allow that.
+    ///
+    /// For more details see [`AddrIncoming::set_sleep_on_errors`]
+    pub(crate) fn tcp_sleep_on_accept_errors(mut self, val: bool) -> Self {
+        self.incoming.set_sleep_on_errors(val);
+        self
+    }
+}
+pub trait Watcher<I, S: HttpService<Body>, E>: Clone {
+    type Future: Future<Output = crate::Result<()>>;
+    fn watch(&self, conn: UpgradeableConnection<I, S, E>) -> Self::Future;
+}
+#[allow(missing_debug_implementations)]
+#[derive(Copy, Clone)]
+pub(crate) struct NoopWatcher;
+impl<I, S, E> Watcher<I, S, E> for NoopWatcher
+where
+    I: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    S: HttpService<Body>,
+    E: ConnStreamExec<S::Future, S::ResBody>,
+    S::ResBody: 'static,
+    <S::ResBody as HttpBody>::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Future = UpgradeableConnection<I, S, E>;
+    fn watch(&self, conn: UpgradeableConnection<I, S, E>) -> Self::Future {
+        conn
+    }
+}
+pub(crate) mod new_svc {
+    use std::error::Error as StdError;
+    use tokio::io::{AsyncRead, AsyncWrite};
+    use tracing::debug;
+    use super::{Connecting, Watcher};
+    use crate::body::{Body, HttpBody};
+    use crate::common::exec::ConnStreamExec;
+    use crate::common::{task, Future, Pin, Poll, Unpin};
+    use crate::service::HttpService;
+    use pin_project_lite::pin_project;
+    pin_project! {
+        #[allow(missing_debug_implementations)] pub struct NewSvcTask < I, N, S :
+        HttpService < Body >, E, W : Watcher < I, S, E >> { #[pin] state : State < I, N,
+        S, E, W >, }
+    }
+    pin_project! {
+        #[project = StateProj] pub (super) enum State < I, N, S : HttpService < Body >,
+        E, W : Watcher < I, S, E >> { Connecting { #[pin] connecting : Connecting < I, N,
+        E >, watcher : W, }, Connected { #[pin] future : W::Future, }, }
+    }
+    impl<I, N, S: HttpService<Body>, E, W: Watcher<I, S, E>> NewSvcTask<I, N, S, E, W> {
+        pub(super) fn new(connecting: Connecting<I, N, E>, watcher: W) -> Self {
+            NewSvcTask {
+                state: State::Connecting {
+                    connecting,
+                    watcher,
+                },
+            }
+        }
+    }
+    impl<I, N, S, NE, B, E, W> Future for NewSvcTask<I, N, S, E, W>
+    where
+        I: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+        N: Future<Output = Result<S, NE>>,
+        NE: Into<Box<dyn StdError + Send + Sync>>,
+        S: HttpService<Body, ResBody = B>,
+        B: HttpBody + 'static,
+        B::Error: Into<Box<dyn StdError + Send + Sync>>,
+        E: ConnStreamExec<S::Future, B>,
+        W: Watcher<I, S, E>,
+    {
+        type Output = ();
+        fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+            loop {}
+        }
+    }
+}
+pin_project! {
+    #[doc = " A future building a new `Service` to a `Connection`."] #[doc = ""] #[doc =
+    " Wraps the future returned from `MakeService` into one that returns"] #[doc =
+    " a `Connection`."] #[must_use = "futures do nothing unless polled"] #[derive(Debug)]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "http1", feature = "http2"))))] pub struct
+    Connecting < I, F, E = Exec > { #[pin] future : F, io : Option < I >, protocol :
+    Http_ < E >, }
+}
+impl<I, F, S, FE, E, B> Future for Connecting<I, F, E>
+where
+    I: AsyncRead + AsyncWrite + Unpin,
+    F: Future<Output = Result<S, FE>>,
+    S: HttpService<Body, ResBody = B>,
+    B: HttpBody + 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: ConnStreamExec<S::Future, B>,
+{
+    type Output = Result<Connection<I, S, E>, FE>;
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut me = self.project();
+        let service = ready!(me.future.poll(cx))?;
+        let io = Option::take(&mut me.io).expect("polled after complete");
+        Poll::Ready(Ok(me.protocol.serve_connection(io, service)))
+    }
+}
diff --git a/hyper/src/server/server_stub.rs b/hyper/src/server/server_stub.rs
new file mode 100644
index 0000000..1fe9cdb
--- /dev/null
+++ b/hyper/src/server/server_stub.rs
@@ -0,0 +1,13 @@
+use std::fmt;
+use crate::common::exec::Exec;
+/// A listening HTTP server that accepts connections in both HTTP1 and HTTP2 by default.
+///
+/// Needs at least one of the `http1` and `http2` features to be activated to actually be useful.
+pub(crate) struct Server<I, S, E = Exec> {
+    _marker: std::marker::PhantomData<(I, S, E)>,
+}
+impl<I: fmt::Debug, S: fmt::Debug> fmt::Debug for Server<I, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Server").finish()
+    }
+}
diff --git a/hyper/src/server/shutdown.rs b/hyper/src/server/shutdown.rs
new file mode 100644
index 0000000..96937d0
--- /dev/null
+++ b/hyper/src/server/shutdown.rs
@@ -0,0 +1,128 @@
+use std::error::Error as StdError;
+
+use pin_project_lite::pin_project;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tracing::debug;
+
+use super::accept::Accept;
+use super::conn::UpgradeableConnection;
+use super::server::{Server, Watcher};
+use crate::body::{Body, HttpBody};
+use crate::common::drain::{self, Draining, Signal, Watch, Watching};
+use crate::common::exec::{ConnStreamExec, NewSvcExec};
+use crate::common::{task, Future, Pin, Poll, Unpin};
+use crate::service::{HttpService, MakeServiceRef};
+
+pin_project! {
+    #[allow(missing_debug_implementations)]
+    pub struct Graceful<I, S, F, E> {
+        #[pin]
+        state: State<I, S, F, E>,
+    }
+}
+
+pin_project! {
+    #[project = StateProj]
+    pub(super) enum State<I, S, F, E> {
+        Running {
+            drain: Option<(Signal, Watch)>,
+            #[pin]
+            server: Server<I, S, E>,
+            #[pin]
+            signal: F,
+        },
+        Draining { draining: Draining },
+    }
+}
+
+impl<I, S, F, E> Graceful<I, S, F, E> {
+    pub(super) fn new(server: Server<I, S, E>, signal: F) -> Self {
+        let drain = Some(drain::channel());
+        Graceful {
+            state: State::Running {
+                drain,
+                server,
+                signal,
+            },
+        }
+    }
+}
+
+impl<I, IO, IE, S, B, F, E> Future for Graceful<I, S, F, E>
+where
+    I: Accept<Conn = IO, Error = IE>,
+    IE: Into<Box<dyn StdError + Send + Sync>>,
+    IO: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    S: MakeServiceRef<IO, Body, ResBody = B>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    B: HttpBody + 'static,
+    B::Error: Into<Box<dyn StdError + Send + Sync>>,
+    F: Future<Output = ()>,
+    E: ConnStreamExec<<S::Service as HttpService<Body>>::Future, B>,
+    E: NewSvcExec<IO, S::Future, S::Service, E, GracefulWatcher>,
+{
+    type Output = crate::Result<()>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut me = self.project();
+        loop {
+            let next = {
+                match me.state.as_mut().project() {
+                    StateProj::Running {
+                        drain,
+                        server,
+                        signal,
+                    } => match signal.poll(cx) {
+                        Poll::Ready(()) => {
+                            debug!("signal received, starting graceful shutdown");
+                            let sig = drain.take().expect("drain channel").0;
+                            State::Draining {
+                                draining: sig.drain(),
+                            }
+                        }
+                        Poll::Pending => {
+                            let watch = drain.as_ref().expect("drain channel").1.clone();
+                            return server.poll_watch(cx, &GracefulWatcher(watch));
+                        }
+                    },
+                    StateProj::Draining { ref mut draining } => {
+                        return Pin::new(draining).poll(cx).map(Ok);
+                    }
+                }
+            };
+            me.state.set(next);
+        }
+    }
+}
+
+#[allow(missing_debug_implementations)]
+#[derive(Clone)]
+pub struct GracefulWatcher(Watch);
+
+impl<I, S, E> Watcher<I, S, E> for GracefulWatcher
+where
+    I: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    S: HttpService<Body>,
+    E: ConnStreamExec<S::Future, S::ResBody>,
+    S::ResBody: 'static,
+    <S::ResBody as HttpBody>::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Future =
+        Watching<UpgradeableConnection<I, S, E>, fn(Pin<&mut UpgradeableConnection<I, S, E>>)>;
+
+    fn watch(&self, conn: UpgradeableConnection<I, S, E>) -> Self::Future {
+        self.0.clone().watch(conn, on_drain)
+    }
+}
+
+fn on_drain<I, S, E>(conn: Pin<&mut UpgradeableConnection<I, S, E>>)
+where
+    S: HttpService<Body>,
+    S::Error: Into<Box<dyn StdError + Send + Sync>>,
+    I: AsyncRead + AsyncWrite + Unpin,
+    S::ResBody: HttpBody + 'static,
+    <S::ResBody as HttpBody>::Error: Into<Box<dyn StdError + Send + Sync>>,
+    E: ConnStreamExec<S::Future, S::ResBody>,
+{
+    conn.graceful_shutdown()
+}
diff --git a/hyper/src/server/tcp.rs b/hyper/src/server/tcp.rs
new file mode 100644
index 0000000..3f93715
--- /dev/null
+++ b/hyper/src/server/tcp.rs
@@ -0,0 +1,484 @@
+use std::fmt;
+use std::io;
+use std::net::{SocketAddr, TcpListener as StdTcpListener};
+use std::time::Duration;
+use socket2::TcpKeepalive;
+
+use tokio::net::TcpListener;
+use tokio::time::Sleep;
+use tracing::{debug, error, trace};
+
+use crate::common::{task, Future, Pin, Poll};
+
+#[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411
+pub use self::addr_stream::AddrStream;
+use super::accept::Accept;
+
+#[derive(Default, Debug, Clone, Copy)]
+struct TcpKeepaliveConfig {
+    time: Option<Duration>,
+    interval: Option<Duration>,
+    retries: Option<u32>,
+}
+
+impl TcpKeepaliveConfig {
+    /// Converts into a `socket2::TcpKeealive` if there is any keep alive configuration.
+    fn into_socket2(self) -> Option<TcpKeepalive> {
+        let mut dirty = false;
+        let mut ka = TcpKeepalive::new();
+        if let Some(time) = self.time {
+            ka = ka.with_time(time);
+            dirty = true
+        }
+        if let Some(interval) = self.interval {
+            ka = Self::ka_with_interval(ka, interval, &mut dirty)
+        };
+        if let Some(retries) = self.retries {
+            ka = Self::ka_with_retries(ka, retries, &mut dirty)
+        };
+        if dirty {
+            Some(ka)
+        } else {
+            None
+        }
+    }
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_vendor = "apple",
+        windows,
+    ))]
+    fn ka_with_interval(ka: TcpKeepalive, interval: Duration, dirty: &mut bool) -> TcpKeepalive {
+        *dirty = true;
+        ka.with_interval(interval)
+    }
+
+    #[cfg(not(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_vendor = "apple",
+        windows,
+    )))]
+    fn ka_with_interval(ka: TcpKeepalive, _: Duration, _: &mut bool) -> TcpKeepalive {
+        ka  // no-op as keepalive interval is not supported on this platform
+    }
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_vendor = "apple",
+    ))]
+    fn ka_with_retries(ka: TcpKeepalive, retries: u32, dirty: &mut bool) -> TcpKeepalive {
+        *dirty = true;
+        ka.with_retries(retries)
+    }
+
+    #[cfg(not(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_vendor = "apple",
+    )))]
+    fn ka_with_retries(ka: TcpKeepalive, _: u32, _: &mut bool) -> TcpKeepalive {
+        ka  // no-op as keepalive retries is not supported on this platform
+    }
+}
+
+/// A stream of connections from binding to an address.
+#[must_use = "streams do nothing unless polled"]
+pub struct AddrIncoming {
+    addr: SocketAddr,
+    listener: TcpListener,
+    sleep_on_errors: bool,
+    tcp_keepalive_config: TcpKeepaliveConfig,
+    tcp_nodelay: bool,
+    timeout: Option<Pin<Box<Sleep>>>,
+}
+
+impl AddrIncoming {
+    pub(super) fn new(addr: &SocketAddr) -> crate::Result<Self> {
+        let std_listener = StdTcpListener::bind(addr).map_err(crate::Error::new_listen)?;
+
+        AddrIncoming::from_std(std_listener)
+    }
+
+    pub(super) fn from_std(std_listener: StdTcpListener) -> crate::Result<Self> {
+        // TcpListener::from_std doesn't set O_NONBLOCK
+        std_listener
+            .set_nonblocking(true)
+            .map_err(crate::Error::new_listen)?;
+        let listener = TcpListener::from_std(std_listener).map_err(crate::Error::new_listen)?;
+        AddrIncoming::from_listener(listener)
+    }
+
+    /// Creates a new `AddrIncoming` binding to provided socket address.
+    pub fn bind(addr: &SocketAddr) -> crate::Result<Self> {
+        AddrIncoming::new(addr)
+    }
+
+    /// Creates a new `AddrIncoming` from an existing `tokio::net::TcpListener`.
+    pub fn from_listener(listener: TcpListener) -> crate::Result<Self> {
+        let addr = listener.local_addr().map_err(crate::Error::new_listen)?;
+        Ok(AddrIncoming {
+            listener,
+            addr,
+            sleep_on_errors: true,
+            tcp_keepalive_config: TcpKeepaliveConfig::default(),
+            tcp_nodelay: false,
+            timeout: None,
+        })
+    }
+
+    /// Get the local address bound to this listener.
+    pub fn local_addr(&self) -> SocketAddr {
+        self.addr
+    }
+
+    /// Set the duration to remain idle before sending TCP keepalive probes.
+    ///
+    /// If `None` is specified, keepalive is disabled.
+    pub fn set_keepalive(&mut self, time: Option<Duration>) -> &mut Self {
+        self.tcp_keepalive_config.time = time;
+        self
+    }
+
+    /// Set the duration between two successive TCP keepalive retransmissions,
+    /// if acknowledgement to the previous keepalive transmission is not received.
+    pub fn set_keepalive_interval(&mut self, interval: Option<Duration>) -> &mut Self {
+        self.tcp_keepalive_config.interval = interval;
+        self
+    }
+
+    /// Set the number of retransmissions to be carried out before declaring that remote end is not available.
+    pub fn set_keepalive_retries(&mut self, retries: Option<u32>) -> &mut Self {
+        self.tcp_keepalive_config.retries = retries;
+        self
+    }
+
+    /// Set the value of `TCP_NODELAY` option for accepted connections.
+    pub fn set_nodelay(&mut self, enabled: bool) -> &mut Self {
+        self.tcp_nodelay = enabled;
+        self
+    }
+
+    /// Set whether to sleep on accept errors.
+    ///
+    /// A possible scenario is that the process has hit the max open files
+    /// allowed, and so trying to accept a new connection will fail with
+    /// `EMFILE`. In some cases, it's preferable to just wait for some time, if
+    /// the application will likely close some files (or connections), and try
+    /// to accept the connection again. If this option is `true`, the error
+    /// will be logged at the `error` level, since it is still a big deal,
+    /// and then the listener will sleep for 1 second.
+    ///
+    /// In other cases, hitting the max open files should be treat similarly
+    /// to being out-of-memory, and simply error (and shutdown). Setting
+    /// this option to `false` will allow that.
+    ///
+    /// Default is `true`.
+    pub fn set_sleep_on_errors(&mut self, val: bool) {
+        self.sleep_on_errors = val;
+    }
+
+    fn poll_next_(&mut self, cx: &mut task::Context<'_>) -> Poll<io::Result<AddrStream>> {
+        // Check if a previous timeout is active that was set by IO errors.
+        if let Some(ref mut to) = self.timeout {
+            ready!(Pin::new(to).poll(cx));
+        }
+        self.timeout = None;
+
+        loop {
+            match ready!(self.listener.poll_accept(cx)) {
+                Ok((socket, remote_addr)) => {
+                    if let Some(tcp_keepalive) = &self.tcp_keepalive_config.into_socket2() {
+                        let sock_ref = socket2::SockRef::from(&socket);
+                        if let Err(e) = sock_ref.set_tcp_keepalive(tcp_keepalive) {
+                            trace!("error trying to set TCP keepalive: {}", e);
+                        }
+                    }
+                    if let Err(e) = socket.set_nodelay(self.tcp_nodelay) {
+                        trace!("error trying to set TCP nodelay: {}", e);
+                    }
+                    let local_addr = socket.local_addr()?;
+                    return Poll::Ready(Ok(AddrStream::new(socket, remote_addr, local_addr)));
+                }
+                Err(e) => {
+                    // Connection errors can be ignored directly, continue by
+                    // accepting the next request.
+                    if is_connection_error(&e) {
+                        debug!("accepted connection already errored: {}", e);
+                        continue;
+                    }
+
+                    if self.sleep_on_errors {
+                        error!("accept error: {}", e);
+
+                        // Sleep 1s.
+                        let mut timeout = Box::pin(tokio::time::sleep(Duration::from_secs(1)));
+
+                        match timeout.as_mut().poll(cx) {
+                            Poll::Ready(()) => {
+                                // Wow, it's been a second already? Ok then...
+                                continue;
+                            }
+                            Poll::Pending => {
+                                self.timeout = Some(timeout);
+                                return Poll::Pending;
+                            }
+                        }
+                    } else {
+                        return Poll::Ready(Err(e));
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl Accept for AddrIncoming {
+    type Conn = AddrStream;
+    type Error = io::Error;
+
+    fn poll_accept(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
+        let result = ready!(self.poll_next_(cx));
+        Poll::Ready(Some(result))
+    }
+}
+
+/// This function defines errors that are per-connection. Which basically
+/// means that if we get this error from `accept()` system call it means
+/// next connection might be ready to be accepted.
+///
+/// All other errors will incur a timeout before next `accept()` is performed.
+/// The timeout is useful to handle resource exhaustion errors like ENFILE
+/// and EMFILE. Otherwise, could enter into tight loop.
+fn is_connection_error(e: &io::Error) -> bool {
+    matches!(
+        e.kind(),
+        io::ErrorKind::ConnectionRefused
+            | io::ErrorKind::ConnectionAborted
+            | io::ErrorKind::ConnectionReset
+    )
+}
+
+impl fmt::Debug for AddrIncoming {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("AddrIncoming")
+            .field("addr", &self.addr)
+            .field("sleep_on_errors", &self.sleep_on_errors)
+            .field("tcp_keepalive_config", &self.tcp_keepalive_config)
+            .field("tcp_nodelay", &self.tcp_nodelay)
+            .finish()
+    }
+}
+
+mod addr_stream {
+    use std::io;
+    use std::net::SocketAddr;
+    #[cfg(unix)]
+    use std::os::unix::io::{AsRawFd, RawFd};
+    use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+    use tokio::net::TcpStream;
+
+    use crate::common::{task, Pin, Poll};
+
+    pin_project_lite::pin_project! {
+        /// A transport returned yieled by `AddrIncoming`.
+        #[derive(Debug)]
+        pub struct AddrStream {
+            #[pin]
+            inner: TcpStream,
+            pub(super) remote_addr: SocketAddr,
+            pub(super) local_addr: SocketAddr
+        }
+    }
+
+    impl AddrStream {
+        pub(super) fn new(
+            tcp: TcpStream,
+            remote_addr: SocketAddr,
+            local_addr: SocketAddr,
+        ) -> AddrStream {
+            AddrStream {
+                inner: tcp,
+                remote_addr,
+                local_addr,
+            }
+        }
+
+        /// Returns the remote (peer) address of this connection.
+        #[inline]
+        pub fn remote_addr(&self) -> SocketAddr {
+            self.remote_addr
+        }
+
+        /// Returns the local address of this connection.
+        #[inline]
+        pub fn local_addr(&self) -> SocketAddr {
+            self.local_addr
+        }
+
+        /// Consumes the AddrStream and returns the underlying IO object
+        #[inline]
+        pub fn into_inner(self) -> TcpStream {
+            self.inner
+        }
+
+        /// Attempt to receive data on the socket, without removing that data
+        /// from the queue, registering the current task for wakeup if data is
+        /// not yet available.
+        pub fn poll_peek(
+            &mut self,
+            cx: &mut task::Context<'_>,
+            buf: &mut tokio::io::ReadBuf<'_>,
+        ) -> Poll<io::Result<usize>> {
+            self.inner.poll_peek(cx, buf)
+        }
+    }
+
+    impl AsyncRead for AddrStream {
+        #[inline]
+        fn poll_read(
+            self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            self.project().inner.poll_read(cx, buf)
+        }
+    }
+
+    impl AsyncWrite for AddrStream {
+        #[inline]
+        fn poll_write(
+            self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            self.project().inner.poll_write(cx, buf)
+        }
+
+        #[inline]
+        fn poll_write_vectored(
+            self: Pin<&mut Self>,
+            cx: &mut task::Context<'_>,
+            bufs: &[io::IoSlice<'_>],
+        ) -> Poll<io::Result<usize>> {
+            self.project().inner.poll_write_vectored(cx, bufs)
+        }
+
+        #[inline]
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+            // TCP flush is a noop
+            Poll::Ready(Ok(()))
+        }
+
+        #[inline]
+        fn poll_shutdown(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
+            self.project().inner.poll_shutdown(cx)
+        }
+
+        #[inline]
+        fn is_write_vectored(&self) -> bool {
+            // Note that since `self.inner` is a `TcpStream`, this could
+            // *probably* be hard-coded to return `true`...but it seems more
+            // correct to ask it anyway (maybe we're on some platform without
+            // scatter-gather IO?)
+            self.inner.is_write_vectored()
+        }
+    }
+
+    #[cfg(unix)]
+    impl AsRawFd for AddrStream {
+        fn as_raw_fd(&self) -> RawFd {
+            self.inner.as_raw_fd()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+    use crate::server::tcp::TcpKeepaliveConfig;
+
+    #[test]
+    fn no_tcp_keepalive_config() {
+        assert!(TcpKeepaliveConfig::default().into_socket2().is_none());
+    }
+
+    #[test]
+    fn tcp_keepalive_time_config() {
+        let mut kac = TcpKeepaliveConfig::default();
+        kac.time = Some(Duration::from_secs(60));
+        if let Some(tcp_keepalive) = kac.into_socket2() {
+            assert!(format!("{tcp_keepalive:?}").contains("time: Some(60s)"));
+        } else {
+            panic!("test failed");
+        }
+    }
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_vendor = "apple",
+        windows,
+    ))]
+    #[test]
+    fn tcp_keepalive_interval_config() {
+        let mut kac = TcpKeepaliveConfig::default();
+        kac.interval = Some(Duration::from_secs(1));
+        if let Some(tcp_keepalive) = kac.into_socket2() {
+            assert!(format!("{tcp_keepalive:?}").contains("interval: Some(1s)"));
+        } else {
+            panic!("test failed");
+        }
+    }
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_vendor = "apple",
+    ))]
+    #[test]
+    fn tcp_keepalive_retries_config() {
+        let mut kac = TcpKeepaliveConfig::default();
+        kac.retries = Some(3);
+        if let Some(tcp_keepalive) = kac.into_socket2() {
+            assert!(format!("{tcp_keepalive:?}").contains("retries: Some(3)"));
+        } else {
+            panic!("test failed");
+        }
+    }
+}
diff --git a/hyper/src/service/http.rs b/hyper/src/service/http.rs
new file mode 100644
index 0000000..81a20c8
--- /dev/null
+++ b/hyper/src/service/http.rs
@@ -0,0 +1,58 @@
+use std::error::Error as StdError;
+
+use crate::body::HttpBody;
+use crate::common::{task, Future, Poll};
+use crate::{Request, Response};
+
+/// An asynchronous function from `Request` to `Response`.
+pub trait HttpService<ReqBody>: sealed::Sealed<ReqBody> {
+    /// The `HttpBody` body of the `http::Response`.
+    type ResBody: HttpBody;
+
+    /// The error type that can occur within this `Service`.
+    ///
+    /// Note: Returning an `Error` to a hyper server will cause the connection
+    /// to be abruptly aborted. In most cases, it is better to return a `Response`
+    /// with a 4xx or 5xx status code.
+    type Error: Into<Box<dyn StdError + Send + Sync>>;
+
+    /// The `Future` returned by this `Service`.
+    type Future: Future<Output = Result<Response<Self::ResBody>, Self::Error>>;
+
+    #[doc(hidden)]
+    fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
+
+    #[doc(hidden)]
+    fn call(&mut self, req: Request<ReqBody>) -> Self::Future;
+}
+
+impl<T, B1, B2> HttpService<B1> for T
+where
+    T: tower_service::Service<Request<B1>, Response = Response<B2>>,
+    B2: HttpBody,
+    T::Error: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type ResBody = B2;
+
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        tower_service::Service::poll_ready(self, cx)
+    }
+
+    fn call(&mut self, req: Request<B1>) -> Self::Future {
+        tower_service::Service::call(self, req)
+    }
+}
+
+impl<T, B1, B2> sealed::Sealed<B1> for T
+where
+    T: tower_service::Service<Request<B1>, Response = Response<B2>>,
+    B2: HttpBody,
+{
+}
+
+mod sealed {
+    pub trait Sealed<T> {}
+}
diff --git a/hyper/src/service/make.rs b/hyper/src/service/make.rs
new file mode 100644
index 0000000..32e5761
--- /dev/null
+++ b/hyper/src/service/make.rs
@@ -0,0 +1,164 @@
+use std::error::Error as StdError;
+use std::fmt;
+use tokio::io::{AsyncRead, AsyncWrite};
+use super::{HttpService, Service};
+use crate::body::HttpBody;
+use crate::common::{task, Future, Poll};
+pub(crate) trait MakeConnection<Target>: self::sealed::Sealed<(Target,)> {
+    type Connection: AsyncRead + AsyncWrite;
+    type Error;
+    type Future: Future<Output = Result<Self::Connection, Self::Error>>;
+    fn poll_ready(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>>;
+    fn make_connection(&mut self, target: Target) -> Self::Future;
+}
+impl<S, Target> self::sealed::Sealed<(Target,)> for S
+where
+    S: Service<Target>,
+{}
+impl<S, Target> MakeConnection<Target> for S
+where
+    S: Service<Target>,
+    S::Response: AsyncRead + AsyncWrite,
+{
+    type Connection = S::Response;
+    type Error = S::Error;
+    type Future = S::Future;
+    fn poll_ready(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Service::poll_ready(self, cx)
+    }
+    fn make_connection(&mut self, target: Target) -> Self::Future {
+        Service::call(self, target)
+    }
+}
+pub trait MakeServiceRef<Target, ReqBody>: self::sealed::Sealed<(Target, ReqBody)> {
+    type ResBody: HttpBody;
+    type Error: Into<Box<dyn StdError + Send + Sync>>;
+    type Service: HttpService<ReqBody, ResBody = Self::ResBody, Error = Self::Error>;
+    type MakeError: Into<Box<dyn StdError + Send + Sync>>;
+    type Future: Future<Output = Result<Self::Service, Self::MakeError>>;
+    type __DontNameMe: self::sealed::CantImpl;
+    fn poll_ready_ref(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::MakeError>>;
+    fn make_service_ref(&mut self, target: &Target) -> Self::Future;
+}
+impl<T, Target, E, ME, S, F, IB, OB> MakeServiceRef<Target, IB> for T
+where
+    T: for<'a> Service<&'a Target, Error = ME, Response = S, Future = F>,
+    E: Into<Box<dyn StdError + Send + Sync>>,
+    ME: Into<Box<dyn StdError + Send + Sync>>,
+    S: HttpService<IB, ResBody = OB, Error = E>,
+    F: Future<Output = Result<S, ME>>,
+    IB: HttpBody,
+    OB: HttpBody,
+{
+    type Error = E;
+    type Service = S;
+    type ResBody = OB;
+    type MakeError = ME;
+    type Future = F;
+    type __DontNameMe = self::sealed::CantName;
+    fn poll_ready_ref(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::MakeError>> {
+        self.poll_ready(cx)
+    }
+    fn make_service_ref(&mut self, target: &Target) -> Self::Future {
+        self.call(target)
+    }
+}
+impl<T, Target, S, B1, B2> self::sealed::Sealed<(Target, B1)> for T
+where
+    T: for<'a> Service<&'a Target, Response = S>,
+    S: HttpService<B1, ResBody = B2>,
+    B1: HttpBody,
+    B2: HttpBody,
+{}
+/// Create a `MakeService` from a function.
+///
+/// # Example
+///
+/// ```
+/// # #[cfg(feature = "runtime")]
+/// # async fn run() {
+/// use std::convert::Infallible;
+/// use hyper::{Body, Request, Response, Server};
+/// use hyper::server::conn::AddrStream;
+/// use hyper::service::{make_service_fn, service_fn};
+///
+/// let addr = ([127, 0, 0, 1], 3000).into();
+///
+/// let make_svc = make_service_fn(|socket: &AddrStream| {
+///     let remote_addr = socket.remote_addr();
+///     async move {
+///         Ok::<_, Infallible>(service_fn(move |_: Request<Body>| async move {
+///             Ok::<_, Infallible>(
+///                 Response::new(Body::from(format!("Hello, {}!", remote_addr)))
+///             )
+///         }))
+///     }
+/// });
+///
+/// // Then bind and serve...
+/// let server = Server::bind(&addr)
+///     .serve(make_svc);
+///
+/// // Finally, spawn `server` onto an Executor...
+/// if let Err(e) = server.await {
+///     eprintln!("server error: {}", e);
+/// }
+/// # }
+/// # fn main() {}
+/// ```
+pub fn make_service_fn<F, Target, Ret>(f: F) -> MakeServiceFn<F>
+where
+    F: FnMut(&Target) -> Ret,
+    Ret: Future,
+{
+    MakeServiceFn { f }
+}
+/// `MakeService` returned from [`make_service_fn`]
+#[derive(Clone, Copy)]
+pub struct MakeServiceFn<F> {
+    f: F,
+}
+impl<'t, F, Ret, Target, Svc, MkErr> Service<&'t Target> for MakeServiceFn<F>
+where
+    F: FnMut(&Target) -> Ret,
+    Ret: Future<Output = Result<Svc, MkErr>>,
+    MkErr: Into<Box<dyn StdError + Send + Sync>>,
+{
+    type Error = MkErr;
+    type Response = Svc;
+    type Future = Ret;
+    fn poll_ready(
+        &mut self,
+        _cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+    fn call(&mut self, target: &'t Target) -> Self::Future {
+        (self.f)(target)
+    }
+}
+impl<F> fmt::Debug for MakeServiceFn<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MakeServiceFn").finish()
+    }
+}
+mod sealed {
+    pub trait Sealed<X> {}
+    #[allow(unreachable_pub)]
+    pub trait CantImpl {}
+    #[allow(missing_debug_implementations)]
+    pub enum CantName {}
+    impl CantImpl for CantName {}
+}
diff --git a/hyper/src/service/mod.rs b/hyper/src/service/mod.rs
new file mode 100644
index 0000000..22f850c
--- /dev/null
+++ b/hyper/src/service/mod.rs
@@ -0,0 +1,55 @@
+//! Asynchronous Services
+//!
+//! A [`Service`](Service) is a trait representing an asynchronous
+//! function of a request to a response. It's similar to
+//! `async fn(Request) -> Result<Response, Error>`.
+//!
+//! The argument and return value isn't strictly required to be for HTTP.
+//! Therefore, hyper uses several "trait aliases" to reduce clutter around
+//! bounds. These are:
+//!
+//! - `HttpService`: This is blanketly implemented for all types that
+//!   implement `Service<http::Request<B1>, Response = http::Response<B2>>`.
+//! - `MakeService`: When a `Service` returns a new `Service` as its "response",
+//!   we consider it a `MakeService`. Again, blanketly implemented in those cases.
+//! - `MakeConnection`: A `Service` that returns a "connection", a type that
+//!   implements `AsyncRead` and `AsyncWrite`.
+//!
+//! # HttpService
+//!
+//! In hyper, especially in the server setting, a `Service` is usually bound
+//! to a single connection. It defines how to respond to **all** requests that
+//! connection will receive.
+//!
+//! The helper [`service_fn`](service_fn) should be sufficient for most cases, but
+//! if you need to implement `Service` for a type manually, you can follow the example
+//! in `service_struct_impl.rs`.
+//!
+//! # MakeService
+//!
+//! Since a `Service` is bound to a single connection, a [`Server`](crate::Server)
+//! needs a way to make them as it accepts connections. This is what a
+//! `MakeService` does.
+//!
+//! Resources that need to be shared by all `Service`s can be put into a
+//! `MakeService`, and then passed to individual `Service`s when `call`
+//! is called.
+
+pub use tower_service::Service;
+
+mod http;
+mod make;
+#[cfg(all(any(feature = "http1", feature = "http2"), feature = "client"))]
+mod oneshot;
+mod util;
+
+pub(super) use self::http::HttpService;
+#[cfg(all(any(feature = "http1", feature = "http2"), feature = "client"))]
+pub(super) use self::make::MakeConnection;
+#[cfg(all(any(feature = "http1", feature = "http2"), feature = "server"))]
+pub(super) use self::make::MakeServiceRef;
+#[cfg(all(any(feature = "http1", feature = "http2"), feature = "client"))]
+pub(super) use self::oneshot::{oneshot, Oneshot};
+
+pub use self::make::make_service_fn;
+pub use self::util::service_fn;
diff --git a/hyper/src/service/oneshot.rs b/hyper/src/service/oneshot.rs
new file mode 100644
index 0000000..2697af8
--- /dev/null
+++ b/hyper/src/service/oneshot.rs
@@ -0,0 +1,73 @@
+// TODO: Eventually to be replaced with tower_util::Oneshot.
+
+use pin_project_lite::pin_project;
+use tower_service::Service;
+
+use crate::common::{task, Future, Pin, Poll};
+
+pub(crate) fn oneshot<S, Req>(svc: S, req: Req) -> Oneshot<S, Req>
+where
+    S: Service<Req>,
+{
+    Oneshot {
+        state: State::NotReady { svc, req },
+    }
+}
+
+pin_project! {
+    // A `Future` consuming a `Service` and request, waiting until the `Service`
+    // is ready, and then calling `Service::call` with the request, and
+    // waiting for that `Future`.
+    #[allow(missing_debug_implementations)]
+    pub struct Oneshot<S: Service<Req>, Req> {
+        #[pin]
+        state: State<S, Req>,
+    }
+}
+
+pin_project! {
+    #[project = StateProj]
+    #[project_replace = StateProjOwn]
+    enum State<S: Service<Req>, Req> {
+        NotReady {
+            svc: S,
+            req: Req,
+        },
+        Called {
+            #[pin]
+            fut: S::Future,
+        },
+        Tmp,
+    }
+}
+
+impl<S, Req> Future for Oneshot<S, Req>
+where
+    S: Service<Req>,
+{
+    type Output = Result<S::Response, S::Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let mut me = self.project();
+
+        loop {
+            match me.state.as_mut().project() {
+                StateProj::NotReady { ref mut svc, .. } => {
+                    ready!(svc.poll_ready(cx))?;
+                    // fallthrough out of the match's borrow
+                }
+                StateProj::Called { fut } => {
+                    return fut.poll(cx);
+                }
+                StateProj::Tmp => unreachable!(),
+            }
+
+            match me.state.as_mut().project_replace(State::Tmp) {
+                StateProjOwn::NotReady { mut svc, req } => {
+                    me.state.set(State::Called { fut: svc.call(req) });
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+}
diff --git a/hyper/src/service/util.rs b/hyper/src/service/util.rs
new file mode 100644
index 0000000..7cba120
--- /dev/null
+++ b/hyper/src/service/util.rs
@@ -0,0 +1,84 @@
+use std::error::Error as StdError;
+use std::fmt;
+use std::marker::PhantomData;
+
+use crate::body::HttpBody;
+use crate::common::{task, Future, Poll};
+use crate::{Request, Response};
+
+/// Create a `Service` from a function.
+///
+/// # Example
+///
+/// ```
+/// use hyper::{Body, Request, Response, Version};
+/// use hyper::service::service_fn;
+///
+/// let service = service_fn(|req: Request<Body>| async move {
+///     if req.version() == Version::HTTP_11 {
+///         Ok(Response::new(Body::from("Hello World")))
+///     } else {
+///         // Note: it's usually better to return a Response
+///         // with an appropriate StatusCode instead of an Err.
+///         Err("not HTTP/1.1, abort connection")
+///     }
+/// });
+/// ```
+pub fn service_fn<F, R, S>(f: F) -> ServiceFn<F, R>
+where
+    F: FnMut(Request<R>) -> S,
+    S: Future,
+{
+    ServiceFn {
+        f,
+        _req: PhantomData,
+    }
+}
+
+/// Service returned by [`service_fn`]
+pub struct ServiceFn<F, R> {
+    f: F,
+    _req: PhantomData<fn(R)>,
+}
+
+impl<F, ReqBody, Ret, ResBody, E> tower_service::Service<crate::Request<ReqBody>>
+    for ServiceFn<F, ReqBody>
+where
+    F: FnMut(Request<ReqBody>) -> Ret,
+    ReqBody: HttpBody,
+    Ret: Future<Output = Result<Response<ResBody>, E>>,
+    E: Into<Box<dyn StdError + Send + Sync>>,
+    ResBody: HttpBody,
+{
+    type Response = crate::Response<ResBody>;
+    type Error = E;
+    type Future = Ret;
+
+    fn poll_ready(&mut self, _cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
+        (self.f)(req)
+    }
+}
+
+impl<F, R> fmt::Debug for ServiceFn<F, R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("impl Service").finish()
+    }
+}
+
+impl<F, R> Clone for ServiceFn<F, R>
+where
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        ServiceFn {
+            f: self.f.clone(),
+            _req: PhantomData,
+        }
+    }
+}
+
+impl<F, R> Copy for ServiceFn<F, R> where F: Copy {}
diff --git a/hyper/src/upgrade.rs b/hyper/src/upgrade.rs
new file mode 100644
index 0000000..06cc4ed
--- /dev/null
+++ b/hyper/src/upgrade.rs
@@ -0,0 +1,335 @@
+//! HTTP Upgrades
+//!
+//! This module deals with managing [HTTP Upgrades][mdn] in hyper. Since
+//! several concepts in HTTP allow for first talking HTTP, and then converting
+//! to a different protocol, this module conflates them into a single API.
+//! Those include:
+//!
+//! - HTTP/1.1 Upgrades
+//! - HTTP `CONNECT`
+//!
+//! You are responsible for any other pre-requisites to establish an upgrade,
+//! such as sending the appropriate headers, methods, and status codes. You can
+//! then use [`on`][] to grab a `Future` which will resolve to the upgraded
+//! connection object, or an error if the upgrade fails.
+//!
+//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Protocol_upgrade_mechanism
+//!
+//! # Client
+//!
+//! Sending an HTTP upgrade from the [`client`](super::client) involves setting
+//! either the appropriate method, if wanting to `CONNECT`, or headers such as
+//! `Upgrade` and `Connection`, on the `http::Request`. Once receiving the
+//! `http::Response` back, you must check for the specific information that the
+//! upgrade is agreed upon by the server (such as a `101` status code), and then
+//! get the `Future` from the `Response`.
+//!
+//! # Server
+//!
+//! Receiving upgrade requests in a server requires you to check the relevant
+//! headers in a `Request`, and if an upgrade should be done, you then send the
+//! corresponding headers in a response. To then wait for hyper to finish the
+//! upgrade, you call `on()` with the `Request`, and then can spawn a task
+//! awaiting it.
+//!
+//! # Example
+//!
+//! See [this example][example] showing how upgrades work with both
+//! Clients and Servers.
+//!
+//! [example]: https://github.com/hyperium/hyper/blob/master/examples/upgrades.rs
+use std::any::TypeId;
+use std::error::Error as StdError;
+use std::fmt;
+use std::io;
+use std::marker::Unpin;
+use bytes::Bytes;
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio::sync::oneshot;
+#[cfg(any(feature = "http1", feature = "http2"))]
+use tracing::trace;
+use crate::common::io::Rewind;
+use crate::common::{task, Future, Pin, Poll};
+/// An upgraded HTTP connection.
+///
+/// This type holds a trait object internally of the original IO that
+/// was used to speak HTTP before the upgrade. It can be used directly
+/// as a `Read` or `Write` for convenience.
+///
+/// Alternatively, if the exact type is known, this can be deconstructed
+/// into its parts.
+pub(crate) struct Upgraded {
+    io: Rewind<Box<dyn Io + Send>>,
+}
+/// A future for a possible HTTP upgrade.
+///
+/// If no upgrade was available, or it doesn't succeed, yields an `Error`.
+pub(crate) struct OnUpgrade {
+    rx: Option<oneshot::Receiver<crate::Result<Upgraded>>>,
+}
+/// The deconstructed parts of an [`Upgraded`](Upgraded) type.
+///
+/// Includes the original IO type, and a read buffer of bytes that the
+/// HTTP state machine may have already read before completing an upgrade.
+#[derive(Debug)]
+pub(crate) struct Parts<T> {
+    /// The original IO object used before the upgrade.
+    pub(crate) io: T,
+    /// A buffer of bytes that have been read but not processed as HTTP.
+    ///
+    /// For instance, if the `Connection` is used for an HTTP upgrade request,
+    /// it is possible the server sent back the first bytes of the new protocol
+    /// along with the response upgrade.
+    ///
+    /// You will want to check for any existing bytes if you plan to continue
+    /// communicating on the IO object.
+    pub(crate) read_buf: Bytes,
+    _inner: (),
+}
+/// Gets a pending HTTP upgrade from this message.
+///
+/// This can be called on the following types:
+///
+/// - `http::Request<B>`
+/// - `http::Response<B>`
+/// - `&mut http::Request<B>`
+/// - `&mut http::Response<B>`
+pub(crate) fn on<T: sealed::CanUpgrade>(msg: T) -> OnUpgrade {
+    msg.on_upgrade()
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+pub(super) struct Pending {
+    tx: oneshot::Sender<crate::Result<Upgraded>>,
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+pub(super) fn pending() -> (Pending, OnUpgrade) {
+    let (tx, rx) = oneshot::channel();
+    (Pending { tx }, OnUpgrade { rx: Some(rx) })
+}
+impl Upgraded {
+    #[cfg(any(feature = "http1", feature = "http2", test))]
+    pub(super) fn new<T>(io: T, read_buf: Bytes) -> Self
+    where
+        T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    {
+        Upgraded {
+            io: Rewind::new_buffered(Box::new(io), read_buf),
+        }
+    }
+    /// Tries to downcast the internal trait object to the type passed.
+    ///
+    /// On success, returns the downcasted parts. On error, returns the
+    /// `Upgraded` back.
+    pub(crate) fn downcast<T: AsyncRead + AsyncWrite + Unpin + 'static>(
+        self,
+    ) -> Result<Parts<T>, Self> {
+        let (io, buf) = self.io.into_inner();
+        match io.__hyper_downcast() {
+            Ok(t) => {
+                Ok(Parts {
+                    io: *t,
+                    read_buf: buf,
+                    _inner: (),
+                })
+            }
+            Err(io) => {
+                Err(Upgraded {
+                    io: Rewind::new_buffered(io, buf),
+                })
+            }
+        }
+    }
+}
+impl AsyncRead for Upgraded {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_read(cx, buf)
+    }
+}
+impl AsyncWrite for Upgraded {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io).poll_write(cx, buf)
+    }
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Pin::new(&mut self.io).poll_write_vectored(cx, bufs)
+    }
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_flush(cx)
+    }
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.io).poll_shutdown(cx)
+    }
+    fn is_write_vectored(&self) -> bool {
+        self.io.is_write_vectored()
+    }
+}
+impl fmt::Debug for Upgraded {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Upgraded").finish()
+    }
+}
+impl OnUpgrade {
+    pub(super) fn none() -> Self {
+        OnUpgrade { rx: None }
+    }
+    #[cfg(feature = "http1")]
+    pub(super) fn is_none(&self) -> bool {
+        self.rx.is_none()
+    }
+}
+impl Future for OnUpgrade {
+    type Output = Result<Upgraded, crate::Error>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        match self.rx {
+            Some(ref mut rx) => {
+                Pin::new(rx)
+                    .poll(cx)
+                    .map(|res| match res {
+                        Ok(Ok(upgraded)) => Ok(upgraded),
+                        Ok(Err(err)) => Err(err),
+                        Err(_oneshot_canceled) => {
+                            Err(crate::Error::new_canceled().with(UpgradeExpected))
+                        }
+                    })
+            }
+            None => Poll::Ready(Err(crate::Error::new_user_no_upgrade())),
+        }
+    }
+}
+impl fmt::Debug for OnUpgrade {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("OnUpgrade").finish()
+    }
+}
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl Pending {
+    pub(super) fn fulfill(self, upgraded: Upgraded) {
+        trace!("pending upgrade fulfill");
+        let _ = self.tx.send(Ok(upgraded));
+    }
+    #[cfg(feature = "http1")]
+    /// Don't fulfill the pending Upgrade, but instead signal that
+    /// upgrades are handled manually.
+    pub(super) fn manual(self) {
+        trace!("pending upgrade handled manually");
+        let _ = self.tx.send(Err(crate::Error::new_user_manual_upgrade()));
+    }
+}
+/// Error cause returned when an upgrade was expected but canceled
+/// for whatever reason.
+///
+/// This likely means the actual `Conn` future wasn't polled and upgraded.
+#[derive(Debug)]
+struct UpgradeExpected;
+impl fmt::Display for UpgradeExpected {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("upgrade expected but not completed")
+    }
+}
+impl StdError for UpgradeExpected {}
+pub(super) trait Io: AsyncRead + AsyncWrite + Unpin + 'static {
+    fn __hyper_type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+}
+impl<T: AsyncRead + AsyncWrite + Unpin + 'static> Io for T {}
+impl dyn Io + Send {
+    fn __hyper_is<T: Io>(&self) -> bool {
+        let t = TypeId::of::<T>();
+        self.__hyper_type_id() == t
+    }
+    fn __hyper_downcast<T: Io>(self: Box<Self>) -> Result<Box<T>, Box<Self>> {
+        if self.__hyper_is::<T>() {
+            unsafe {
+                let raw: *mut dyn Io = Box::into_raw(self);
+                Ok(Box::from_raw(raw as *mut T))
+            }
+        } else {
+            Err(self)
+        }
+    }
+}
+mod sealed {
+    use super::OnUpgrade;
+    pub(crate) trait CanUpgrade {
+        fn on_upgrade(self) -> OnUpgrade;
+    }
+    impl<B> CanUpgrade for http::Request<B> {
+        fn on_upgrade(mut self) -> OnUpgrade {
+            self.extensions_mut().remove::<OnUpgrade>().unwrap_or_else(OnUpgrade::none)
+        }
+    }
+    impl<B> CanUpgrade for &'_ mut http::Request<B> {
+        fn on_upgrade(self) -> OnUpgrade {
+            self.extensions_mut().remove::<OnUpgrade>().unwrap_or_else(OnUpgrade::none)
+        }
+    }
+    impl<B> CanUpgrade for http::Response<B> {
+        fn on_upgrade(mut self) -> OnUpgrade {
+            self.extensions_mut().remove::<OnUpgrade>().unwrap_or_else(OnUpgrade::none)
+        }
+    }
+    impl<B> CanUpgrade for &'_ mut http::Response<B> {
+        fn on_upgrade(self) -> OnUpgrade {
+            self.extensions_mut().remove::<OnUpgrade>().unwrap_or_else(OnUpgrade::none)
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn upgraded_downcast() {
+        let upgraded = Upgraded::new(Mock, Bytes::new());
+        let upgraded = upgraded.downcast::<std::io::Cursor<Vec<u8>>>().unwrap_err();
+        upgraded.downcast::<Mock>().unwrap();
+    }
+    struct Mock;
+    impl AsyncRead for Mock {
+        fn poll_read(
+            self: Pin<&mut Self>,
+            _cx: &mut task::Context<'_>,
+            _buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            unreachable!("Mock::poll_read")
+        }
+    }
+    impl AsyncWrite for Mock {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _: &mut task::Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            Poll::Ready(Ok(buf.len()))
+        }
+        fn poll_flush(
+            self: Pin<&mut Self>,
+            _cx: &mut task::Context<'_>,
+        ) -> Poll<io::Result<()>> {
+            unreachable!("Mock::poll_flush")
+        }
+        fn poll_shutdown(
+            self: Pin<&mut Self>,
+            _cx: &mut task::Context<'_>,
+        ) -> Poll<io::Result<()>> {
+            unreachable!("Mock::poll_shutdown")
+        }
+    }
+}
diff --git a/warp/.github/FUNDING.yml b/warp/.github/FUNDING.yml
new file mode 100644
index 0000000..a6b3376
--- /dev/null
+++ b/warp/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: [seanmonstar]
diff --git a/warp/.github/ISSUE_TEMPLATE/bug_report.md b/warp/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..34ee804
--- /dev/null
+++ b/warp/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,36 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Version**
+List the versions of all `warp` crates you are using. The easiest way to get
+this information is using `cargo-tree`.
+
+`cargo install cargo-tree`
+(see install here: https://github.com/sfackler/cargo-tree)
+
+Then:
+
+`cargo tree | grep warp`
+
+**Platform**
+The output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
+
+**Description**
+Enter your issue details here.
+One way to structure the description:
+
+[short summary of the bug]
+
+I tried this code:
+
+[code sample that causes the bug]
+
+I expected to see this happen: [explanation]
+
+Instead, this happened: [explanation]
diff --git a/warp/.github/ISSUE_TEMPLATE/config.yml b/warp/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000..be346fe
--- /dev/null
+++ b/warp/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,6 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Question
+    url: https://discord.gg/RFsPjyt
+    about: 'Please post your question on the #warp discord channel. You may
+           also be able to find help at https://users.rust-lang.org/.'
diff --git a/warp/.github/ISSUE_TEMPLATE/feature_request.md b/warp/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..4fe86d5
--- /dev/null
+++ b/warp/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/warp/.github/workflows/ci.yml b/warp/.github/workflows/ci.yml
new file mode 100644
index 0000000..7a1cd98
--- /dev/null
+++ b/warp/.github/workflows/ci.yml
@@ -0,0 +1,97 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  style:
+    name: Check Style
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          components: rustfmt
+          profile: minimal
+          override: true
+
+      - name: cargo fmt -- --check
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+  test:
+    name: Test
+    needs: [style]
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        build: [stable, beta, nightly, tls, no-default-features, compression]
+
+        include:
+          - build: beta
+            rust: beta
+          - build: nightly
+            rust: nightly
+            benches: true
+          - build: tls
+            features: "--features tls"
+          - build: no-default-features
+            features: "--no-default-features"
+          - build: compression
+            features: "--features compression"
+
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust || 'stable' }}
+          profile: minimal
+          override: true
+
+      - name: Test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: ${{ matrix.features }}
+
+      - name: Test all benches
+        if: matrix.benches
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --benches ${{ matrix.features }}
+
+  doc:
+    name: Build docs
+    needs: [style, test]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+
+      - name: cargo doc
+        uses: actions-rs/cargo@v1
+        with:
+          command: rustdoc
+          args: -- -D broken_intra_doc_links
diff --git a/warp/.gitignore b/warp/.gitignore
new file mode 100644
index 0000000..3e631c8
--- /dev/null
+++ b/warp/.gitignore
@@ -0,0 +1,6 @@
+
+/target
+**/*.rs.bk
+Cargo.lock
+.idea/
+warp.iml
diff --git a/warp/CHANGELOG.md b/warp/CHANGELOG.md
new file mode 100644
index 0000000..dbf80b8
--- /dev/null
+++ b/warp/CHANGELOG.md
@@ -0,0 +1,324 @@
+### v0.3.3 (September 27, 2022)
+
+- **Fixes**:
+  - Fix `fs` filters path sanitization to reject colons on Windows.
+
+### v0.3.2 (November 9, 2021)
+
+- **Features**:
+  - Add `Filter::then()`, which is like `Filter::map()` in that it's infallible, but is async like `Filter::and_then()`.
+  - Add `redirect::found()` reply helper that returns `302 Found`.
+  - Add `compression-brotli` and `compression-gzip` cargo features to enable only the compression you need.
+  - Allow `HEAD` requests to be served to `fs::dir()` filters.
+  - Allow `path!()` with no arguments.
+- **Fixes**:
+  - Update private dependencies Tungstenite and Multipart.
+  - Replaces uses of `futures` with `futures-util`, which is a smaller dependency.
+
+
+### v0.3.1 (March 24, 2021)
+
+- **Features**:
+  - Add `pong` constructor to websocket messages.
+  - Add `redirect::see_other` and `redirect::permanent` helpers.
+- **Fixes**:
+  - Fix `fs` filters sometimes having an off-by-one error with range requests.
+  - Fix CORS to allow spaces when checking `Access-Control-Request-Headers`.
+
+## v0.3.0 (January 19, 2021)
+
+- **Features**:
+  - Add TLS client authentication support.
+  - Add TLS OCSP stapling support.
+  - Add `From<Reject>` for `Rejection`.
+  - Add `close_frame` accessor to `ws::Message`.
+- **Changes**:
+  - Update to Tokio v1.
+  - Update to Bytes v1.
+  - Update to hyper v0.14.
+  - Rework `sse` filter to be more like `ws`, with a single `Event` type and builder.
+  - Change `cookie` filter to extract a generic `FromStr` value.
+
+
+### v0.2.5 (August 31, 2020)
+
+- **Features**:
+  - Add `wrap_fn`, which can be used to create a `Wrap` from a closure. These in turn are used with `Filter::with()`.
+  - Add `warp::host` filters to deal with `Host`/`:authority` headers.
+  - Relax some lifetime bounds on `Server`.
+- **Fixes**:
+  - Fix panic when URI doesn't have a slash (for example, `CONNECT foo.bar`).
+
+### v0.2.4 (July 20, 2020)
+
+- **Features**:
+  - Add `tracing` internals in place of `log` (log is still emitted for backwards compatibility).
+  - Add `warp::trace` module set of filters to customize `tracing` dianostics.
+  - Add `path` method to `warp::fs::File` reply.
+  - Add `source` implementation for `BodyDeserializeError`.
+  - Make `warp::ws::MissingConnectionUpgrade` rejection public.
+
+### v0.2.3 (May 19, 2020)
+
+- **Features**:
+  - Add `warp::compression` filters, which will compress response bodies.
+  - Add `warp::header::value()` filter to get a request `HeaderValue`.
+  - Add `request_headers` method to `warp::log::Info`.
+  - Add `max_frame_size` to `warp::ws::Ws` builder.
+  - Add `remote_addr` to `warp::test::RequestBuilder`.
+  - Add `try_bind_with_graceful_shutdown` to `warp::Server` builder.
+  - Add `serve_incoming_with_graceful_shutdown` to `warp::Server` builder.
+- **Fixes**:
+  - Fix `warp::addr::remote` when used with `Server::tls`.
+  - Fix panic in `warp::path::{peek, tail, full}` filters when the request URI is in authority-form or asterisk-form.
+
+### v0.2.2 (March 3, 2020)
+
+- **Features**:
+  - Implement `Reply` for all `Box<T>` where `T: Reply`.
+  - Add `name` methods to `MissingHeader`, `InvalidHeader`, and `MissingCookie` rejections.
+  - Add `warp::ext::optional()` filter that optionally retrieves an extension from the request.
+- **Fixes**:
+  - Fix the sending of pings when a user sends a `ws::Message::ping()`.
+
+### v0.2.1 (January 23, 2020)
+
+- **Features**:
+  - Add `close` and `close_with` constructors to `warp::ws::Message`.
+- **Fixes**:
+  - Fix `warp::fs` filters using a very small read buffer.
+
+## v0.2.0 (January 16, 2020)
+
+- **Features**:
+  - Update to `std::future`, adding `async`/`await` support!
+  - Add `warp::service()` to convert a `Filter` into a `tower::Service`.
+  - Implement `Reply` for `Box<dyn Reply>`.
+- **Changes**:
+  - Refactored Rejection system (#311).
+  - Change `path!` macro to assume a `path::end()` by default, with explicit `/ ..` to allow building a prefix (#359).
+  - Change `warp::path(str)` to accept any `AsRef<str>` argument.
+  - Rename "2"-suffixed filters and types (`get2` to `get`, `ws2` to `ws`, etc).
+  - `Filter::{or, or_else, recover}` now require `Self::Error=Rejection`. This helps catch filters that didn't make sense (like `warp::any().or(warp::get())`).
+  - Change several `warp::body` filters (#345).
+  - Change `warp::cors()` to return a `warp::cors::Builder` which still implements `Wrap`, but can also `build` a cheaper-to-clone wrapper.
+  - Change `warp::multipart` stream API to allow for errors when streaming.
+  - Change `warp::sse` to no longer return a `Filter`, adds `warp::sse::reply` to do what `Sse::reply` did.
+  - Change `Server::tls()` to return a TLS server builder (#340).
+  - Change internal `warp::never::Never` usage with `std::convert::Infallible`.
+  - Remove `warp::ext::set()` function (#222).
+  - Remove deprecated `warp::cookie::optional_value()`.
+
+
+### v0.1.20 (September 17, 2019)
+
+- **Features**:
+  - Implement `Clone` for the `warp::cors` filter.
+  - Add `into_bytes` method for `warp::ws::Message`.
+
+### v0.1.19 (August 16, 2019)
+
+- **Features**:
+  - Make `warp::multipart` and `wrap::ws` support optional, though enabled by default.
+- **Fixes**:
+  - Fix `warp::fs::dir` filter to reject paths containing backslashes.
+
+### v0.1.18 (July 25, 2019)
+
+- **Features**:
+  - Add `warp::multipart` support.
+
+### v0.1.17 (July 8, 2019)
+
+- **Features**:
+  - Export all built-in Rejection causes in the `warp::reject` module.
+  - Add `Server::try_bind` as fallible bind methods.
+
+### v0.1.16 (June 11, 2019)
+
+- **Features**:
+  - Unseal the `Reply` trait: custom types can now implement `Reply`.
+  - Add `warp::sse::keep_alive()` replacement for `warp::sse::keep()` which allows customizing keep-alive behavior.
+  - Add `warp::log::Info::host()` accessor.
+- **Fixes**:
+  - Fix `warp::fs` filters from sending some headers for `304` responses.
+
+### v0.1.15 (April 2, 2019)
+
+- **Features**:
+  - Add more accessors to `warp::log::Info` type for building custom log formats.
+  - Implement `Reply` for `Cow<'static, str>`.
+
+### v0.1.14 (March 19, 2019)
+
+- **Features**:
+  - Add `warp::header::optional` filter.
+
+### v0.1.13 (February 13, 2019)
+
+- **Features**:
+  - Implement `Reply` for `Vec<u8>` and `&'static [u8]`.
+  - Set `content-type` header automatically for string and bytes replies.
+  - Add `expose_headers` to `warp::cors` filter.
+
+### v0.1.12 (January 29, 2019)
+
+- **Features**:
+  - Implement `PartialEq`, `Eq`, and `Clone` for `warp::ws::Message`.
+- **Fixes**:
+  - Fix panic when incoming request URI may not have a path (such as `CONNECT` requests).
+
+### v0.1.11 (January 14, 2019)
+
+- **Features**:
+  - Add `warp::sse` filters for handling Server-Sent-Events.
+  - Add `allow_headers` to `warp::cors` filter.
+- **Fixes**:
+  - Fix TLS handshake to close the connection if handshake fails.
+
+### v0.1.10 (December 17, 2018)
+
+- **Features**:
+  - Add optional TLS support. Enable the `tls` feature, and then use `Server::tls`.
+  - Add `warp::cors` filter for CORS support.
+  - Add `warp::addr::remote` to access the remote address of a request.
+  - Add `warp::log::custom` to support customizing of access logging.
+  - Add `warp::test::ws` to improve testing Websocket filters.
+
+### v0.1.9 (October 30, 2018)
+
+- **Features**:
+  - Add `warp::ext::get` and `warp::ext::set` to set request extensions.
+  - Add `Filter::untuple_one` to unroll nested tuple layers from extractions.
+  - Add `Ws2::max_send_queue` configuration method.
+  - Add `ws::Message::is_ping` method, and yield pings to user code.
+- **Fixes**:
+  - Fix panic in debug mode when receiving a websocket ping.
+
+### v0.1.8 (October 25, 2018)
+
+- **Features**:
+  - Improved flexibility of `Rejection` system.
+    
+    The `Rejection` type can now nest and combine arbitrary rejections,
+    so it is no longer bound to a small set of meanings. The ranking of
+    status codes is still used to determine which rejection gets priority.
+    
+    A different priority can be implemented by handling rejections with
+    a `Filter::recover`, and searching for causes in order via
+    `Rejection::find_cause`.
+    - Adds `warp::reject::custom()` to create a `Rejection` with
+      any `Into<Box<std::error::Error>>`. These rejections should be
+      handled with an eventual `Filter::recover`. Any unhandled
+      custom rejections are considered a server error.
+    - Deprecates `Rejection::with`. Use custom rejections instead.
+    - Deprecates `Rejection::into_cause`, as it can no longer work. Always
+      returns `Err(Rejection)`.
+    - Deprecates `Rejection::json`, since the format needed is too generic.
+      The `errors.rs` example shows how to send custom JSON when recovering
+      from rejections.
+    - Deprecates `warp::reject()`, since it current signals a `400 Bad
+      Request`, but in newer versions, it will signal `404 Not Found`.
+      It's deprecated simply to warn that the semantics are changing,
+      but the function won't actually go away.
+    - Deprecates `reject::bad_request()`, `reject::forbidden()`, and
+      `reject::server_error()`. Uses custom rejections instead.
+  - Renamed `warp::path::index` to `warp::path::end`.
+
+
+### v0.1.7 (October 15, 2018)
+
+- **Features**:
+  - Export the types returned from the `warp::body::stream()` filter, `BodyStream` and `StreamBuf`.
+  - Deprecated `Rejection::into_cause`, since an upcoming Rejection refactor will make it impossible to support.
+
+- **Fixes**:
+  - Fix websocket filters to do a case-insensitive match of the `Connection` header.
+
+### v0.1.6 (October 5, 2018)
+
+- **Features**:
+  - Add Conditional and Range request support for `warp::fs` filters.
+  - Relaxed bounds on `Rejection::with` to no longer need to be `Sized`.
+  - Add `warp::path::peek()` which gets the unmatched tail without adjusting the currently matched path.
+
+### v0.1.5 (October 3, 2018)
+
+- **Features**:
+  - Serve `index.html` automatically with `warp::fs::dir` filter.
+  - Include `last-modified` header with `warp::fs` filters.
+  - Add `warp::redirect` to easily reply with redirections.
+  - Add `warp::reply::{with_status, with_header}` to wrap `impl Reply`s directly with a new status code or header.
+  - Add support for running a warp `Server` with a custom source of incoming connections.
+    - `Server::run_incoming` to have the runtime started automatically.
+    - `Server::serve_incoming` to get a future to run on existing runtime.
+    - These can be used to support Unix Domain Sockets, TLS, and other transports.
+  - Add `Rejection::into_cause()` to retrieve the original error of a rejection back.
+  - Add `Rejection::json()` to convert a rejection into a JSON response.
+
+- **Fixes**
+  - Internal errors in warp that result in rendering a `500 Internal Server Error` are now also logged at the `error` level.
+
+
+### v0.1.4 (September 25, 2018)
+
+- **Features**:
+  - Add `warp::reply::with::headers(HeaderMap)` filter wrapper.
+  - Add `warp::cookie::optional()` to get an optional cookie value.
+  - Add `warp::path::full()` to be able to extract the full request path without affecting route matching.
+  - Add graceful shutdown support to the `Server`.
+  - Allow empty query strings to be treated as for `warp::query()`.
+
+### v0.1.3 (August 28, 2018)
+
+- **Features**:
+  - Add `warp::reject::forbidden()` to represent `403 Forbidden` responses.
+  - Add `Rejection::with(cause)` to customize rejection messages.
+- **Fixes**:
+  - Fix `warp::body::form` to allow charsets in the `content-type` header.
+
+### v0.1.2 (August 14, 2018)
+
+- **Features**:
+  - Implemented `Reply` for `Response<impl Into<hyper::Body>`, allowing streaming response bodies.
+  - Add `warp::body::stream()` filter to access the request body as an `impl Stream`.
+  - Add `warp::ws2()` as a more flexible websocket filter.
+    - This allows passing other extracted values to the upgrade callback, such as a value from a header or path.
+    - Deprecates `warp::ws()`, and `ws2()` will become `ws()` in 0.2.
+  - Add `warp::get2()`, `warp::post2()`, `warp::put2()`, and `warp::delete2()` as more standard method filters that are used via chaining instead of nesting.
+    - `get()`, `post()`, `put()`, and `delete()` are deprecated, and the new versions will become them in 0.2.
+  - Add `Filter::unify()` for when a filter returns `Either<T, T>`, converting the `Either` into the inner `T`, regardless of which variant it was.
+    - This requires that both sides of the `Either` be the same type.
+    - This can be useful when extracting a value that might be present in different places of the request.
+      
+      ```rust
+      // Allow `MyId` to be a path parameter or a header...
+      let id = warp::path::param::<MyId>()
+          .or(warp::header::<MyId>())
+          .unify();
+      
+      // A way of providing default values...
+      let dnt = warp::header::<bool>("dnt")
+          .or(warp::any().map(|| true))
+          .unify();
+      ```
+  - Add `content-type` header automatically to replies from `file` and `dir` filters based on file extension.
+  - Add `warp::head()`, `warp::options()`, and `warp::patch()` as new Method filters.
+  - Try to use OS blocksize in `warp::fs` filters.
+- **Fixes**:
+  - Chaining filters that try to consume the request body will log that the body is already consumed, and return a `500 Internal Server Error` rejection.
+
+### v0.1.1 (August 7, 2018)
+
+- **Features**:
+  - Add `warp::query::raw()` filter to get query as a `String`.
+  - Add `Filter::recover()` to ease customizing of rejected responses.
+  - Add `warp::header::headers_clone()` filter to get a clone of request's `HeaderMap`.
+  - Add `warp::path::tail()` filter to get remaining "tail" of the request path.
+- **Fixes**:
+  - URL decode path segments in `warp::fs` filters.
+
+
+## v0.1.0 (August 1, 2018)
+
+- Initial release.
diff --git a/warp/Cargo.toml b/warp/Cargo.toml
new file mode 100644
index 0000000..62ee566
--- /dev/null
+++ b/warp/Cargo.toml
@@ -0,0 +1,98 @@
+[package]
+name = "warp"
+version = "0.3.3" # don't forget to update html_root_url
+description = "serve the web at warp speeds"
+authors = ["Sean McArthur <sean@seanmonstar.com>"]
+license = "MIT"
+readme = "README.md"
+documentation = "https://docs.rs/warp"
+repository = "https://github.com/seanmonstar/warp"
+categories = ["web-programming::http-server"]
+keywords = ["warp", "server", "http", "hyper"]
+autotests = true
+autoexamples = true
+edition = "2018"
+
+[package.metadata.docs.rs]
+all-features = true
+
+[dependencies]
+async-compression = { version = "0.3.7", features = ["tokio"], optional = true }
+bytes = "1.0"
+futures-util = { version = "0.3", default-features = false, features = ["sink"] }
+futures-channel = { version = "0.3.17", features = ["sink"]}
+headers = "0.3"
+http = "0.2"
+hyper = { version = "0.14", features = ["stream", "server", "http1", "http2", "tcp", "client"] }
+log = "0.4"
+mime = "0.3"
+mime_guess = "2.0.0"
+multipart = { version = "0.18", default-features = false, features = ["server"], optional = true }
+scoped-tls = "1.0"
+serde = "1.0"
+serde_json = "1.0"
+serde_urlencoded = "0.7"
+tokio = { version = "1.0", features = ["fs", "sync", "time"] }
+tokio-stream = "0.1.1"
+tokio-util = { version = "0.7", features = ["io"] }
+tracing = { version = "0.1.21", default-features = false, features = ["log", "std"] }
+tower-service = "0.3"
+tokio-tungstenite = { version = "0.17", optional = true }
+percent-encoding = "2.1"
+pin-project = "1.0"
+tokio-rustls = { version = "0.23", optional = true }
+rustls-pemfile = "0.2"
+
+[dev-dependencies]
+pretty_env_logger = "0.4"
+tracing-subscriber = "0.2.7"
+tracing-log = "0.1"
+serde_derive = "1.0"
+handlebars = "4.0"
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
+tokio-stream = { version = "0.1.1", features = ["net"] }
+listenfd = "0.3"
+
+[features]
+default = ["multipart", "websocket"]
+websocket = ["tokio-tungstenite"]
+tls = ["tokio-rustls"]
+
+# Enable compression-related filters
+compression = ["compression-brotli", "compression-gzip"]
+compression-brotli = ["async-compression/brotli"]
+compression-gzip = ["async-compression/deflate", "async-compression/gzip"]
+
+[profile.release]
+codegen-units = 1
+incremental = false
+
+[profile.bench]
+codegen-units = 1
+incremental = false
+
+[[test]]
+name = "multipart"
+required-features = ["multipart"]
+
+[[test]]
+name = "ws"
+required-features = ["websocket"]
+
+[[example]]
+name = "compression"
+required-features = ["compression"]
+
+[[example]]
+name = "unix_socket"
+
+[[example]]
+name = "websockets"
+required-features = ["websocket"]
+
+[[example]]
+name = "websockets_chat"
+required-features = ["websocket"]
+
+[[example]]
+name = "query_string"
diff --git a/warp/LICENSE b/warp/LICENSE
new file mode 100644
index 0000000..4ba959d
--- /dev/null
+++ b/warp/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2018-2020 Sean McArthur
+
+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.
+
diff --git a/warp/README.md b/warp/README.md
new file mode 100644
index 0000000..0f65594
--- /dev/null
+++ b/warp/README.md
@@ -0,0 +1,63 @@
+# warp
+
+[![crates.io](https://img.shields.io/crates/v/warp.svg)](https://crates.io/crates/warp)
+[![Released API docs](https://docs.rs/warp/badge.svg)](https://docs.rs/warp)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+[![GHA Build Status](https://github.com/seanmonstar/warp/workflows/CI/badge.svg)](https://github.com/seanmonstar/warp/actions?query=workflow%3ACI)
+[![Discord chat][discord-badge]][discord-url]
+
+A super-easy, composable, web server framework for warp speeds.
+
+The fundamental building block of `warp` is the `Filter`: they can be combined
+and composed to express rich requirements on requests.
+
+Thanks to its `Filter` system, warp provides these out of the box:
+
+* Path routing and parameter extraction
+* Header requirements and extraction
+* Query string deserialization
+* JSON and Form bodies
+* Multipart form data
+* Static Files and Directories
+* Websockets
+* Access logging
+* Gzip, Deflate, and Brotli compression
+
+Since it builds on top of [hyper](https://hyper.rs), you automatically get:
+
+- HTTP/1
+- HTTP/2
+- Asynchronous
+- One of the fastest HTTP implementations
+- Tested and **correct**
+
+## Example
+
+Add warp and Tokio to your dependencies:
+
+```toml
+tokio = { version = "1", features = ["full"] }
+warp = "0.3"
+```
+
+And then get started in your `main.rs`:
+
+```rust
+use warp::Filter;
+
+#[tokio::main]
+async fn main() {
+    // GET /hello/warp => 200 OK with body "Hello, warp!"
+    let hello = warp::path!("hello" / String)
+        .map(|name| format!("Hello, {}!", name));
+
+    warp::serve(hello)
+        .run(([127, 0, 0, 1], 3030))
+        .await;
+}
+```
+
+For more information you can check the [docs](https://docs.rs/warp) or the [examples](https://github.com/seanmonstar/warp/tree/master/examples).
+
+[discord-badge]: https://img.shields.io/discord/500028886025895936.svg?logo=discord
+[discord-url]: https://discord.gg/RFsPjyt
diff --git a/warp/src/error.rs b/warp/src/error.rs
new file mode 100644
index 0000000..2bdde4e
--- /dev/null
+++ b/warp/src/error.rs
@@ -0,0 +1,50 @@
+use std::convert::Infallible;
+use std::error::Error as StdError;
+use std::fmt;
+type BoxError = Box<dyn std::error::Error + Send + Sync>;
+/// Errors that can happen inside warp.
+pub struct Error {
+    inner: BoxError,
+}
+impl Error {
+    pub(crate) fn new<E: Into<BoxError>>(err: E) -> Error {
+        loop {}
+    }
+}
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        loop {}
+    }
+}
+impl From<Infallible> for Error {
+    fn from(infallible: Infallible) -> Error {
+        loop {}
+    }
+}
+#[test]
+fn error_size_of() {
+    loop {}
+}
+#[test]
+fn error_source() {
+    loop {}
+}
+macro_rules! unit_error {
+    ($(#[$docs:meta])* $pub:vis $typ:ident : $display:literal) => {
+        $(#[$docs])* $pub struct $typ { _p : (), } impl ::std::fmt::Debug for $typ { fn
+        fmt(& self, f : & mut ::std::fmt::Formatter <'_ >) -> ::std::fmt::Result { f
+        .debug_struct(stringify!($typ)).finish() } } impl ::std::fmt::Display for $typ {
+        fn fmt(& self, f : & mut ::std::fmt::Formatter <'_ >) -> ::std::fmt::Result { f
+        .write_str($display) } } impl ::std::error::Error for $typ {}
+    };
+}
diff --git a/warp/src/filter/and.rs b/warp/src/filter/and.rs
new file mode 100644
index 0000000..7e40ac5
--- /dev/null
+++ b/warp/src/filter/and.rs
@@ -0,0 +1,72 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use pin_project::pin_project;
+use super::{Combine, Filter, FilterBase, Internal, Tuple};
+use crate::generic::CombinedTuples;
+use crate::reject::CombineRejection;
+#[derive(Clone, Copy, Debug)]
+pub struct And<T, U> {
+    pub(super) first: T,
+    pub(super) second: U,
+}
+impl<T, U> FilterBase for And<T, U>
+where
+    T: Filter,
+    T::Extract: Send,
+    U: Filter + Clone + Send,
+    <T::Extract as Tuple>::HList: Combine<<U::Extract as Tuple>::HList> + Send,
+    CombinedTuples<T::Extract, U::Extract>: Send,
+    U::Error: CombineRejection<T::Error>,
+{
+    type Extract = CombinedTuples<T::Extract, U::Extract>;
+    type Error = <U::Error as CombineRejection<T::Error>>::One;
+    type Future = AndFuture<T, U>;
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct AndFuture<T: Filter, U: Filter> {
+    #[pin]
+    state: State<T::Future, T::Extract, U>,
+}
+#[pin_project(project = StateProj)]
+enum State<T, TE, U: Filter> {
+    First(#[pin] T, U),
+    Second(Option<TE>, #[pin] U::Future),
+    Done,
+}
+impl<T, U> Future for AndFuture<T, U>
+where
+    T: Filter,
+    U: Filter,
+    <T::Extract as Tuple>::HList: Combine<<U::Extract as Tuple>::HList> + Send,
+    U::Error: CombineRejection<T::Error>,
+{
+    type Output = Result<
+        CombinedTuples<T::Extract, U::Extract>,
+        <U::Error as CombineRejection<T::Error>>::One,
+    >;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
+impl<T, TE, U, E> Future for State<T, TE, U>
+where
+    T: Future<Output = Result<TE, E>>,
+    U: Filter,
+    TE: Tuple,
+    TE::HList: Combine<<U::Extract as Tuple>::HList> + Send,
+    U::Error: CombineRejection<E>,
+{
+    type Output = Result<
+        CombinedTuples<TE, U::Extract>,
+        <U::Error as CombineRejection<E>>::One,
+    >;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/and_then.rs b/warp/src/filter/and_then.rs
new file mode 100644
index 0000000..03306dd
--- /dev/null
+++ b/warp/src/filter/and_then.rs
@@ -0,0 +1,81 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use futures_util::{TryFuture};
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Func, Internal};
+use crate::reject::CombineRejection;
+#[derive(Clone, Copy, Debug)]
+pub struct AndThen<T, F> {
+    pub(super) filter: T,
+    pub(super) callback: F,
+}
+impl<T, F> FilterBase for AndThen<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract> + Clone + Send,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: CombineRejection<T::Error>,
+{
+    type Extract = (<F::Output as TryFuture>::Ok,);
+    type Error = <<F::Output as TryFuture>::Error as CombineRejection<T::Error>>::One;
+    type Future = AndThenFuture<T, F>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct AndThenFuture<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract>,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: CombineRejection<T::Error>,
+{
+    #[pin]
+    state: State<T::Future, F>,
+}
+#[pin_project(project = StateProj)]
+enum State<T, F>
+where
+    T: TryFuture,
+    F: Func<T::Ok>,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: CombineRejection<T::Error>,
+{
+    First(#[pin] T, F),
+    Second(#[pin] F::Output),
+    Done,
+}
+impl<T, F> Future for AndThenFuture<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract>,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: CombineRejection<T::Error>,
+{
+    type Output = Result<
+        (<F::Output as TryFuture>::Ok,),
+        <<F::Output as TryFuture>::Error as CombineRejection<T::Error>>::One,
+    >;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
+impl<T, F> Future for State<T, F>
+where
+    T: TryFuture,
+    F: Func<T::Ok>,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: CombineRejection<T::Error>,
+{
+    type Output = Result<
+        (<F::Output as TryFuture>::Ok,),
+        <<F::Output as TryFuture>::Error as CombineRejection<T::Error>>::One,
+    >;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/boxed.rs b/warp/src/filter/boxed.rs
new file mode 100644
index 0000000..8f1a9bf
--- /dev/null
+++ b/warp/src/filter/boxed.rs
@@ -0,0 +1,82 @@
+use std::fmt;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+
+use super::{Filter, FilterBase, Internal, Tuple};
+use crate::reject::Rejection;
+/// A type representing a boxed `Filter` trait object.
+///
+/// The filter inside is a dynamic trait object. The purpose of this type is
+/// to ease returning `Filter`s from other functions.
+///
+/// To create one, call `Filter::boxed` on any filter.
+///
+/// # Examples
+///
+/// ```
+/// use warp::{Filter, filters::BoxedFilter, Reply};
+///
+/// pub fn assets_filter() -> BoxedFilter<(impl Reply,)> {
+///     warp::path("assets")
+///         .and(warp::fs::dir("./assets"))
+///         .boxed()
+/// }
+/// ```
+///
+pub struct BoxedFilter<T: Tuple> {
+    filter: Arc<
+        dyn Filter<
+            Extract = T,
+            Error = Rejection,
+            Future = Pin<Box<dyn Future<Output = Result<T, Rejection>> + Send>>,
+        > + Send + Sync,
+    >,
+}
+impl<T: Tuple + Send> BoxedFilter<T> {
+    pub(super) fn new<F>(filter: F) -> BoxedFilter<T>
+    where
+        F: Filter<Extract = T> + Send + Sync + 'static,
+        F::Error: Into<Rejection>,
+    {
+        loop {}
+    }
+}
+impl<T: Tuple> Clone for BoxedFilter<T> {
+    fn clone(&self) -> BoxedFilter<T> {
+        loop {}
+    }
+}
+impl<T: Tuple> fmt::Debug for BoxedFilter<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+fn _assert_send() {
+    loop {}
+}
+impl<T: Tuple + Send> FilterBase for BoxedFilter<T> {
+    type Extract = T;
+    type Error = Rejection;
+    type Future = Pin<Box<dyn Future<Output = Result<T, Rejection>> + Send>>;
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+struct BoxingFilter<F> {
+    filter: F,
+}
+impl<F> FilterBase for BoxingFilter<F>
+where
+    F: Filter,
+    F::Future: Send + 'static,
+{
+    type Extract = F::Extract;
+    type Error = F::Error;
+    type Future = Pin<
+        Box<dyn Future<Output = Result<Self::Extract, Self::Error>> + Send>,
+    >;
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/map.rs b/warp/src/filter/map.rs
new file mode 100644
index 0000000..5e3f57c
--- /dev/null
+++ b/warp/src/filter/map.rs
@@ -0,0 +1,42 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Func, Internal};
+#[derive(Clone, Copy, Debug)]
+pub struct Map<T, F> {
+    pub(super) filter: T,
+    pub(super) callback: F,
+}
+impl<T, F> FilterBase for Map<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract> + Clone + Send,
+{
+    type Extract = (F::Output,);
+    type Error = T::Error;
+    type Future = MapFuture<T, F>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct MapFuture<T: Filter, F> {
+    #[pin]
+    extract: T::Future,
+    callback: F,
+}
+impl<T, F> Future for MapFuture<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract>,
+{
+    type Output = Result<(F::Output,), T::Error>;
+    #[inline]
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/map_err.rs b/warp/src/filter/map_err.rs
new file mode 100644
index 0000000..e0ecd20
--- /dev/null
+++ b/warp/src/filter/map_err.rs
@@ -0,0 +1,44 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Internal};
+use crate::reject::IsReject;
+#[derive(Clone, Copy, Debug)]
+pub struct MapErr<T, F> {
+    pub(super) filter: T,
+    pub(super) callback: F,
+}
+impl<T, F, E> FilterBase for MapErr<T, F>
+where
+    T: Filter,
+    F: Fn(T::Error) -> E + Clone + Send,
+    E: IsReject,
+{
+    type Extract = T::Extract;
+    type Error = E;
+    type Future = MapErrFuture<T, F>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct MapErrFuture<T: Filter, F> {
+    #[pin]
+    extract: T::Future,
+    callback: F,
+}
+impl<T, F, E> Future for MapErrFuture<T, F>
+where
+    T: Filter,
+    F: Fn(T::Error) -> E,
+{
+    type Output = Result<T::Extract, E>;
+    #[inline]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/mod.rs b/warp/src/filter/mod.rs
new file mode 100644
index 0000000..43c85db
--- /dev/null
+++ b/warp/src/filter/mod.rs
@@ -0,0 +1,425 @@
+mod and;
+mod and_then;
+mod boxed;
+mod map;
+mod map_err;
+mod or;
+mod or_else;
+mod recover;
+pub(crate) mod service;
+mod then;
+mod unify;
+mod untuple_one;
+mod wrap;
+use std::future::Future;
+use futures_util::{future, TryFuture, TryFutureExt};
+pub(crate) use crate::generic::{one, Combine, Either, Func, One, Tuple};
+use crate::reject::{CombineRejection, IsReject, Rejection};
+use crate::route::{Route};
+pub(crate) use self::and::And;
+use self::and_then::AndThen;
+pub use self::boxed::BoxedFilter;
+pub(crate) use self::map::Map;
+pub(crate) use self::map_err::MapErr;
+pub(crate) use self::or::Or;
+use self::or_else::OrElse;
+use self::recover::Recover;
+use self::then::Then;
+use self::unify::Unify;
+use self::untuple_one::UntupleOne;
+pub use self::wrap::wrap_fn;
+pub(crate) use self::wrap::{Wrap, WrapSealed};
+pub trait FilterBase {
+    type Extract: Tuple;
+    type Error: IsReject;
+    type Future: Future<Output = Result<Self::Extract, Self::Error>> + Send;
+    fn filter(&self, internal: Internal) -> Self::Future;
+    fn map_err<F, E>(self, _internal: Internal, fun: F) -> MapErr<Self, F>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E + Clone,
+        E: ::std::fmt::Debug + Send,
+    {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+pub struct Internal;
+/// Composable request filters.
+///
+/// A `Filter` can optionally extract some data from a request, combine
+/// it with others, mutate it, and return back some value as a reply. The
+/// power of `Filter`s come from being able to isolate small subsets, and then
+/// chain and reuse them in various parts of your app.
+///
+/// # Extracting Tuples
+///
+/// You may notice that several of these filters extract some tuple, often
+/// times a tuple of just 1 item! Why?
+///
+/// If a filter extracts a `(String,)`, that simply means that it
+/// extracts a `String`. If you were to `map` the filter, the argument type
+/// would be exactly that, just a `String`.
+///
+/// What is it? It's just some type magic that allows for automatic combining
+/// and flattening of tuples. Without it, combining two filters together with
+/// `and`, where one extracted `()`, and another `String`, would mean the
+/// `map` would be given a single argument of `((), String,)`, which is just
+/// no fun.
+pub trait Filter: FilterBase {
+    /// Composes a new `Filter` that requires both this and the other to filter a request.
+    ///
+    /// Additionally, this will join together the extracted values of both
+    /// filters, so that `map` and `and_then` receive them as separate arguments.
+    ///
+    /// If a `Filter` extracts nothing (so, `()`), combining with any other
+    /// filter will simply discard the `()`. If a `Filter` extracts one or
+    /// more items, combining will mean it extracts the values of itself
+    /// combined with the other.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// // Match `/hello/:name`...
+    /// warp::path("hello")
+    ///     .and(warp::path::param::<String>());
+    /// ```
+    fn and<F>(self, other: F) -> And<Self, F>
+    where
+        Self: Sized,
+        <Self::Extract as Tuple>::HList: Combine<<F::Extract as Tuple>::HList>,
+        F: Filter + Clone,
+        F::Error: CombineRejection<Self::Error>,
+    {
+        loop {}
+    }
+    /// Composes a new `Filter` of either this or the other filter.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use std::net::SocketAddr;
+    /// use warp::Filter;
+    ///
+    /// // Match either `/:u32` or `/:socketaddr`
+    /// warp::path::param::<u32>()
+    ///     .or(warp::path::param::<SocketAddr>());
+    /// ```
+    fn or<F>(self, other: F) -> Or<Self, F>
+    where
+        Self: Filter<Error = Rejection> + Sized,
+        F: Filter,
+        F::Error: CombineRejection<Self::Error>,
+    {
+        loop {}
+    }
+    /// Composes this `Filter` with a function receiving the extracted value.
+    ///
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// // Map `/:id`
+    /// warp::path::param().map(|id: u64| {
+    ///   format!("Hello #{}", id)
+    /// });
+    /// ```
+    ///
+    /// # `Func`
+    ///
+    /// The generic `Func` trait is implemented for any function that receives
+    /// the same arguments as this `Filter` extracts. In practice, this
+    /// shouldn't ever bother you, and simply makes things feel more natural.
+    ///
+    /// For example, if three `Filter`s were combined together, suppose one
+    /// extracts nothing (so `()`), and the other two extract two integers,
+    /// a function that accepts exactly two integer arguments is allowed.
+    /// Specifically, any `Fn(u32, u32)`.
+    ///
+    /// Without `Product` and `Func`, this would be a lot messier. First of
+    /// all, the `()`s couldn't be discarded, and the tuples would be nested.
+    /// So, instead, you'd need to pass an `Fn(((), (u32, u32)))`. That's just
+    /// a single argument. Bleck!
+    ///
+    /// Even worse, the tuples would shuffle the types around depending on
+    /// the exact invocation of `and`s. So, `unit.and(int).and(int)` would
+    /// result in a different extracted type from `unit.and(int.and(int))`,
+    /// or from `int.and(unit).and(int)`. If you changed around the order
+    /// of filters, while still having them be semantically equivalent, you'd
+    /// need to update all your `map`s as well.
+    ///
+    /// `Product`, `HList`, and `Func` do all the heavy work so that none of
+    /// this is a bother to you. What's more, the types are enforced at
+    /// compile-time, and tuple flattening is optimized away to nothing by
+    /// LLVM.
+    fn map<F>(self, fun: F) -> Map<Self, F>
+    where
+        Self: Sized,
+        F: Func<Self::Extract> + Clone,
+    {
+        loop {}
+    }
+    /// Composes this `Filter` with an async function receiving
+    /// the extracted value.
+    ///
+    /// The function should return some `Future` type.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// // Map `/:id`
+    /// warp::path::param().then(|id: u64| async move {
+    ///   format!("Hello #{}", id)
+    /// });
+    /// ```
+    fn then<F>(self, fun: F) -> Then<Self, F>
+    where
+        Self: Sized,
+        F: Func<Self::Extract> + Clone,
+        F::Output: Future + Send,
+    {
+        loop {}
+    }
+    /// Composes this `Filter` with a fallible async function receiving
+    /// the extracted value.
+    ///
+    /// The function should return some `TryFuture` type.
+    ///
+    /// The `Error` type of the return `Future` needs be a `Rejection`, which
+    /// means most futures will need to have their error mapped into one.
+    ///
+    /// Rejections are meant to say "this filter didn't accept the request,
+    /// maybe another can". So for application-level errors, consider using
+    /// [`Filter::then`] instead.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// // Validate after `/:id`
+    /// warp::path::param().and_then(|id: u64| async move {
+    ///     if id != 0 {
+    ///         Ok(format!("Hello #{}", id))
+    ///     } else {
+    ///         Err(warp::reject::not_found())
+    ///     }
+    /// });
+    /// ```
+    fn and_then<F>(self, fun: F) -> AndThen<Self, F>
+    where
+        Self: Sized,
+        F: Func<Self::Extract> + Clone,
+        F::Output: TryFuture + Send,
+        <F::Output as TryFuture>::Error: CombineRejection<Self::Error>,
+    {
+        loop {}
+    }
+    /// Compose this `Filter` with a function receiving an error.
+    ///
+    /// The function should return some `TryFuture` type yielding the
+    /// same item and error types.
+    fn or_else<F>(self, fun: F) -> OrElse<Self, F>
+    where
+        Self: Filter<Error = Rejection> + Sized,
+        F: Func<Rejection>,
+        F::Output: TryFuture<Ok = Self::Extract> + Send,
+        <F::Output as TryFuture>::Error: IsReject,
+    {
+        loop {}
+    }
+    /// Compose this `Filter` with a function receiving an error and
+    /// returning a *new* type, instead of the *same* type.
+    ///
+    /// This is useful for "customizing" rejections into new response types.
+    /// See also the [rejections example][ex].
+    ///
+    /// [ex]: https://github.com/seanmonstar/warp/blob/master/examples/rejections.rs
+    fn recover<F>(self, fun: F) -> Recover<Self, F>
+    where
+        Self: Filter<Error = Rejection> + Sized,
+        F: Func<Rejection>,
+        F::Output: TryFuture + Send,
+        <F::Output as TryFuture>::Error: IsReject,
+    {
+        loop {}
+    }
+    /// Unifies the extracted value of `Filter`s composed with `or`.
+    ///
+    /// When a `Filter` extracts some `Either<T, T>`, where both sides
+    /// are the same type, this combinator can be used to grab the
+    /// inner value, regardless of which side of `Either` it was. This
+    /// is useful for values that could be extracted from multiple parts
+    /// of a request, and the exact place isn't important.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use std::net::SocketAddr;
+    /// use warp::Filter;
+    ///
+    /// let client_ip = warp::header("x-real-ip")
+    ///     .or(warp::header("x-forwarded-for"))
+    ///     .unify()
+    ///     .map(|ip: SocketAddr| {
+    ///         // Get the IP from either header,
+    ///         // and unify into the inner type.
+    ///     });
+    /// ```
+    fn unify<T>(self) -> Unify<Self>
+    where
+        Self: Filter<Extract = (Either<T, T>,)> + Sized,
+        T: Tuple,
+    {
+        loop {}
+    }
+    /// Convenience method to remove one layer of tupling.
+    ///
+    /// This is useful for when things like `map` don't return a new value,
+    /// but just `()`, since warp will wrap it up into a `((),)`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// let route = warp::path::param()
+    ///     .map(|num: u64| {
+    ///         println!("just logging: {}", num);
+    ///         // returning "nothing"
+    ///     })
+    ///     .untuple_one()
+    ///     .map(|| {
+    ///         println!("the ((),) was removed");
+    ///         warp::reply()
+    ///     });
+    /// ```
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// let route = warp::any()
+    ///     .map(|| {
+    ///         // wanting to return a tuple
+    ///         (true, 33)
+    ///     })
+    ///     .untuple_one()
+    ///     .map(|is_enabled: bool, count: i32| {
+    ///         println!("untupled: ({}, {})", is_enabled, count);
+    ///     });
+    /// ```
+    fn untuple_one<T>(self) -> UntupleOne<Self>
+    where
+        Self: Filter<Extract = (T,)> + Sized,
+        T: Tuple,
+    {
+        loop {}
+    }
+    /// Wraps the current filter with some wrapper.
+    ///
+    /// The wrapper may do some preparation work before starting this filter,
+    /// and may do post-processing after the filter completes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// let route = warp::any()
+    ///     .map(warp::reply);
+    ///
+    /// // Wrap the route with a log wrapper.
+    /// let route = route.with(warp::log("example"));
+    /// ```
+    fn with<W>(self, wrapper: W) -> W::Wrapped
+    where
+        Self: Sized,
+        W: Wrap<Self>,
+    {
+        loop {}
+    }
+    /// Boxes this filter into a trait object, making it easier to name the type.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use warp::Filter;
+    ///
+    /// fn impl_reply() -> warp::filters::BoxedFilter<(impl warp::Reply,)> {
+    ///     warp::any()
+    ///         .map(warp::reply)
+    ///         .boxed()
+    /// }
+    ///
+    /// fn named_i32() -> warp::filters::BoxedFilter<(i32,)> {
+    ///     warp::path::param::<i32>()
+    ///         .boxed()
+    /// }
+    ///
+    /// fn named_and() -> warp::filters::BoxedFilter<(i32, String)> {
+    ///     warp::path::param::<i32>()
+    ///         .and(warp::header::<String>("host"))
+    ///         .boxed()
+    /// }
+    /// ```
+    fn boxed(self) -> BoxedFilter<Self::Extract>
+    where
+        Self: Sized + Send + Sync + 'static,
+        Self::Extract: Send,
+        Self::Error: Into<Rejection>,
+    {
+        loop {}
+    }
+}
+impl<T: FilterBase> Filter for T {}
+pub trait FilterClone: Filter + Clone {}
+impl<T: Filter + Clone> FilterClone for T {}
+fn _assert_object_safe() {
+    loop {}
+}
+pub(crate) fn filter_fn<F, U>(func: F) -> FilterFn<F>
+where
+    F: Fn(&mut Route) -> U,
+    U: TryFuture,
+    U::Ok: Tuple,
+    U::Error: IsReject,
+{
+    loop {}
+}
+pub(crate) fn filter_fn_one<F, U>(
+    func: F,
+) -> impl Filter<Extract = (U::Ok,), Error = U::Error> + Copy
+where
+    F: Fn(&mut Route) -> U + Copy,
+    U: TryFuture + Send + 'static,
+    U::Ok: Send,
+    U::Error: IsReject,
+{
+    filter_fn(move |route| func(route).map_ok(|item| (item,)))
+}
+#[derive(Copy, Clone)]
+#[allow(missing_debug_implementations)]
+pub(crate) struct FilterFn<F> {
+    func: F,
+}
+impl<F, U> FilterBase for FilterFn<F>
+where
+    F: Fn(&mut Route) -> U,
+    U: TryFuture + Send + 'static,
+    U::Ok: Tuple + Send,
+    U::Error: IsReject,
+{
+    type Extract = U::Ok;
+    type Error = U::Error;
+    type Future = future::IntoFuture<U>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/or.rs b/warp/src/filter/or.rs
new file mode 100644
index 0000000..2a2c9f3
--- /dev/null
+++ b/warp/src/filter/or.rs
@@ -0,0 +1,62 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Internal};
+use crate::generic::Either;
+use crate::reject::CombineRejection;
+
+type Combined<E1, E2> = <E1 as CombineRejection<E2>>::Combined;
+#[derive(Clone, Copy, Debug)]
+pub struct Or<T, U> {
+    pub(super) first: T,
+    pub(super) second: U,
+}
+impl<T, U> FilterBase for Or<T, U>
+where
+    T: Filter,
+    U: Filter + Clone + Send,
+    U::Error: CombineRejection<T::Error>,
+{
+    type Extract = (Either<T::Extract, U::Extract>,);
+    type Error = Combined<U::Error, T::Error>;
+    type Future = EitherFuture<T, U>;
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct EitherFuture<T: Filter, U: Filter> {
+    #[pin]
+    state: State<T, U>,
+    original_path_index: PathIndex,
+}
+#[pin_project(project = StateProj)]
+enum State<T: Filter, U: Filter> {
+    First(#[pin] T::Future, U),
+    Second(Option<T::Error>, #[pin] U::Future),
+    Done,
+}
+#[derive(Copy, Clone)]
+struct PathIndex(usize);
+impl PathIndex {
+    fn reset_path(&self) {
+        loop {}
+    }
+}
+impl<T, U> Future for EitherFuture<T, U>
+where
+    T: Filter,
+    U: Filter,
+    U::Error: CombineRejection<T::Error>,
+{
+    type Output = Result<
+        (Either<T::Extract, U::Extract>,),
+        Combined<U::Error, T::Error>,
+    >;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/or_else.rs b/warp/src/filter/or_else.rs
new file mode 100644
index 0000000..1bb45d0
--- /dev/null
+++ b/warp/src/filter/or_else.rs
@@ -0,0 +1,69 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use futures_util::{TryFuture};
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Func, Internal};
+use crate::reject::IsReject;
+
+#[derive(Clone, Copy, Debug)]
+pub struct OrElse<T, F> {
+    pub(super) filter: T,
+    pub(super) callback: F,
+}
+impl<T, F> FilterBase for OrElse<T, F>
+where
+    T: Filter,
+    F: Func<T::Error> + Clone + Send,
+    F::Output: TryFuture<Ok = T::Extract> + Send,
+    <F::Output as TryFuture>::Error: IsReject,
+{
+    type Extract = <F::Output as TryFuture>::Ok;
+    type Error = <F::Output as TryFuture>::Error;
+    type Future = OrElseFuture<T, F>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct OrElseFuture<T: Filter, F>
+where
+    T: Filter,
+    F: Func<T::Error>,
+    F::Output: TryFuture<Ok = T::Extract> + Send,
+{
+    #[pin]
+    state: State<T, F>,
+    original_path_index: PathIndex,
+}
+#[pin_project(project = StateProj)]
+enum State<T, F>
+where
+    T: Filter,
+    F: Func<T::Error>,
+    F::Output: TryFuture<Ok = T::Extract> + Send,
+{
+    First(#[pin] T::Future, F),
+    Second(#[pin] F::Output),
+    Done,
+}
+#[derive(Copy, Clone)]
+struct PathIndex(usize);
+impl PathIndex {
+    fn reset_path(&self) {
+        loop {}
+    }
+}
+impl<T, F> Future for OrElseFuture<T, F>
+where
+    T: Filter,
+    F: Func<T::Error>,
+    F::Output: TryFuture<Ok = T::Extract> + Send,
+{
+    type Output = Result<<F::Output as TryFuture>::Ok, <F::Output as TryFuture>::Error>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/recover.rs b/warp/src/filter/recover.rs
new file mode 100644
index 0000000..b4088e2
--- /dev/null
+++ b/warp/src/filter/recover.rs
@@ -0,0 +1,76 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use futures_util::{TryFuture};
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Func, Internal};
+use crate::generic::Either;
+use crate::reject::IsReject;
+
+#[derive(Clone, Copy, Debug)]
+pub struct Recover<T, F> {
+    pub(super) filter: T,
+    pub(super) callback: F,
+}
+impl<T, F> FilterBase for Recover<T, F>
+where
+    T: Filter,
+    F: Func<T::Error> + Clone + Send,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: IsReject,
+{
+    type Extract = (Either<T::Extract, (<F::Output as TryFuture>::Ok,)>,);
+    type Error = <F::Output as TryFuture>::Error;
+    type Future = RecoverFuture<T, F>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct RecoverFuture<T: Filter, F>
+where
+    T: Filter,
+    F: Func<T::Error>,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: IsReject,
+{
+    #[pin]
+    state: State<T, F>,
+    original_path_index: PathIndex,
+}
+#[pin_project(project = StateProj)]
+enum State<T, F>
+where
+    T: Filter,
+    F: Func<T::Error>,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: IsReject,
+{
+    First(#[pin] T::Future, F),
+    Second(#[pin] F::Output),
+    Done,
+}
+#[derive(Copy, Clone)]
+struct PathIndex(usize);
+impl PathIndex {
+    fn reset_path(&self) {
+        loop {}
+    }
+}
+impl<T, F> Future for RecoverFuture<T, F>
+where
+    T: Filter,
+    F: Func<T::Error>,
+    F::Output: TryFuture + Send,
+    <F::Output as TryFuture>::Error: IsReject,
+{
+    type Output = Result<
+        (Either<T::Extract, (<F::Output as TryFuture>::Ok,)>,),
+        <F::Output as TryFuture>::Error,
+    >;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/service.rs b/warp/src/filter/service.rs
new file mode 100644
index 0000000..76a7972
--- /dev/null
+++ b/warp/src/filter/service.rs
@@ -0,0 +1,111 @@
+use std::convert::Infallible;
+use std::future::Future;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use futures_util::future::TryFuture;
+use hyper::service::Service;
+use pin_project::pin_project;
+use crate::reject::IsReject;
+use crate::reply::{Reply, Response};
+use crate::route::{Route};
+use crate::{Filter, Request};
+/// Convert a `Filter` into a `Service`.
+///
+/// Filters are normally what APIs are built on in warp. However, it can be
+/// useful to convert a `Filter` into a [`Service`][Service], such as if
+/// further customizing a `hyper::Service`, or if wanting to make use of
+/// the greater [Tower][tower] set of middleware.
+///
+/// # Example
+///
+/// Running a `warp::Filter` on a regular `hyper::Server`:
+///
+/// ```
+/// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+/// use std::convert::Infallible;
+/// use warp::Filter;
+///
+/// // Our Filter...
+/// let route = warp::any().map(|| "Hello From Warp!");
+///
+/// // Convert it into a `Service`...
+/// let svc = warp::service(route);
+///
+/// // Typical hyper setup...
+/// let make_svc = hyper::service::make_service_fn(move |_| async move {
+///     Ok::<_, Infallible>(svc)
+/// });
+///
+/// hyper::Server::bind(&([127, 0, 0, 1], 3030).into())
+///     .serve(make_svc)
+///     .await?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// [Service]: https://docs.rs/hyper/0.13.*/hyper/service/trait.Service.html
+/// [tower]: https://docs.rs/tower
+pub fn service<F>(filter: F) -> FilteredService<F>
+where
+    F: Filter,
+    <F::Future as TryFuture>::Ok: Reply,
+    <F::Future as TryFuture>::Error: IsReject,
+{
+    loop {}
+}
+#[derive(Copy, Clone, Debug)]
+pub struct FilteredService<F> {
+    filter: F,
+}
+impl<F> FilteredService<F>
+where
+    F: Filter,
+    <F::Future as TryFuture>::Ok: Reply,
+    <F::Future as TryFuture>::Error: IsReject,
+{
+    #[inline]
+    pub(crate) fn call_with_addr(
+        &self,
+        req: Request,
+        remote_addr: Option<SocketAddr>,
+    ) -> FilteredFuture<F::Future> {
+        loop {}
+    }
+}
+impl<F> Service<Request> for FilteredService<F>
+where
+    F: Filter,
+    <F::Future as TryFuture>::Ok: Reply,
+    <F::Future as TryFuture>::Error: IsReject,
+{
+    type Response = Response;
+    type Error = Infallible;
+    type Future = FilteredFuture<F::Future>;
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+    #[inline]
+    fn call(&mut self, req: Request) -> Self::Future {
+        loop {}
+    }
+}
+#[pin_project]
+#[derive(Debug)]
+pub struct FilteredFuture<F> {
+    #[pin]
+    future: F,
+    route: ::std::cell::RefCell<Route>,
+}
+impl<F> Future for FilteredFuture<F>
+where
+    F: TryFuture,
+    F::Ok: Reply,
+    F::Error: IsReject,
+{
+    type Output = Result<Response, Infallible>;
+    #[inline]
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/then.rs b/warp/src/filter/then.rs
new file mode 100644
index 0000000..9305bd3
--- /dev/null
+++ b/warp/src/filter/then.rs
@@ -0,0 +1,69 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use futures_util::{TryFuture};
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Func, Internal};
+#[derive(Clone, Copy, Debug)]
+pub struct Then<T, F> {
+    pub(super) filter: T,
+    pub(super) callback: F,
+}
+impl<T, F> FilterBase for Then<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract> + Clone + Send,
+    F::Output: Future + Send,
+{
+    type Extract = (<F::Output as Future>::Output,);
+    type Error = T::Error;
+    type Future = ThenFuture<T, F>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct ThenFuture<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract>,
+    F::Output: Future + Send,
+{
+    #[pin]
+    state: State<T::Future, F>,
+}
+#[pin_project(project = StateProj)]
+enum State<T, F>
+where
+    T: TryFuture,
+    F: Func<T::Ok>,
+    F::Output: Future + Send,
+{
+    First(#[pin] T, F),
+    Second(#[pin] F::Output),
+    Done,
+}
+impl<T, F> Future for ThenFuture<T, F>
+where
+    T: Filter,
+    F: Func<T::Extract>,
+    F::Output: Future + Send,
+{
+    type Output = Result<(<F::Output as Future>::Output,), T::Error>;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
+impl<T, F> Future for State<T, F>
+where
+    T: TryFuture,
+    F: Func<T::Ok>,
+    F::Output: Future + Send,
+{
+    type Output = Result<(<F::Output as Future>::Output,), T::Error>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/unify.rs b/warp/src/filter/unify.rs
new file mode 100644
index 0000000..47d0384
--- /dev/null
+++ b/warp/src/filter/unify.rs
@@ -0,0 +1,39 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use futures_util::{TryFuture};
+use pin_project::pin_project;
+use super::{Either, Filter, FilterBase, Internal, Tuple};
+#[derive(Clone, Copy, Debug)]
+pub struct Unify<F> {
+    pub(super) filter: F,
+}
+impl<F, T> FilterBase for Unify<F>
+where
+    F: Filter<Extract = (Either<T, T>,)>,
+    T: Tuple,
+{
+    type Extract = T;
+    type Error = F::Error;
+    type Future = UnifyFuture<F::Future>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct UnifyFuture<F> {
+    #[pin]
+    inner: F,
+}
+impl<F, T> Future for UnifyFuture<F>
+where
+    F: TryFuture<Ok = (Either<T, T>,)>,
+{
+    type Output = Result<T, F::Error>;
+    #[inline]
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/untuple_one.rs b/warp/src/filter/untuple_one.rs
new file mode 100644
index 0000000..45052b9
--- /dev/null
+++ b/warp/src/filter/untuple_one.rs
@@ -0,0 +1,40 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use pin_project::pin_project;
+use super::{Filter, FilterBase, Internal, Tuple};
+#[derive(Clone, Copy, Debug)]
+pub struct UntupleOne<F> {
+    pub(super) filter: F,
+}
+impl<F, T> FilterBase for UntupleOne<F>
+where
+    F: Filter<Extract = (T,)>,
+    T: Tuple,
+{
+    type Extract = T;
+    type Error = F::Error;
+    type Future = UntupleOneFuture<F>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+pub struct UntupleOneFuture<F: Filter> {
+    #[pin]
+    extract: F::Future,
+}
+impl<F, T> Future for UntupleOneFuture<F>
+where
+    F: Filter<Extract = (T,)>,
+    T: Tuple,
+{
+    type Output = Result<T, F::Error>;
+    #[inline]
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filter/wrap.rs b/warp/src/filter/wrap.rs
new file mode 100644
index 0000000..416a43e
--- /dev/null
+++ b/warp/src/filter/wrap.rs
@@ -0,0 +1,57 @@
+use super::Filter;
+pub trait WrapSealed<F: Filter> {
+    type Wrapped: Filter;
+    fn wrap(&self, filter: F) -> Self::Wrapped;
+}
+impl<'a, T, F> WrapSealed<F> for &'a T
+where
+    T: WrapSealed<F>,
+    F: Filter,
+{
+    type Wrapped = T::Wrapped;
+    fn wrap(&self, filter: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+pub trait Wrap<F: Filter>: WrapSealed<F> {}
+impl<T, F> Wrap<F> for T
+where
+    T: WrapSealed<F>,
+    F: Filter,
+{}
+/// Combines received filter with pre and after filters
+///
+/// # Example
+///
+/// ```
+/// use crate::warp::Filter;
+///
+/// let route = warp::any()
+///     .map(|| "hello world")
+///     .with(warp::wrap_fn(|filter| filter));
+/// ```
+///
+/// You can find the full example in the [usage example](https://github.com/seanmonstar/warp/blob/master/examples/wrapping.rs).
+pub fn wrap_fn<F, T, U>(func: F) -> WrapFn<F>
+where
+    F: Fn(T) -> U,
+    T: Filter,
+    U: Filter,
+{
+    loop {}
+}
+#[derive(Debug)]
+pub struct WrapFn<F> {
+    func: F,
+}
+impl<F, T, U> WrapSealed<T> for WrapFn<F>
+where
+    F: Fn(T) -> U,
+    T: Filter,
+    U: Filter,
+{
+    type Wrapped = U;
+    fn wrap(&self, filter: T) -> Self::Wrapped {
+        loop {}
+    }
+}
diff --git a/warp/src/filters/addr.rs b/warp/src/filters/addr.rs
new file mode 100644
index 0000000..3d63070
--- /dev/null
+++ b/warp/src/filters/addr.rs
@@ -0,0 +1,26 @@
+//! Socket Address filters.
+
+use std::convert::Infallible;
+use std::net::SocketAddr;
+
+use crate::filter::{filter_fn_one, Filter};
+
+/// Creates a `Filter` to get the remote address of the connection.
+///
+/// If the underlying transport doesn't use socket addresses, this will yield
+/// `None`.
+///
+/// # Example
+///
+/// ```
+/// use std::net::SocketAddr;
+/// use warp::Filter;
+///
+/// let route = warp::addr::remote()
+///     .map(|addr: Option<SocketAddr>| {
+///         println!("remote address = {:?}", addr);
+///     });
+/// ```
+pub fn remote() -> impl Filter<Extract = (Option<SocketAddr>,), Error = Infallible> + Copy {
+    filter_fn_one(|route| futures_util::future::ok(route.remote_addr()))
+}
diff --git a/warp/src/filters/any.rs b/warp/src/filters/any.rs
new file mode 100644
index 0000000..136707e
--- /dev/null
+++ b/warp/src/filters/any.rs
@@ -0,0 +1,68 @@
+//! A filter that matches any route.
+use std::convert::Infallible;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use crate::filter::{Filter, FilterBase, Internal};
+/// A filter that matches any route.
+///
+/// This can be a useful building block to build new filters from,
+/// since [`Filter`](crate::Filter) is otherwise a sealed trait.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::any()
+///     .map(|| {
+///         "I always return this string!"
+///     });
+/// ```
+///
+/// This could allow creating a single `impl Filter` returning a specific
+/// reply, that can then be used as the end of several different filter
+/// chains.
+///
+/// Another use case is turning some clone-able resource into a `Filter`,
+/// thus allowing to easily `and` it together with others.
+///
+/// ```
+/// use std::sync::Arc;
+/// use warp::Filter;
+///
+/// let state = Arc::new(vec![33, 41]);
+/// let with_state = warp::any().map(move || state.clone());
+///
+/// // Now we could `and` with any other filter:
+///
+/// let route = warp::path::param()
+///     .and(with_state)
+///     .map(|param_id: u32, db: Arc<Vec<u32>>| {
+///         db.contains(&param_id)
+///     });
+/// ```
+pub fn any() -> impl Filter<Extract = (), Error = Infallible> + Copy {
+    Any
+}
+#[derive(Copy, Clone)]
+#[allow(missing_debug_implementations)]
+struct Any;
+impl FilterBase for Any {
+    type Extract = ();
+    type Error = Infallible;
+    type Future = AnyFut;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+struct AnyFut;
+impl Future for AnyFut {
+    type Output = Result<(), Infallible>;
+    #[inline]
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {}
+    }
+}
diff --git a/warp/src/filters/body.rs b/warp/src/filters/body.rs
new file mode 100644
index 0000000..a84b12b
--- /dev/null
+++ b/warp/src/filters/body.rs
@@ -0,0 +1,320 @@
+//! Body filters
+//!
+//! Filters that extract a body for a route.
+use std::error::Error as StdError;
+use std::fmt;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use bytes::{Buf, Bytes};
+use futures_util::{future, Stream, TryFutureExt};
+use headers::ContentLength;
+use http::header::CONTENT_TYPE;
+use hyper::Body;
+use mime;
+use serde::de::DeserializeOwned;
+
+
+use crate::filter::{filter_fn, filter_fn_one, Filter, FilterBase};
+use crate::reject::{self, Rejection};
+type BoxError = Box<dyn StdError + Send + Sync>;
+pub(crate) fn body() -> impl Filter<Extract = (Body,), Error = Rejection> + Copy {
+    filter_fn_one(|route| {
+        future::ready(
+            route
+                .take_body()
+                .ok_or_else(|| {
+                    tracing::error!("request body already taken in previous filter");
+                    reject::known(BodyConsumedMultipleTimes {
+                        _p: (),
+                    })
+                }),
+        )
+    })
+}
+/// Require a `content-length` header to have a value no greater than some limit.
+///
+/// Rejects if `content-length` header is missing, is invalid, or has a number
+/// larger than the limit provided.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // Limit the upload to 4kb...
+/// let upload = warp::body::content_length_limit(4096)
+///     .and(warp::body::aggregate());
+/// ```
+pub fn content_length_limit(
+    limit: u64,
+) -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    crate::filters::header::header2()
+        .map_err(
+            crate::filter::Internal,
+            |_| {
+                tracing::debug!("content-length missing");
+                reject::length_required()
+            },
+        )
+        .and_then(move |ContentLength(length)| {
+            if length <= limit {
+                future::ok(())
+            } else {
+                tracing::debug!("content-length: {} is over limit {}", length, limit);
+                future::err(reject::payload_too_large())
+            }
+        })
+        .untuple_one()
+}
+/// Create a `Filter` that extracts the request body as a `futures::Stream`.
+///
+/// If other filters have already extracted the body, this filter will reject
+/// with a `500 Internal Server Error`.
+///
+/// # Warning
+///
+/// This does not have a default size limit, it would be wise to use one to
+/// prevent a overly large request from using too much memory.
+pub fn stream() -> impl Filter<
+    Extract = (impl Stream<Item = Result<impl Buf, crate::Error>>,),
+    Error = Rejection,
+> + Copy {
+    body().map(|body: Body| BodyStream { body })
+}
+/// Returns a `Filter` that matches any request and extracts a `Future` of a
+/// concatenated body.
+///
+/// The contents of the body will be flattened into a single contiguous
+/// `Bytes`, which may require memory copies. If you don't require a
+/// contiguous buffer, using `aggregate` can be give better performance.
+///
+/// # Warning
+///
+/// This does not have a default size limit, it would be wise to use one to
+/// prevent a overly large request from using too much memory.
+///
+/// # Example
+///
+/// ```
+/// use warp::{Buf, Filter};
+///
+/// let route = warp::body::content_length_limit(1024 * 32)
+///     .and(warp::body::bytes())
+///     .map(|bytes: bytes::Bytes| {
+///         println!("bytes = {:?}", bytes);
+///     });
+/// ```
+pub fn bytes() -> impl Filter<Extract = (Bytes,), Error = Rejection> + Copy {
+    body()
+        .and_then(|body: hyper::Body| {
+            hyper::body::to_bytes(body)
+                .map_err(|err| {
+                    tracing::debug!("to_bytes error: {}", err);
+                    reject::known(BodyReadError(err))
+                })
+        })
+}
+/// Returns a `Filter` that matches any request and extracts a `Future` of an
+/// aggregated body.
+///
+/// The `Buf` may contain multiple, non-contiguous buffers. This can be more
+/// performant (by reducing copies) when receiving large bodies.
+///
+/// # Warning
+///
+/// This does not have a default size limit, it would be wise to use one to
+/// prevent a overly large request from using too much memory.
+///
+/// # Example
+///
+/// ```
+/// use warp::{Buf, Filter};
+///
+/// fn full_body(mut body: impl Buf) {
+///     // It could have several non-contiguous slices of memory...
+///     while body.has_remaining() {
+///         println!("slice = {:?}", body.chunk());
+///         let cnt = body.chunk().len();
+///         body.advance(cnt);
+///     }
+/// }
+///
+/// let route = warp::body::content_length_limit(1024 * 32)
+///     .and(warp::body::aggregate())
+///     .map(full_body);
+/// ```
+pub fn aggregate() -> impl Filter<Extract = (impl Buf,), Error = Rejection> + Copy {
+    body()
+        .and_then(|body: ::hyper::Body| {
+            hyper::body::aggregate(body)
+                .map_err(|err| {
+                    tracing::debug!("aggregate error: {}", err);
+                    reject::known(BodyReadError(err))
+                })
+        })
+}
+/// Returns a `Filter` that matches any request and extracts a `Future` of a
+/// JSON-decoded body.
+///
+/// # Warning
+///
+/// This does not have a default size limit, it would be wise to use one to
+/// prevent a overly large request from using too much memory.
+///
+/// # Example
+///
+/// ```
+/// use std::collections::HashMap;
+/// use warp::Filter;
+///
+/// let route = warp::body::content_length_limit(1024 * 32)
+///     .and(warp::body::json())
+///     .map(|simple_map: HashMap<String, String>| {
+///         "Got a JSON body!"
+///     });
+/// ```
+pub fn json<T: DeserializeOwned + Send>() -> impl Filter<
+    Extract = (T,),
+    Error = Rejection,
+> + Copy {
+    is_content_type::<Json>()
+        .and(bytes())
+        .and_then(|buf| async move {
+            Json::decode(buf)
+                .map_err(|err| {
+                    tracing::debug!("request json body error: {}", err);
+                    reject::known(BodyDeserializeError { cause: err })
+                })
+        })
+}
+/// Returns a `Filter` that matches any request and extracts a
+/// `Future` of a form encoded body.
+///
+/// # Note
+///
+/// This filter is for the simpler `application/x-www-form-urlencoded` format,
+/// not `multipart/form-data`.
+///
+/// # Warning
+///
+/// This does not have a default size limit, it would be wise to use one to
+/// prevent a overly large request from using too much memory.
+///
+///
+/// ```
+/// use std::collections::HashMap;
+/// use warp::Filter;
+///
+/// let route = warp::body::content_length_limit(1024 * 32)
+///     .and(warp::body::form())
+///     .map(|simple_map: HashMap<String, String>| {
+///         "Got a urlencoded body!"
+///     });
+/// ```
+pub fn form<T: DeserializeOwned + Send>() -> impl Filter<
+    Extract = (T,),
+    Error = Rejection,
+> + Copy {
+    is_content_type::<Form>()
+        .and(aggregate())
+        .and_then(|buf| async move {
+            Form::decode(buf)
+                .map_err(|err| {
+                    tracing::debug!("request form body error: {}", err);
+                    reject::known(BodyDeserializeError { cause: err })
+                })
+        })
+}
+trait Decode {
+    const MIME: (mime::Name<'static>, mime::Name<'static>);
+    const WITH_NO_CONTENT_TYPE: bool;
+    fn decode<B: Buf, T: DeserializeOwned>(buf: B) -> Result<T, BoxError>;
+}
+struct Json;
+impl Decode for Json {
+    const MIME: (mime::Name<'static>, mime::Name<'static>) = (
+        mime::APPLICATION,
+        mime::JSON,
+    );
+    const WITH_NO_CONTENT_TYPE: bool = true;
+    fn decode<B: Buf, T: DeserializeOwned>(mut buf: B) -> Result<T, BoxError> {
+        loop {}
+    }
+}
+struct Form;
+impl Decode for Form {
+    const MIME: (mime::Name<'static>, mime::Name<'static>) = (
+        mime::APPLICATION,
+        mime::WWW_FORM_URLENCODED,
+    );
+    const WITH_NO_CONTENT_TYPE: bool = true;
+    fn decode<B: Buf, T: DeserializeOwned>(buf: B) -> Result<T, BoxError> {
+        loop {}
+    }
+}
+fn is_content_type<D: Decode>() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    filter_fn(move |route| {
+        let (type_, subtype) = D::MIME;
+        if let Some(value) = route.headers().get(CONTENT_TYPE) {
+            tracing::trace!("is_content_type {}/{}? {:?}", type_, subtype, value);
+            let ct = value.to_str().ok().and_then(|s| s.parse::<mime::Mime>().ok());
+            if let Some(ct) = ct {
+                if ct.type_() == type_ && ct.subtype() == subtype {
+                    future::ok(())
+                } else {
+                    tracing::debug!(
+                        "content-type {:?} doesn't match {}/{}", value, type_, subtype
+                    );
+                    future::err(reject::unsupported_media_type())
+                }
+            } else {
+                tracing::debug!("content-type {:?} couldn't be parsed", value);
+                future::err(reject::unsupported_media_type())
+            }
+        } else if D::WITH_NO_CONTENT_TYPE {
+            tracing::trace!("no content-type header, assuming {}/{}", type_, subtype);
+            future::ok(())
+        } else {
+            tracing::debug!("no content-type found");
+            future::err(reject::unsupported_media_type())
+        }
+    })
+}
+struct BodyStream {
+    body: Body,
+}
+impl Stream for BodyStream {
+    type Item = Result<Bytes, crate::Error>;
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {}
+    }
+}
+/// An error used in rejections when deserializing a request body fails.
+#[derive(Debug)]
+pub struct BodyDeserializeError {
+    cause: BoxError,
+}
+impl fmt::Display for BodyDeserializeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for BodyDeserializeError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        loop {}
+    }
+}
+#[derive(Debug)]
+pub(crate) struct BodyReadError(::hyper::Error);
+impl fmt::Display for BodyReadError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for BodyReadError {}
+unit_error! {
+    pub (crate) BodyConsumedMultipleTimes : "Request body consumed multiple times"
+}
diff --git a/warp/src/filters/compression.rs b/warp/src/filters/compression.rs
new file mode 100644
index 0000000..4bc9ef0
--- /dev/null
+++ b/warp/src/filters/compression.rs
@@ -0,0 +1,200 @@
+//! Compression Filters
+//!
+//! Filters that compress the body of a response.
+#[cfg(feature = "compression-brotli")]
+use async_compression::tokio::bufread::BrotliEncoder;
+#[cfg(feature = "compression-gzip")]
+use async_compression::tokio::bufread::{DeflateEncoder, GzipEncoder};
+use http::header::HeaderValue;
+use hyper::{
+    header::{CONTENT_ENCODING, CONTENT_LENGTH},
+    Body,
+};
+use tokio_util::io::{ReaderStream, StreamReader};
+use crate::filter::{Filter, WrapSealed};
+use crate::reject::IsReject;
+use crate::reply::{Reply, Response};
+use self::internal::{CompressionProps, WithCompression};
+enum CompressionAlgo {
+    #[cfg(feature = "compression-brotli")]
+    BR,
+    #[cfg(feature = "compression-gzip")]
+    DEFLATE,
+    #[cfg(feature = "compression-gzip")]
+    GZIP,
+}
+impl From<CompressionAlgo> for HeaderValue {
+    #[inline]
+    fn from(algo: CompressionAlgo) -> Self {
+        loop {}
+    }
+}
+/// Compression
+#[derive(Clone, Copy, Debug)]
+pub struct Compression<F> {
+    func: F,
+}
+/// Create a wrapping filter that compresses the Body of a [`Response`](crate::reply::Response)
+/// using gzip, adding `content-encoding: gzip` to the Response's [`HeaderMap`](hyper::HeaderMap)
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::get()
+///     .and(warp::path::end())
+///     .and(warp::fs::file("./README.md"))
+///     .with(warp::compression::gzip());
+/// ```
+#[cfg(feature = "compression-gzip")]
+pub fn gzip() -> Compression<impl Fn(CompressionProps) -> Response + Copy> {
+    loop {}
+}
+/// Create a wrapping filter that compresses the Body of a [`Response`](crate::reply::Response)
+/// using deflate, adding `content-encoding: deflate` to the Response's [`HeaderMap`](hyper::HeaderMap)
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::get()
+///     .and(warp::path::end())
+///     .and(warp::fs::file("./README.md"))
+///     .with(warp::compression::deflate());
+/// ```
+#[cfg(feature = "compression-gzip")]
+pub fn deflate() -> Compression<impl Fn(CompressionProps) -> Response + Copy> {
+    loop {}
+}
+/// Create a wrapping filter that compresses the Body of a [`Response`](crate::reply::Response)
+/// using brotli, adding `content-encoding: br` to the Response's [`HeaderMap`](hyper::HeaderMap)
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::get()
+///     .and(warp::path::end())
+///     .and(warp::fs::file("./README.md"))
+///     .with(warp::compression::brotli());
+/// ```
+#[cfg(feature = "compression-brotli")]
+pub fn brotli() -> Compression<impl Fn(CompressionProps) -> Response + Copy> {
+    loop {}
+}
+impl<FN, F> WrapSealed<F> for Compression<FN>
+where
+    FN: Fn(CompressionProps) -> Response + Clone + Send,
+    F: Filter + Clone + Send,
+    F::Extract: Reply,
+    F::Error: IsReject,
+{
+    type Wrapped = WithCompression<FN, F>;
+    fn wrap(&self, filter: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+mod internal {
+    use std::future::Future;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+    use bytes::Bytes;
+    use futures_util::{ready, Stream, TryFuture};
+    use hyper::Body;
+    use pin_project::pin_project;
+    use crate::filter::{Filter, FilterBase, Internal};
+    use crate::reject::IsReject;
+    use crate::reply::{Reply, Response};
+    use super::Compression;
+    /// A wrapper around any type that implements [`Stream`](futures::Stream) to be
+    /// compatible with async_compression's Stream based encoders
+    #[pin_project]
+    #[derive(Debug)]
+    pub struct CompressableBody<S, E>
+    where
+        E: std::error::Error,
+        S: Stream<Item = Result<Bytes, E>>,
+    {
+        #[pin]
+        body: S,
+    }
+    impl<S, E> Stream for CompressableBody<S, E>
+    where
+        E: std::error::Error,
+        S: Stream<Item = Result<Bytes, E>>,
+    {
+        type Item = std::io::Result<Bytes>;
+        fn poll_next(
+            self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+        ) -> Poll<Option<Self::Item>> {
+            loop {}
+        }
+    }
+    impl From<Body> for CompressableBody<Body, hyper::Error> {
+        fn from(body: Body) -> Self {
+            loop {}
+        }
+    }
+    /// Compression Props
+    #[derive(Debug)]
+    pub struct CompressionProps {
+        pub(super) body: CompressableBody<Body, hyper::Error>,
+        pub(super) head: http::response::Parts,
+    }
+    impl From<http::Response<Body>> for CompressionProps {
+        fn from(resp: http::Response<Body>) -> Self {
+            loop {}
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    pub struct Compressed(pub(super) Response);
+    impl Reply for Compressed {
+        #[inline]
+        fn into_response(self) -> Response {
+            loop {}
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    #[derive(Clone, Copy)]
+    pub struct WithCompression<FN, F> {
+        pub(super) compress: Compression<FN>,
+        pub(super) filter: F,
+    }
+    impl<FN, F> FilterBase for WithCompression<FN, F>
+    where
+        FN: Fn(CompressionProps) -> Response + Clone + Send,
+        F: Filter + Clone + Send,
+        F::Extract: Reply,
+        F::Error: IsReject,
+    {
+        type Extract = (Compressed,);
+        type Error = F::Error;
+        type Future = WithCompressionFuture<FN, F::Future>;
+        fn filter(&self, _: Internal) -> Self::Future {
+            loop {}
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    #[pin_project]
+    pub struct WithCompressionFuture<FN, F> {
+        compress: Compression<FN>,
+        #[pin]
+        future: F,
+    }
+    impl<FN, F> Future for WithCompressionFuture<FN, F>
+    where
+        FN: Fn(CompressionProps) -> Response,
+        F: TryFuture,
+        F::Ok: Reply,
+        F::Error: IsReject,
+    {
+        type Output = Result<(Compressed,), F::Error>;
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            loop {}
+        }
+    }
+}
diff --git a/warp/src/filters/cookie.rs b/warp/src/filters/cookie.rs
new file mode 100644
index 0000000..53695e8
--- /dev/null
+++ b/warp/src/filters/cookie.rs
@@ -0,0 +1,46 @@
+//! Cookie Filters
+
+use futures_util::future;
+use headers::Cookie;
+
+use super::header;
+use crate::filter::{Filter, One};
+use crate::reject::Rejection;
+use std::convert::Infallible;
+use std::str::FromStr;
+
+/// Creates a `Filter` that requires a cookie by name.
+///
+/// If found, extracts the value of the cookie, otherwise rejects.
+pub fn cookie<T>(name: &'static str) -> impl Filter<Extract = One<T>, Error = Rejection> + Copy
+where
+    T: FromStr + Send + 'static,
+{
+    header::header2().and_then(move |cookie: Cookie| {
+        let cookie = cookie
+            .get(name)
+            .ok_or_else(|| crate::reject::missing_cookie(name))
+            .and_then(|s| T::from_str(s).map_err(|_| crate::reject::missing_cookie(name)));
+        future::ready(cookie)
+    })
+}
+
+/// Creates a `Filter` that looks for an optional cookie by name.
+///
+/// If found, extracts the value of the cookie, otherwise continues
+/// the request, extracting `None`.
+pub fn optional<T>(
+    name: &'static str,
+) -> impl Filter<Extract = One<Option<T>>, Error = Infallible> + Copy
+where
+    T: FromStr + Send + 'static,
+{
+    header::optional2().map(move |opt: Option<Cookie>| {
+        let cookie = opt.and_then(|cookie| cookie.get(name).map(|x| T::from_str(x)));
+        match cookie {
+            Some(Ok(t)) => Some(t),
+            Some(Err(_)) => None,
+            None => None,
+        }
+    })
+}
diff --git a/warp/src/filters/cors.rs b/warp/src/filters/cors.rs
new file mode 100644
index 0000000..dd3cbda
--- /dev/null
+++ b/warp/src/filters/cors.rs
@@ -0,0 +1,350 @@
+//! CORS Filters
+use std::collections::HashSet;
+use std::convert::TryFrom;
+use std::error::Error as StdError;
+use std::fmt;
+use std::sync::Arc;
+use headers::{
+    AccessControlAllowHeaders, AccessControlAllowMethods, AccessControlExposeHeaders,
+};
+use http::{self, header::{HeaderName, HeaderValue}};
+use crate::filter::{Filter, WrapSealed};
+use crate::reject::{CombineRejection, Rejection};
+use crate::reply::Reply;
+use self::internal::{CorsFilter, IntoOrigin, Seconds};
+/// Create a wrapping filter that exposes [CORS][] behavior for a wrapped
+/// filter.
+///
+/// [CORS]: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let cors = warp::cors()
+///     .allow_origin("https://hyper.rs")
+///     .allow_methods(vec!["GET", "POST", "DELETE"]);
+///
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(cors);
+/// ```
+/// If you want to allow any route:
+/// ```
+/// use warp::Filter;
+/// let cors = warp::cors()
+///     .allow_any_origin();
+/// ```
+/// You can find more usage examples [here](https://github.com/seanmonstar/warp/blob/7fa54eaecd0fe12687137372791ff22fc7995766/tests/cors.rs).
+pub fn cors() -> Builder {
+    loop {}
+}
+/// A wrapping filter constructed via `warp::cors()`.
+#[derive(Clone, Debug)]
+pub struct Cors {
+    config: Arc<Configured>,
+}
+/// A constructed via `warp::cors()`.
+#[derive(Clone, Debug)]
+pub struct Builder {
+    credentials: bool,
+    allowed_headers: HashSet<HeaderName>,
+    exposed_headers: HashSet<HeaderName>,
+    max_age: Option<u64>,
+    methods: HashSet<http::Method>,
+    origins: Option<HashSet<HeaderValue>>,
+}
+impl Builder {
+    /// Sets whether to add the `Access-Control-Allow-Credentials` header.
+    pub fn allow_credentials(mut self, allow: bool) -> Self {
+        loop {}
+    }
+    /// Adds a method to the existing list of allowed request methods.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided argument is not a valid `http::Method`.
+    pub fn allow_method<M>(mut self, method: M) -> Self
+    where
+        http::Method: TryFrom<M>,
+    {
+        loop {}
+    }
+    /// Adds multiple methods to the existing list of allowed request methods.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided argument is not a valid `http::Method`.
+    pub fn allow_methods<I>(mut self, methods: I) -> Self
+    where
+        I: IntoIterator,
+        http::Method: TryFrom<I::Item>,
+    {
+        loop {}
+    }
+    /// Adds a header to the list of allowed request headers.
+    ///
+    /// **Note**: These should match the values the browser sends via `Access-Control-Request-Headers`, e.g. `content-type`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided argument is not a valid `http::header::HeaderName`.
+    pub fn allow_header<H>(mut self, header: H) -> Self
+    where
+        HeaderName: TryFrom<H>,
+    {
+        loop {}
+    }
+    /// Adds multiple headers to the list of allowed request headers.
+    ///
+    /// **Note**: These should match the values the browser sends via `Access-Control-Request-Headers`, e.g.`content-type`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any of the headers are not a valid `http::header::HeaderName`.
+    pub fn allow_headers<I>(mut self, headers: I) -> Self
+    where
+        I: IntoIterator,
+        HeaderName: TryFrom<I::Item>,
+    {
+        loop {}
+    }
+    /// Adds a header to the list of exposed headers.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided argument is not a valid `http::header::HeaderName`.
+    pub fn expose_header<H>(mut self, header: H) -> Self
+    where
+        HeaderName: TryFrom<H>,
+    {
+        loop {}
+    }
+    /// Adds multiple headers to the list of exposed headers.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any of the headers are not a valid `http::header::HeaderName`.
+    pub fn expose_headers<I>(mut self, headers: I) -> Self
+    where
+        I: IntoIterator,
+        HeaderName: TryFrom<I::Item>,
+    {
+        loop {}
+    }
+    /// Sets that *any* `Origin` header is allowed.
+    ///
+    /// # Warning
+    ///
+    /// This can allow websites you didn't intend to access this resource,
+    /// it is usually better to set an explicit list.
+    pub fn allow_any_origin(mut self) -> Self {
+        loop {}
+    }
+    /// Add an origin to the existing list of allowed `Origin`s.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided argument is not a valid `Origin`.
+    pub fn allow_origin(self, origin: impl IntoOrigin) -> Self {
+        loop {}
+    }
+    /// Add multiple origins to the existing list of allowed `Origin`s.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the provided argument is not a valid `Origin`.
+    pub fn allow_origins<I>(mut self, origins: I) -> Self
+    where
+        I: IntoIterator,
+        I::Item: IntoOrigin,
+    {
+        loop {}
+    }
+    /// Sets the `Access-Control-Max-Age` header.
+    ///
+    /// # Example
+    ///
+    ///
+    /// ```
+    /// use std::time::Duration;
+    /// use warp::Filter;
+    ///
+    /// let cors = warp::cors()
+    ///     .max_age(30) // 30u32 seconds
+    ///     .max_age(Duration::from_secs(30)); // or a Duration
+    /// ```
+    pub fn max_age(mut self, seconds: impl Seconds) -> Self {
+        loop {}
+    }
+    /// Builds the `Cors` wrapper from the configured settings.
+    ///
+    /// This step isn't *required*, as the `Builder` itself can be passed
+    /// to `Filter::with`. This just allows constructing once, thus not needing
+    /// to pay the cost of "building" every time.
+    pub fn build(self) -> Cors {
+        loop {}
+    }
+}
+impl<F> WrapSealed<F> for Builder
+where
+    F: Filter + Clone + Send + Sync + 'static,
+    F::Extract: Reply,
+    F::Error: CombineRejection<Rejection>,
+    <F::Error as CombineRejection<Rejection>>::One: CombineRejection<Rejection>,
+{
+    type Wrapped = CorsFilter<F>;
+    fn wrap(&self, inner: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+impl<F> WrapSealed<F> for Cors
+where
+    F: Filter + Clone + Send + Sync + 'static,
+    F::Extract: Reply,
+    F::Error: CombineRejection<Rejection>,
+    <F::Error as CombineRejection<Rejection>>::One: CombineRejection<Rejection>,
+{
+    type Wrapped = CorsFilter<F>;
+    fn wrap(&self, inner: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+/// An error used to reject requests that are forbidden by a `cors` filter.
+pub struct CorsForbidden {
+    kind: Forbidden,
+}
+#[derive(Debug)]
+enum Forbidden {
+    OriginNotAllowed,
+    MethodNotAllowed,
+    HeaderNotAllowed,
+}
+impl fmt::Debug for CorsForbidden {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl fmt::Display for CorsForbidden {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for CorsForbidden {}
+#[derive(Clone, Debug)]
+struct Configured {
+    cors: Builder,
+    allowed_headers_header: AccessControlAllowHeaders,
+    expose_headers_header: Option<AccessControlExposeHeaders>,
+    methods_header: AccessControlAllowMethods,
+}
+enum Validated {
+    Preflight(HeaderValue),
+    Simple(HeaderValue),
+    NotCors,
+}
+impl Configured {}
+mod internal {
+    use std::future::Future;
+    use std::pin::Pin;
+    use std::sync::Arc;
+    use std::task::{Context, Poll};
+    use futures_util::{future, TryFuture};
+    use headers::Origin;
+    use http::header;
+    use pin_project::pin_project;
+    use super::Configured;
+    use crate::filter::{Filter, FilterBase, Internal, One};
+    use crate::generic::Either;
+    use crate::reject::{CombineRejection, Rejection};
+    #[derive(Clone, Debug)]
+    pub struct CorsFilter<F> {
+        pub(super) config: Arc<Configured>,
+        pub(super) inner: F,
+    }
+    impl<F> FilterBase for CorsFilter<F>
+    where
+        F: Filter,
+        F::Extract: Send,
+        F::Future: Future,
+        F::Error: CombineRejection<Rejection>,
+    {
+        type Extract = One<
+            Either<One<Preflight>, One<Either<One<Wrapped<F::Extract>>, F::Extract>>>,
+        >;
+        type Error = <F::Error as CombineRejection<Rejection>>::One;
+        type Future = future::Either<
+            future::Ready<Result<Self::Extract, Self::Error>>,
+            WrappedFuture<F::Future>,
+        >;
+        fn filter(&self, _: Internal) -> Self::Future {
+            loop {}
+        }
+    }
+    #[derive(Debug)]
+    pub struct Preflight {
+        config: Arc<Configured>,
+        origin: header::HeaderValue,
+    }
+    impl crate::reply::Reply for Preflight {
+        fn into_response(self) -> crate::reply::Response {
+            loop {}
+        }
+    }
+    #[derive(Debug)]
+    pub struct Wrapped<R> {
+        config: Arc<Configured>,
+        inner: R,
+        origin: header::HeaderValue,
+    }
+    impl<R> crate::reply::Reply for Wrapped<R>
+    where
+        R: crate::reply::Reply,
+    {
+        fn into_response(self) -> crate::reply::Response {
+            loop {}
+        }
+    }
+    #[pin_project]
+    #[derive(Debug)]
+    pub struct WrappedFuture<F> {
+        #[pin]
+        inner: F,
+        wrapped: Option<(Arc<Configured>, header::HeaderValue)>,
+    }
+    impl<F> Future for WrappedFuture<F>
+    where
+        F: TryFuture,
+        F::Error: CombineRejection<Rejection>,
+    {
+        type Output = Result<
+            One<Either<One<Preflight>, One<Either<One<Wrapped<F::Ok>>, F::Ok>>>>,
+            <F::Error as CombineRejection<Rejection>>::One,
+        >;
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            loop {}
+        }
+    }
+    pub trait Seconds {
+        fn seconds(self) -> u64;
+    }
+    impl Seconds for u32 {
+        fn seconds(self) -> u64 {
+            loop {}
+        }
+    }
+    impl Seconds for ::std::time::Duration {
+        fn seconds(self) -> u64 {
+            loop {}
+        }
+    }
+    pub trait IntoOrigin {
+        fn into_origin(self) -> Origin;
+    }
+    impl<'a> IntoOrigin for &'a str {
+        fn into_origin(self) -> Origin {
+            loop {}
+        }
+    }
+}
diff --git a/warp/src/filters/ext.rs b/warp/src/filters/ext.rs
new file mode 100644
index 0000000..985bbfb
--- /dev/null
+++ b/warp/src/filters/ext.rs
@@ -0,0 +1,36 @@
+//! Request Extensions
+
+use std::convert::Infallible;
+
+use futures_util::future;
+
+use crate::filter::{filter_fn_one, Filter};
+use crate::reject::{self, Rejection};
+
+/// Get a previously set extension of the current route.
+///
+/// If the extension doesn't exist, this rejects with a `MissingExtension`.
+pub fn get<T: Clone + Send + Sync + 'static>(
+) -> impl Filter<Extract = (T,), Error = Rejection> + Copy {
+    filter_fn_one(|route| {
+        let route = route
+            .extensions()
+            .get::<T>()
+            .cloned()
+            .ok_or_else(|| reject::known(MissingExtension { _p: () }));
+        future::ready(route)
+    })
+}
+
+/// Get a previously set extension of the current route.
+///
+/// If the extension doesn't exist, it yields `None`.
+pub fn optional<T: Clone + Send + Sync + 'static>(
+) -> impl Filter<Extract = (Option<T>,), Error = Infallible> + Copy {
+    filter_fn_one(|route| future::ok(route.extensions().get::<T>().cloned()))
+}
+
+unit_error! {
+    /// An error used to reject if `get` cannot find the extension.
+    pub MissingExtension: "Missing request extension"
+}
diff --git a/warp/src/filters/fs.rs b/warp/src/filters/fs.rs
new file mode 100644
index 0000000..55575d2
--- /dev/null
+++ b/warp/src/filters/fs.rs
@@ -0,0 +1,358 @@
+//! File System Filters
+
+use std::convert::Infallible;
+use std::fs::Metadata;
+use std::future::Future;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::Poll;
+use bytes::{Bytes, BytesMut};
+use futures_util::future::Either;
+use futures_util::{future, ready, stream, FutureExt, Stream, StreamExt, TryFutureExt};
+use headers::{
+    AcceptRanges, ContentLength, ContentRange, ContentType, HeaderMapExt,
+    IfModifiedSince, IfRange, IfUnmodifiedSince, LastModified, Range,
+};
+use http::StatusCode;
+use hyper::Body;
+use mime_guess;
+
+use tokio::fs::File as TkFile;
+use tokio::io::AsyncSeekExt;
+use tokio_util::io::poll_read_buf;
+use crate::filter::{Filter, FilterClone, One};
+use crate::reject::{self, Rejection};
+use crate::reply::{Reply, Response};
+/// Creates a `Filter` that serves a File at the `path`.
+///
+/// Does not filter out based on any information of the request. Always serves
+/// the file at the exact `path` provided. Thus, this can be used to serve a
+/// single file with `GET`s, but could also be used in combination with other
+/// filters, such as after validating in `POST` request, wanting to return a
+/// specific file as the body.
+///
+/// For serving a directory, see [dir](dir).
+///
+/// # Example
+///
+/// ```
+/// // Always serves this file from the file system.
+/// let route = warp::fs::file("/www/static/app.js");
+/// ```
+pub fn file(
+    path: impl Into<PathBuf>,
+) -> impl FilterClone<Extract = One<File>, Error = Rejection> {
+    let path = Arc::new(path.into());
+    crate::any()
+        .map(move || {
+            tracing::trace!("file: {:?}", path);
+            ArcPath(path.clone())
+        })
+        .and(conditionals())
+        .and_then(file_reply)
+}
+/// Creates a `Filter` that serves a directory at the base `path` joined
+/// by the request path.
+///
+/// This can be used to serve "static files" from a directory. By far the most
+/// common pattern of serving static files is for `GET` requests, so this
+/// filter automatically includes a `GET` check.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // Matches requests that start with `/static`,
+/// // and then uses the rest of that path to lookup
+/// // and serve a file from `/www/static`.
+/// let route = warp::path("static")
+///     .and(warp::fs::dir("/www/static"));
+///
+/// // For example:
+/// // - `GET /static/app.js` would serve the file `/www/static/app.js`
+/// // - `GET /static/css/app.css` would serve the file `/www/static/css/app.css`
+/// ```
+pub fn dir(
+    path: impl Into<PathBuf>,
+) -> impl FilterClone<Extract = One<File>, Error = Rejection> {
+    let base = Arc::new(path.into());
+    crate::get()
+        .or(crate::head())
+        .unify()
+        .and(path_from_tail(base))
+        .and(conditionals())
+        .and_then(file_reply)
+}
+fn path_from_tail(
+    base: Arc<PathBuf>,
+) -> impl FilterClone<Extract = One<ArcPath>, Error = Rejection> {
+    crate::path::tail()
+        .and_then(move |tail: crate::path::Tail| {
+            future::ready(sanitize_path(base.as_ref(), tail.as_str()))
+                .and_then(|mut buf| async {
+                    let is_dir = tokio::fs::metadata(buf.clone())
+                        .await
+                        .map(|m| m.is_dir())
+                        .unwrap_or(false);
+                    if is_dir {
+                        tracing::debug!("dir: appending index.html to directory path");
+                        buf.push("index.html");
+                    }
+                    tracing::trace!("dir: {:?}", buf);
+                    Ok(ArcPath(Arc::new(buf)))
+                })
+        })
+}
+fn sanitize_path(base: impl AsRef<Path>, tail: &str) -> Result<PathBuf, Rejection> {
+    loop {}
+}
+#[derive(Debug)]
+struct Conditionals {
+    if_modified_since: Option<IfModifiedSince>,
+    if_unmodified_since: Option<IfUnmodifiedSince>,
+    if_range: Option<IfRange>,
+    range: Option<Range>,
+}
+enum Cond {
+    NoBody(Response),
+    WithBody(Option<Range>),
+}
+impl Conditionals {
+    fn check(self, last_modified: Option<LastModified>) -> Cond {
+        loop {}
+    }
+}
+fn conditionals() -> impl Filter<
+    Extract = One<Conditionals>,
+    Error = Infallible,
+> + Copy {
+    crate::header::optional2()
+        .and(crate::header::optional2())
+        .and(crate::header::optional2())
+        .and(crate::header::optional2())
+        .map(|if_modified_since, if_unmodified_since, if_range, range| Conditionals {
+            if_modified_since,
+            if_unmodified_since,
+            if_range,
+            range,
+        })
+}
+/// A file response.
+#[derive(Debug)]
+pub struct File {
+    resp: Response,
+    path: ArcPath,
+}
+impl File {
+    /// Extract the `&Path` of the file this `Response` delivers.
+    ///
+    /// # Example
+    ///
+    /// The example below changes the Content-Type response header for every file called `video.mp4`.
+    ///
+    /// ```
+    /// use warp::{Filter, reply::Reply};
+    ///
+    /// let route = warp::path("static")
+    ///     .and(warp::fs::dir("/www/static"))
+    ///     .map(|reply: warp::filters::fs::File| {
+    ///         if reply.path().ends_with("video.mp4") {
+    ///             warp::reply::with_header(reply, "Content-Type", "video/mp4").into_response()
+    ///         } else {
+    ///             reply.into_response()
+    ///         }
+    ///     });
+    /// ```
+    pub fn path(&self) -> &Path {
+        loop {}
+    }
+}
+#[derive(Clone, Debug)]
+struct ArcPath(Arc<PathBuf>);
+impl AsRef<Path> for ArcPath {
+    fn as_ref(&self) -> &Path {
+        loop {}
+    }
+}
+impl Reply for File {
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+fn file_reply(
+    path: ArcPath,
+    conditionals: Conditionals,
+) -> impl Future<Output = Result<File, Rejection>> + Send {
+    TkFile::open(path.clone())
+        .then(move |res| match res {
+            Ok(f) => Either::Left(file_conditional(f, path, conditionals)),
+            Err(err) => {
+                let rej = match err.kind() {
+                    io::ErrorKind::NotFound => {
+                        tracing::debug!("file not found: {:?}", path.as_ref().display());
+                        reject::not_found()
+                    }
+                    io::ErrorKind::PermissionDenied => {
+                        tracing::warn!(
+                            "file permission denied: {:?}", path.as_ref().display()
+                        );
+                        reject::known(FilePermissionError { _p: () })
+                    }
+                    _ => {
+                        tracing::error!(
+                            "file open error (path={:?}): {} ", path.as_ref().display(),
+                            err
+                        );
+                        reject::known(FileOpenError { _p: () })
+                    }
+                };
+                Either::Right(future::err(rej))
+            }
+        })
+}
+async fn file_metadata(f: TkFile) -> Result<(TkFile, Metadata), Rejection> {
+    loop {}
+}
+fn file_conditional(
+    f: TkFile,
+    path: ArcPath,
+    conditionals: Conditionals,
+) -> impl Future<Output = Result<File, Rejection>> + Send {
+    file_metadata(f)
+        .map_ok(move |(file, meta)| {
+            let mut len = meta.len();
+            let modified = meta.modified().ok().map(LastModified::from);
+            let resp = match conditionals.check(modified) {
+                Cond::NoBody(resp) => resp,
+                Cond::WithBody(range) => {
+                    bytes_range(range, len)
+                        .map(|(start, end)| {
+                            let sub_len = end - start;
+                            let buf_size = optimal_buf_size(&meta);
+                            let stream = file_stream(file, buf_size, (start, end));
+                            let body = Body::wrap_stream(stream);
+                            let mut resp = Response::new(body);
+                            if sub_len != len {
+                                *resp.status_mut() = StatusCode::PARTIAL_CONTENT;
+                                resp.headers_mut()
+                                    .typed_insert(
+                                        ContentRange::bytes(start..end, len)
+                                            .expect("valid ContentRange"),
+                                    );
+                                len = sub_len;
+                            }
+                            let mime = mime_guess::from_path(path.as_ref())
+                                .first_or_octet_stream();
+                            resp.headers_mut().typed_insert(ContentLength(len));
+                            resp.headers_mut().typed_insert(ContentType::from(mime));
+                            resp.headers_mut().typed_insert(AcceptRanges::bytes());
+                            if let Some(last_modified) = modified {
+                                resp.headers_mut().typed_insert(last_modified);
+                            }
+                            resp
+                        })
+                        .unwrap_or_else(|BadRange| {
+                            let mut resp = Response::new(Body::empty());
+                            *resp.status_mut() = StatusCode::RANGE_NOT_SATISFIABLE;
+                            resp.headers_mut()
+                                .typed_insert(ContentRange::unsatisfied_bytes(len));
+                            resp
+                        })
+                }
+            };
+            File { resp, path }
+        })
+}
+struct BadRange;
+fn bytes_range(range: Option<Range>, max_len: u64) -> Result<(u64, u64), BadRange> {
+    loop {}
+}
+fn file_stream(
+    mut file: TkFile,
+    buf_size: usize,
+    (start, end): (u64, u64),
+) -> impl Stream<Item = Result<Bytes, io::Error>> + Send {
+    use std::io::SeekFrom;
+    let seek = async move {
+        if start != 0 {
+            file.seek(SeekFrom::Start(start)).await?;
+        }
+        Ok(file)
+    };
+    seek.into_stream()
+        .map(move |result| {
+            let mut buf = BytesMut::new();
+            let mut len = end - start;
+            let mut f = match result {
+                Ok(f) => f,
+                Err(f) => return Either::Left(stream::once(future::err(f))),
+            };
+            Either::Right(
+                stream::poll_fn(move |cx| {
+                    if len == 0 {
+                        return Poll::Ready(None);
+                    }
+                    reserve_at_least(&mut buf, buf_size);
+                    let n = match ready!(
+                        poll_read_buf(Pin::new(& mut f), cx, & mut buf)
+                    ) {
+                        Ok(n) => n as u64,
+                        Err(err) => {
+                            tracing::debug!("file read error: {}", err);
+                            return Poll::Ready(Some(Err(err)));
+                        }
+                    };
+                    if n == 0 {
+                        tracing::debug!("file read found EOF before expected length");
+                        return Poll::Ready(None);
+                    }
+                    let mut chunk = buf.split().freeze();
+                    if n > len {
+                        chunk = chunk.split_to(len as usize);
+                        len = 0;
+                    } else {
+                        len -= n;
+                    }
+                    Poll::Ready(Some(Ok(chunk)))
+                }),
+            )
+        })
+        .flatten()
+}
+fn reserve_at_least(buf: &mut BytesMut, cap: usize) {
+    loop {}
+}
+const DEFAULT_READ_BUF_SIZE: usize = 8_192;
+fn optimal_buf_size(metadata: &Metadata) -> usize {
+    loop {}
+}
+#[cfg(unix)]
+fn get_block_size(metadata: &Metadata) -> usize {
+    loop {}
+}
+#[cfg(not(unix))]
+fn get_block_size(_metadata: &Metadata) -> usize {
+    loop {}
+}
+unit_error! {
+    pub (crate) FileOpenError : "file open error"
+}
+unit_error! {
+    pub (crate) FilePermissionError : "file perimission error"
+}
+#[cfg(test)]
+mod tests {
+    use super::sanitize_path;
+    use bytes::BytesMut;
+    #[test]
+    fn test_sanitize_path() {
+        loop {}
+    }
+    #[test]
+    fn test_reserve_at_least() {
+        loop {}
+    }
+}
diff --git a/warp/src/filters/header.rs b/warp/src/filters/header.rs
new file mode 100644
index 0000000..0c535a3
--- /dev/null
+++ b/warp/src/filters/header.rs
@@ -0,0 +1,230 @@
+//! Header Filters
+//!
+//! These filters are used to interact with the Request HTTP headers. Some
+//! of them, like `exact` and `exact_ignore_case`, are just predicates,
+//! they don't extract any values. The `header` filter allows parsing
+//! a type from any header.
+use std::convert::Infallible;
+use std::str::FromStr;
+
+use futures_util::future;
+use headers::{Header, HeaderMapExt};
+use http::header::HeaderValue;
+use http::HeaderMap;
+
+use crate::filter::{filter_fn, filter_fn_one, Filter, One};
+use crate::reject::{self, Rejection};
+
+/// Create a `Filter` that tries to parse the specified header.
+///
+/// This `Filter` will look for a header with supplied name, and try to
+/// parse to a `T`, otherwise rejects the request.
+///
+/// # Example
+///
+/// ```
+/// use std::net::SocketAddr;
+///
+/// // Parse `content-length: 100` as a `u64`
+/// let content_length = warp::header::<u64>("content-length");
+///
+/// // Parse `host: 127.0.0.1:8080` as a `SocketAddr
+/// let local_host = warp::header::<SocketAddr>("host");
+///
+/// // Parse `foo: bar` into a `String`
+/// let foo = warp::header::<String>("foo");
+/// ```
+pub fn header<T: FromStr + Send + 'static>(
+    name: &'static str,
+) -> impl Filter<Extract = One<T>, Error = Rejection> + Copy {
+    filter_fn_one(move |route| {
+        tracing::trace!("header({:?})", name);
+        let route = route
+            .headers()
+            .get(name)
+            .ok_or_else(|| reject::missing_header(name))
+            .and_then(|value| value.to_str().map_err(|_| reject::invalid_header(name)))
+            .and_then(|s| T::from_str(s).map_err(|_| reject::invalid_header(name)));
+        future::ready(route)
+    })
+}
+
+pub(crate) fn header2<T: Header + Send + 'static>(
+) -> impl Filter<Extract = One<T>, Error = Rejection> + Copy {
+    filter_fn_one(move |route| {
+        tracing::trace!("header2({:?})", T::name());
+        let route = route
+            .headers()
+            .typed_get()
+            .ok_or_else(|| reject::invalid_header(T::name().as_str()));
+        future::ready(route)
+    })
+}
+
+/// Create a `Filter` that tries to parse the specified header, if it exists.
+///
+/// If the header does not exist, it yields `None`. Otherwise, it will try to
+/// parse as a `T`, and if it fails, a invalid header rejection is return. If
+/// successful, the filter yields `Some(T)`.
+///
+/// # Example
+///
+/// ```
+/// // Grab the `authorization` header if it exists.
+/// let opt_auth = warp::header::optional::<String>("authorization");
+/// ```
+pub fn optional<T>(
+    name: &'static str,
+) -> impl Filter<Extract = One<Option<T>>, Error = Rejection> + Copy
+where
+    T: FromStr + Send + 'static,
+{
+    filter_fn_one(move |route| {
+        tracing::trace!("optional({:?})", name);
+        let result = route.headers().get(name).map(|value| {
+            value
+                .to_str()
+                .map_err(|_| reject::invalid_header(name))?
+                .parse::<T>()
+                .map_err(|_| reject::invalid_header(name))
+        });
+
+        match result {
+            Some(Ok(t)) => future::ok(Some(t)),
+            Some(Err(e)) => future::err(e),
+            None => future::ok(None),
+        }
+    })
+}
+
+pub(crate) fn optional2<T>() -> impl Filter<Extract = One<Option<T>>, Error = Infallible> + Copy
+where
+    T: Header + Send + 'static,
+{
+    filter_fn_one(move |route| future::ready(Ok(route.headers().typed_get())))
+}
+
+/* TODO
+pub fn exact2<T>(header: T) -> impl FilterClone<Extract=(), Error=Rejection>
+where
+    T: Header + PartialEq + Clone + Send,
+{
+    filter_fn(move |route| {
+        tracing::trace!("exact2({:?})", T::NAME);
+        route.headers()
+            .typed_get::<T>()
+            .and_then(|val| if val == header {
+                Some(())
+            } else {
+                None
+            })
+            .ok_or_else(|| reject::bad_request())
+    })
+}
+*/
+
+/// Create a `Filter` that requires a header to match the value exactly.
+///
+/// This `Filter` will look for a header with supplied name and the exact
+/// value, otherwise rejects the request.
+///
+/// # Example
+///
+/// ```
+/// // Require `dnt: 1` header to be set.
+/// let must_dnt = warp::header::exact("dnt", "1");
+/// ```
+pub fn exact(
+    name: &'static str,
+    value: &'static str,
+) -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    filter_fn(move |route| {
+        tracing::trace!("exact?({:?}, {:?})", name, value);
+        let route = route
+            .headers()
+            .get(name)
+            .ok_or_else(|| reject::missing_header(name))
+            .and_then(|val| {
+                if val == value {
+                    Ok(())
+                } else {
+                    Err(reject::invalid_header(name))
+                }
+            });
+        future::ready(route)
+    })
+}
+
+/// Create a `Filter` that requires a header to match the value exactly.
+///
+/// This `Filter` will look for a header with supplied name and the exact
+/// value, ignoring ASCII case, otherwise rejects the request.
+///
+/// # Example
+///
+/// ```
+/// // Require `connection: keep-alive` header to be set.
+/// let keep_alive = warp::header::exact_ignore_case("connection", "keep-alive");
+/// ```
+pub fn exact_ignore_case(
+    name: &'static str,
+    value: &'static str,
+) -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    filter_fn(move |route| {
+        tracing::trace!("exact_ignore_case({:?}, {:?})", name, value);
+        let route = route
+            .headers()
+            .get(name)
+            .ok_or_else(|| reject::missing_header(name))
+            .and_then(|val| {
+                if val.as_bytes().eq_ignore_ascii_case(value.as_bytes()) {
+                    Ok(())
+                } else {
+                    Err(reject::invalid_header(name))
+                }
+            });
+        future::ready(route)
+    })
+}
+
+/// Create a `Filter` that gets a `HeaderValue` for the name.
+///
+/// # Example
+///
+/// ```
+/// use warp::{Filter, http::header::HeaderValue};
+///
+/// let filter = warp::header::value("x-token")
+///     .map(|value: HeaderValue| {
+///         format!("header value bytes: {:?}", value)
+///     });
+/// ```
+pub fn value(
+    name: &'static str,
+) -> impl Filter<Extract = One<HeaderValue>, Error = Rejection> + Copy {
+    filter_fn_one(move |route| {
+        tracing::trace!("value({:?})", name);
+        let route = route
+            .headers()
+            .get(name)
+            .cloned()
+            .ok_or_else(|| reject::missing_header(name));
+        future::ready(route)
+    })
+}
+
+/// Create a `Filter` that returns a clone of the request's `HeaderMap`.
+///
+/// # Example
+///
+/// ```
+/// use warp::{Filter, http::HeaderMap};
+///
+/// let headers = warp::header::headers_cloned()
+///     .map(|headers: HeaderMap| {
+///         format!("header count: {}", headers.len())
+///     });
+/// ```
+pub fn headers_cloned() -> impl Filter<Extract = One<HeaderMap>, Error = Infallible> + Copy {
+    filter_fn_one(|route| future::ok(route.headers().clone()))
+}
diff --git a/warp/src/filters/host.rs b/warp/src/filters/host.rs
new file mode 100644
index 0000000..9aae039
--- /dev/null
+++ b/warp/src/filters/host.rs
@@ -0,0 +1,96 @@
+//! Host ("authority") filter
+//!
+use crate::filter::{filter_fn_one, Filter, One};
+use crate::reject::{self, Rejection};
+use futures_util::future;
+pub use http::uri::Authority;
+use std::str::FromStr;
+
+/// Creates a `Filter` that requires a specific authority (target server's
+/// host and port) in the request.
+///
+/// Authority is specified either in the `Host` header or in the target URI.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let multihost =
+///     warp::host::exact("foo.com").map(|| "you've reached foo.com")
+///     .or(warp::host::exact("bar.com").map(|| "you've reached bar.com"));
+/// ```
+pub fn exact(expected: &str) -> impl Filter<Extract = (), Error = Rejection> + Clone {
+    let expected = Authority::from_str(expected).expect("invalid host/authority");
+    optional()
+        .and_then(move |option: Option<Authority>| match option {
+            Some(authority) if authority == expected => future::ok(()),
+            _ => future::err(reject::not_found()),
+        })
+        .untuple_one()
+}
+
+/// Creates a `Filter` that looks for an authority (target server's host
+/// and port) in the request.
+///
+/// Authority is specified either in the `Host` header or in the target URI.
+///
+/// If found, extracts the `Authority`, otherwise continues the request,
+/// extracting `None`.
+///
+/// Rejects with `400 Bad Request` if the `Host` header is malformed or if there
+/// is a mismatch between the `Host` header and the target URI.
+///
+/// # Example
+///
+/// ```
+/// use warp::{Filter, host::Authority};
+///
+/// let host = warp::host::optional()
+///     .map(|authority: Option<Authority>| {
+///         if let Some(a) = authority {
+///             format!("{} is currently not at home", a.host())
+///         } else {
+///             "please state who you're trying to reach".to_owned()
+///         }
+///     });
+/// ```
+pub fn optional() -> impl Filter<Extract = One<Option<Authority>>, Error = Rejection> + Copy {
+    filter_fn_one(move |route| {
+        // The authority can be sent by clients in various ways:
+        //
+        //  1) in the "target URI"
+        //    a) serialized in the start line (HTTP/1.1 proxy requests)
+        //    b) serialized in `:authority` pseudo-header (HTTP/2 generated - "SHOULD")
+        //  2) in the `Host` header (HTTP/1.1 origin requests, HTTP/2 converted)
+        //
+        // Hyper transparently handles 1a/1b, but not 2, so we must look at both.
+
+        let from_uri = route.uri().authority();
+
+        let name = "host";
+        let from_header = route.headers()
+            .get(name)
+            .map(|value|
+                // Header present, parse it
+                value.to_str().map_err(|_| reject::invalid_header(name))
+                    .and_then(|value| Authority::from_str(value).map_err(|_| reject::invalid_header(name)))
+            );
+
+        future::ready(match (from_uri, from_header) {
+            // no authority in the request (HTTP/1.0 or non-conforming)
+            (None, None) => Ok(None),
+
+            // authority specified in either or both matching
+            (Some(a), None) => Ok(Some(a.clone())),
+            (None, Some(Ok(a))) => Ok(Some(a)),
+            (Some(a), Some(Ok(b))) if *a == b => Ok(Some(b)),
+
+            // mismatch
+            (Some(_), Some(Ok(_))) => Err(reject::invalid_header(name)),
+
+            // parse error
+            (_, Some(Err(r))) => Err(r),
+        })
+    })
+}
diff --git a/warp/src/filters/log.rs b/warp/src/filters/log.rs
new file mode 100644
index 0000000..f7c51b1
--- /dev/null
+++ b/warp/src/filters/log.rs
@@ -0,0 +1,197 @@
+//! Logger Filters
+use std::fmt;
+use std::net::SocketAddr;
+use std::time::{Duration, Instant};
+use http::{self, StatusCode};
+use crate::filter::{Filter, WrapSealed};
+use crate::reject::IsReject;
+use crate::reply::Reply;
+use crate::route::Route;
+use self::internal::WithLog;
+/// Create a wrapping filter with the specified `name` as the `target`.
+///
+/// This uses the default access logging format, and log records produced
+/// will have their `target` set to `name`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // If using something like `pretty_env_logger`,
+/// // view logs by setting `RUST_LOG=example::api`.
+/// let log = warp::log("example::api");
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(log);
+/// ```
+pub fn log(name: &'static str) -> Log<impl Fn(Info<'_>) + Copy> {
+    let func = move |info: Info<'_>| {
+        log::info!(
+            target : name, "{} \"{} {} {:?}\" {} \"{}\" \"{}\" {:?}", OptFmt(info.route
+            .remote_addr()), info.method(), info.path(), info.route.version(), info
+            .status().as_u16(), OptFmt(info.referer()), OptFmt(info.user_agent()), info
+            .elapsed(),
+        );
+    };
+    Log { func }
+}
+/// Create a wrapping filter that receives `warp::log::Info`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let log = warp::log::custom(|info| {
+///     // Use a log macro, or slog, or println, or whatever!
+///     eprintln!(
+///         "{} {} {}",
+///         info.method(),
+///         info.path(),
+///         info.status(),
+///     );
+/// });
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(log);
+/// ```
+pub fn custom<F>(func: F) -> Log<F>
+where
+    F: Fn(Info<'_>),
+{
+    loop {}
+}
+/// Decorates a [`Filter`](crate::Filter) to log requests and responses.
+#[derive(Clone, Copy, Debug)]
+pub struct Log<F> {
+    func: F,
+}
+/// Information about the request/response that can be used to prepare log lines.
+#[allow(missing_debug_implementations)]
+pub struct Info<'a> {
+    route: &'a Route,
+    start: Instant,
+    status: StatusCode,
+}
+impl<FN, F> WrapSealed<F> for Log<FN>
+where
+    FN: Fn(Info<'_>) + Clone + Send,
+    F: Filter + Clone + Send,
+    F::Extract: Reply,
+    F::Error: IsReject,
+{
+    type Wrapped = WithLog<FN, F>;
+    fn wrap(&self, filter: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+impl<'a> Info<'a> {
+    /// View the remote `SocketAddr` of the request.
+    pub fn remote_addr(&self) -> Option<SocketAddr> {
+        loop {}
+    }
+    /// View the `http::Method` of the request.
+    pub fn method(&self) -> &http::Method {
+        loop {}
+    }
+    /// View the URI path of the request.
+    pub fn path(&self) -> &str {
+        loop {}
+    }
+    /// View the `http::Version` of the request.
+    pub fn version(&self) -> http::Version {
+        loop {}
+    }
+    /// View the `http::StatusCode` of the response.
+    pub fn status(&self) -> http::StatusCode {
+        loop {}
+    }
+    /// View the referer of the request.
+    pub fn referer(&self) -> Option<&str> {
+        loop {}
+    }
+    /// View the user agent of the request.
+    pub fn user_agent(&self) -> Option<&str> {
+        loop {}
+    }
+    /// View the `Duration` that elapsed for the request.
+    pub fn elapsed(&self) -> Duration {
+        loop {}
+    }
+    /// View the host of the request
+    pub fn host(&self) -> Option<&str> {
+        loop {}
+    }
+    /// Access the full headers of the request
+    pub fn request_headers(&self) -> &http::HeaderMap {
+        loop {}
+    }
+}
+struct OptFmt<T>(Option<T>);
+impl<T: fmt::Display> fmt::Display for OptFmt<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+mod internal {
+    use std::future::Future;
+    use std::pin::Pin;
+    use std::task::{Context, Poll};
+    use std::time::Instant;
+    use futures_util::{TryFuture};
+    use pin_project::pin_project;
+    use super::{Info, Log};
+    use crate::filter::{Filter, FilterBase, Internal};
+    use crate::reject::IsReject;
+    use crate::reply::{Reply, Response};
+    
+    #[allow(missing_debug_implementations)]
+    pub struct Logged(pub(super) Response);
+    impl Reply for Logged {
+        #[inline]
+        fn into_response(self) -> Response {
+            loop {}
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    #[derive(Clone, Copy)]
+    pub struct WithLog<FN, F> {
+        pub(super) filter: F,
+        pub(super) log: Log<FN>,
+    }
+    impl<FN, F> FilterBase for WithLog<FN, F>
+    where
+        FN: Fn(Info<'_>) + Clone + Send,
+        F: Filter + Clone + Send,
+        F::Extract: Reply,
+        F::Error: IsReject,
+    {
+        type Extract = (Logged,);
+        type Error = F::Error;
+        type Future = WithLogFuture<FN, F::Future>;
+        fn filter(&self, _: Internal) -> Self::Future {
+            loop {}
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    #[pin_project]
+    pub struct WithLogFuture<FN, F> {
+        log: Log<FN>,
+        #[pin]
+        future: F,
+        started: Instant,
+    }
+    impl<FN, F> Future for WithLogFuture<FN, F>
+    where
+        FN: Fn(Info<'_>),
+        F: TryFuture,
+        F::Ok: Reply,
+        F::Error: IsReject,
+    {
+        type Output = Result<(Logged,), F::Error>;
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            loop {}
+        }
+    }
+}
diff --git a/warp/src/filters/method.rs b/warp/src/filters/method.rs
new file mode 100644
index 0000000..80c00e2
--- /dev/null
+++ b/warp/src/filters/method.rs
@@ -0,0 +1,135 @@
+//! HTTP Method filters.
+//!
+//! The filters deal with the HTTP Method part of a request. Several here will
+//! match the request `Method`, and if not matched, will reject the request
+//! with a `405 Method Not Allowed`.
+//!
+//! There is also [`warp::method()`](method), which never rejects
+//! a request, and just extracts the method to be used in your filter chains.
+use futures_util::future;
+use http::Method;
+use crate::filter::{filter_fn, filter_fn_one, Filter, One};
+use crate::reject::Rejection;
+use std::convert::Infallible;
+/// Create a `Filter` that requires the request method to be `GET`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let get_only = warp::get().map(warp::reply);
+/// ```
+pub fn get() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    method_is(|| &Method::GET)
+}
+/// Create a `Filter` that requires the request method to be `POST`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let post_only = warp::post().map(warp::reply);
+/// ```
+pub fn post() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    method_is(|| &Method::POST)
+}
+/// Create a `Filter` that requires the request method to be `PUT`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let put_only = warp::put().map(warp::reply);
+/// ```
+pub fn put() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    method_is(|| &Method::PUT)
+}
+/// Create a `Filter` that requires the request method to be `DELETE`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let delete_only = warp::delete().map(warp::reply);
+/// ```
+pub fn delete() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    method_is(|| &Method::DELETE)
+}
+/// Create a `Filter` that requires the request method to be `HEAD`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let head_only = warp::head().map(warp::reply);
+/// ```
+pub fn head() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    method_is(|| &Method::HEAD)
+}
+/// Create a `Filter` that requires the request method to be `OPTIONS`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let options_only = warp::options().map(warp::reply);
+/// ```
+pub fn options() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    method_is(|| &Method::OPTIONS)
+}
+/// Create a `Filter` that requires the request method to be `PATCH`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let patch_only = warp::patch().map(warp::reply);
+/// ```
+pub fn patch() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    method_is(|| &Method::PATCH)
+}
+/// Extract the `Method` from the request.
+///
+/// This never rejects a request.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::method()
+///     .map(|method| {
+///         format!("You sent a {} request!", method)
+///     });
+/// ```
+pub fn method() -> impl Filter<Extract = One<Method>, Error = Infallible> + Copy {
+    filter_fn_one(|route| future::ok::<_, Infallible>(route.method().clone()))
+}
+fn method_is<F>(func: F) -> impl Filter<Extract = (), Error = Rejection> + Copy
+where
+    F: Fn() -> &'static Method + Copy,
+{
+    filter_fn(move |route| {
+        let method = func();
+        tracing::trace!("method::{:?}?: {:?}", method, route.method());
+        if route.method() == method {
+            future::ok(())
+        } else {
+            future::err(crate::reject::method_not_allowed())
+        }
+    })
+}
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn method_size_of() {
+        loop {}
+    }
+}
diff --git a/warp/src/filters/mod.rs b/warp/src/filters/mod.rs
new file mode 100644
index 0000000..bd1c487
--- /dev/null
+++ b/warp/src/filters/mod.rs
@@ -0,0 +1,29 @@
+//! Built-in Filters
+//!
+//! This module mostly serves as documentation to group together the list of
+//! built-in filters. Most of these are available at more convenient paths.
+
+pub mod addr;
+pub mod any;
+pub mod body;
+#[cfg(any(feature = "compression-brotli", feature = "compression-gzip"))]
+pub mod compression;
+pub mod cookie;
+pub mod cors;
+pub mod ext;
+pub mod fs;
+pub mod header;
+pub mod host;
+pub mod log;
+pub mod method;
+#[cfg(feature = "multipart")]
+pub mod multipart;
+pub mod path;
+pub mod query;
+pub mod reply;
+pub mod sse;
+pub mod trace;
+#[cfg(feature = "websocket")]
+pub mod ws;
+
+pub use crate::filter::BoxedFilter;
diff --git a/warp/src/filters/multipart.rs b/warp/src/filters/multipart.rs
new file mode 100644
index 0000000..d58587c
--- /dev/null
+++ b/warp/src/filters/multipart.rs
@@ -0,0 +1,116 @@
+//! Multipart body filters
+//!
+//! Filters that extract a multipart body for a route.
+use std::fmt;
+use std::future::Future;
+use std::io::{Cursor, Read};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use bytes::{Buf, Bytes};
+use futures_util::{future, Stream};
+use headers::ContentType;
+use mime::Mime;
+use multipart::server::Multipart;
+use crate::filter::{Filter, FilterBase, Internal};
+use crate::reject::{self, Rejection};
+const DEFAULT_FORM_DATA_MAX_LENGTH: u64 = 1024 * 1024 * 2;
+/// A `Filter` to extract a `multipart/form-data` body from a request.
+///
+/// Create with the `warp::multipart::form()` function.
+#[derive(Debug, Clone)]
+pub struct FormOptions {
+    max_length: u64,
+}
+/// A `Stream` of multipart/form-data `Part`s.
+///
+/// Extracted with a `warp::multipart::form` filter.
+pub struct FormData {
+    inner: Multipart<Cursor<::bytes::Bytes>>,
+}
+/// A single "part" of a multipart/form-data body.
+///
+/// Yielded from the `FormData` stream.
+pub struct Part {
+    name: String,
+    filename: Option<String>,
+    content_type: Option<String>,
+    data: Option<Vec<u8>>,
+}
+/// Create a `Filter` to extract a `multipart/form-data` body from a request.
+///
+/// The extracted `FormData` type is a `Stream` of `Part`s, and each `Part`
+/// in turn is a `Stream` of bytes.
+pub fn form() -> FormOptions {
+    loop {}
+}
+impl FormOptions {
+    /// Set the maximum byte length allowed for this body.
+    ///
+    /// Defaults to 2MB.
+    pub fn max_length(mut self, max: u64) -> Self {
+        loop {}
+    }
+}
+type FormFut = Pin<Box<dyn Future<Output = Result<(FormData,), Rejection>> + Send>>;
+impl FilterBase for FormOptions {
+    type Extract = (FormData,);
+    type Error = Rejection;
+    type Future = FormFut;
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+impl fmt::Debug for FormData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl Stream for FormData {
+    type Item = Result<Part, crate::Error>;
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {}
+    }
+}
+impl Part {
+    /// Get the name of this part.
+    pub fn name(&self) -> &str {
+        loop {}
+    }
+    /// Get the filename of this part, if present.
+    pub fn filename(&self) -> Option<&str> {
+        loop {}
+    }
+    /// Get the content-type of this part, if present.
+    pub fn content_type(&self) -> Option<&str> {
+        loop {}
+    }
+    /// Asynchronously get some of the data for this `Part`.
+    pub async fn data(&mut self) -> Option<Result<impl Buf, crate::Error>> {
+        loop {}
+    }
+    /// Convert this `Part` into a `Stream` of `Buf`s.
+    pub fn stream(self) -> impl Stream<Item = Result<impl Buf, crate::Error>> {
+        loop {}
+    }
+    fn take_data(&mut self) -> Option<Result<Bytes, crate::Error>> {
+        loop {}
+    }
+}
+impl fmt::Debug for Part {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+struct PartStream(Part);
+impl Stream for PartStream {
+    type Item = Result<Bytes, crate::Error>;
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {}
+    }
+}
diff --git a/warp/src/filters/path.rs b/warp/src/filters/path.rs
new file mode 100644
index 0000000..545b21f
--- /dev/null
+++ b/warp/src/filters/path.rs
@@ -0,0 +1,527 @@
+//! Path Filters
+//!
+//! The filters here work on the "path" of requests.
+//!
+//! - [`path`](./fn.path.html) matches a specific segment, like `/foo`.
+//! - [`param`](./fn.param.html) tries to parse a segment into a type, like `/:u16`.
+//! - [`end`](./fn.end.html) matches when the path end is found.
+//! - [`path!`](../../macro.path.html) eases combining multiple `path` and `param` filters.
+//!
+//! # Routing
+//!
+//! Routing in warp is simple yet powerful.
+//!
+//! First up, matching a single segment:
+//!
+//! ```
+//! use warp::Filter;
+//!
+//! // GET /hi
+//! let hi = warp::path("hi").map(|| {
+//!     "Hello, World!"
+//! });
+//! ```
+//!
+//! How about multiple segments? It's easiest with the `path!` macro:
+//!
+//! ```
+//! # use warp::Filter;
+//! // GET /hello/from/warp
+//! let hello_from_warp = warp::path!("hello" / "from" / "warp").map(|| {
+//!     "Hello from warp!"
+//! });
+//! ```
+//!
+//! Neat! But how do I handle **parameters** in paths?
+//!
+//! ```
+//! # use warp::Filter;
+//! // GET /sum/:u32/:u32
+//! let sum = warp::path!("sum" / u32 / u32).map(|a, b| {
+//!     format!("{} + {} = {}", a, b, a + b)
+//! });
+//! ```
+//!
+//! In fact, any type that implements `FromStr` can be used, in any order:
+//!
+//! ```
+//! # use warp::Filter;
+//! // GET /:u16/times/:u16
+//! let times = warp::path!(u16 / "times" / u16).map(|a, b| {
+//!     format!("{} times {} = {}", a, b, a * b)
+//! });
+//! ```
+//!
+//! Oh shoot, those math routes should be **mounted** at a different path,
+//! is that possible? Yep!
+//!
+//! ```
+//! # use warp::Filter;
+//! # let sum = warp::any().map(warp::reply);
+//! # let times = sum.clone();
+//! // GET /math/sum/:u32/:u32
+//! // GET /math/:u16/times/:u16
+//! let math = warp::path("math");
+//! let math_sum = math.and(sum);
+//! let math_times = math.and(times);
+//! ```
+//!
+//! What! `and`? What's that do?
+//!
+//! It combines the filters in a sort of "this and then that" order. In fact,
+//! it's exactly what the `path!` macro has been doing internally.
+//!
+//! ```
+//! # use warp::Filter;
+//! // GET /bye/:string
+//! let bye = warp::path("bye")
+//!     .and(warp::path::param())
+//!     .map(|name: String| {
+//!         format!("Good bye, {}!", name)
+//!     });
+//! ```
+//!
+//! Ah, so, can filters do things besides `and`?
+//!
+//! Why, yes they can! They can also `or`! As you might expect, `or` creates a
+//! "this or else that" chain of filters. If the first doesn't succeed, then
+//! it tries the other.
+//!
+//! So, those `math` routes could have been **mounted** all as one, with `or`.
+//!
+//!
+//! ```
+//! # use warp::Filter;
+//! # let sum = warp::path("sum");
+//! # let times = warp::path("times");
+//! // GET /math/sum/:u32/:u32
+//! // GET /math/:u16/times/:u16
+//! let math = warp::path("math")
+//!     .and(sum.or(times));
+//! ```
+//!
+//! It turns out, using `or` is how you combine everything together into a
+//! single API.
+//!
+//! ```
+//! # use warp::Filter;
+//! # let hi = warp::path("hi");
+//! # let hello_from_warp = hi.clone();
+//! # let bye = hi.clone();
+//! # let math = hi.clone();
+//! // GET /hi
+//! // GET /hello/from/warp
+//! // GET /bye/:string
+//! // GET /math/sum/:u32/:u32
+//! // GET /math/:u16/times/:u16
+//! let routes = hi
+//!     .or(hello_from_warp)
+//!     .or(bye)
+//!     .or(math);
+//! ```
+//!
+//! Note that you will generally want path filters to come **before** other filters
+//! like `body` or `headers`. If a different type of filter comes first, a request
+//! with an invalid body for route `/right-path-wrong-body` may try matching against `/wrong-path`
+//! and return the error from `/wrong-path` instead of the correct body-related error.
+use std::convert::Infallible;
+use std::fmt;
+use std::str::FromStr;
+use futures_util::future;
+use http::uri::PathAndQuery;
+use self::internal::Opaque;
+use crate::filter::{filter_fn, one, Filter, FilterBase, Internal, One, Tuple};
+use crate::reject::{self, Rejection};
+use crate::route::Route;
+/// Create an exact match path segment `Filter`.
+///
+/// This will try to match exactly to the current request path segment.
+///
+/// # Note
+///
+/// - [`end()`](./fn.end.html) should be used to match the end of a path to avoid having
+///   filters for shorter paths like `/math` unintentionally match a longer
+///   path such as `/math/sum`
+/// - Path-related filters should generally come **before** other types of filters, such
+///   as those checking headers or body types. Including those other filters before
+///   the path checks may result in strange errors being returned because a given request
+///   does not match the parameters for a completely separate route.
+///
+/// # Panics
+///
+/// Exact path filters cannot be empty, or contain slashes.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // Matches '/hello'
+/// let hello = warp::path("hello")
+///     .map(|| "Hello, World!");
+/// ```
+pub fn path<P>(p: P) -> Exact<Opaque<P>>
+where
+    P: AsRef<str>,
+{
+    loop {}
+}
+/// A `Filter` matching an exact path segment.
+///
+/// Constructed from `path()` or `path!()`.
+#[allow(missing_debug_implementations)]
+#[derive(Clone, Copy)]
+pub struct Exact<P>(P);
+impl<P> FilterBase for Exact<P>
+where
+    P: AsRef<str>,
+{
+    type Extract = ();
+    type Error = Rejection;
+    type Future = future::Ready<Result<Self::Extract, Self::Error>>;
+    #[inline]
+    fn filter(&self, _: Internal) -> Self::Future {
+        loop {}
+    }
+}
+/// Matches the end of a route.
+///
+/// Note that _not_ including `end()` may result in shorter paths like
+/// `/math` unintentionally matching `/math/sum`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // Matches '/'
+/// let hello = warp::path::end()
+///     .map(|| "Hello, World!");
+/// ```
+pub fn end() -> impl Filter<Extract = (), Error = Rejection> + Copy {
+    filter_fn(move |route| {
+        if route.path().is_empty() {
+            future::ok(())
+        } else {
+            future::err(reject::not_found())
+        }
+    })
+}
+/// Extract a parameter from a path segment.
+///
+/// This will try to parse a value from the current request path
+/// segment, and if successful, the value is returned as the `Filter`'s
+/// "extracted" value.
+///
+/// If the value could not be parsed, rejects with a `404 Not Found`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::path::param()
+///     .map(|id: u32| {
+///         format!("You asked for /{}", id)
+///     });
+/// ```
+pub fn param<T: FromStr + Send + 'static>() -> impl Filter<
+    Extract = One<T>,
+    Error = Rejection,
+> + Copy {
+    filter_segment(|seg| {
+        tracing::trace!("param?: {:?}", seg);
+        if seg.is_empty() {
+            return Err(reject::not_found());
+        }
+        T::from_str(seg).map(one).map_err(|_| reject::not_found())
+    })
+}
+/// Extract the unmatched tail of the path.
+///
+/// This will return a `Tail`, which allows access to the rest of the path
+/// that previous filters have not already matched.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::path("foo")
+///     .and(warp::path::tail())
+///     .map(|tail| {
+///         // GET /foo/bar/baz would return "bar/baz".
+///         format!("The tail after foo is {:?}", tail)
+///     });
+/// ```
+pub fn tail() -> impl Filter<Extract = One<Tail>, Error = Infallible> + Copy {
+    filter_fn(move |route| {
+        let path = path_and_query(route);
+        let idx = route.matched_path_index();
+        let end = path.path().len() - idx;
+        route.set_unmatched_path(end);
+        future::ok(one(Tail { path, start_index: idx }))
+    })
+}
+/// Represents the tail part of a request path, returned by the [`tail()`] filter.
+pub struct Tail {
+    path: PathAndQuery,
+    start_index: usize,
+}
+impl Tail {
+    /// Get the `&str` representation of the remaining path.
+    pub fn as_str(&self) -> &str {
+        loop {}
+    }
+}
+impl fmt::Debug for Tail {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+/// Peek at the unmatched tail of the path, without affecting the matched path.
+///
+/// This will return a `Peek`, which allows access to the rest of the path
+/// that previous filters have not already matched. This differs from `tail`
+/// in that `peek` will **not** set the entire path as matched.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::path("foo")
+///     .and(warp::path::peek())
+///     .map(|peek| {
+///         // GET /foo/bar/baz would return "bar/baz".
+///         format!("The path after foo is {:?}", peek)
+///     });
+/// ```
+pub fn peek() -> impl Filter<Extract = One<Peek>, Error = Infallible> + Copy {
+    filter_fn(move |route| {
+        let path = path_and_query(route);
+        let idx = route.matched_path_index();
+        future::ok(one(Peek { path, start_index: idx }))
+    })
+}
+/// Represents the tail part of a request path, returned by the [`peek()`] filter.
+pub struct Peek {
+    path: PathAndQuery,
+    start_index: usize,
+}
+impl Peek {
+    /// Get the `&str` representation of the remaining path.
+    pub fn as_str(&self) -> &str {
+        loop {}
+    }
+    /// Get an iterator over the segments of the peeked path.
+    pub fn segments(&self) -> impl Iterator<Item = &str> {
+        self.as_str().split('/').filter(|seg| !seg.is_empty())
+    }
+}
+impl fmt::Debug for Peek {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+/// Returns the full request path, irrespective of other filters.
+///
+/// This will return a `FullPath`, which can be stringified to return the
+/// full path of the request.
+///
+/// This is more useful in generic pre/post-processing filters, and should
+/// probably not be used for request matching/routing.
+///
+/// # Example
+///
+/// ```
+/// use warp::{Filter, path::FullPath};
+/// use std::{collections::HashMap, sync::{Arc, Mutex}};
+///
+/// let counts = Arc::new(Mutex::new(HashMap::new()));
+/// let access_counter = warp::path::full()
+///     .map(move |path: FullPath| {
+///         let mut counts = counts.lock().unwrap();
+///
+///         *counts.entry(path.as_str().to_string())
+///             .and_modify(|c| *c += 1)
+///             .or_insert(0)
+///     });
+///
+/// let route = warp::path("foo")
+///     .and(warp::path("bar"))
+///     .and(access_counter)
+///     .map(|count| {
+///         format!("This is the {}th visit to this URL!", count)
+///     });
+/// ```
+pub fn full() -> impl Filter<Extract = One<FullPath>, Error = Infallible> + Copy {
+    filter_fn(move |route| future::ok(one(FullPath(path_and_query(route)))))
+}
+/// Represents the full request path, returned by the [`full()`] filter.
+pub struct FullPath(PathAndQuery);
+impl FullPath {
+    /// Get the `&str` representation of the request path.
+    pub fn as_str(&self) -> &str {
+        loop {}
+    }
+}
+impl fmt::Debug for FullPath {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+fn filter_segment<F, U>(func: F) -> impl Filter<Extract = U, Error = Rejection> + Copy
+where
+    F: Fn(&str) -> Result<U, Rejection> + Copy,
+    U: Tuple + Send + 'static,
+{
+    filter_fn(move |route| future::ready(with_segment(route, func)))
+}
+fn with_segment<F, U>(route: &mut Route, func: F) -> Result<U, Rejection>
+where
+    F: Fn(&str) -> Result<U, Rejection>,
+{
+    loop {}
+}
+fn path_and_query(route: &Route) -> PathAndQuery {
+    loop {}
+}
+/// Convenient way to chain multiple path filters together.
+///
+/// Any number of either type identifiers or string expressions can be passed,
+/// each separated by a forward slash (`/`). Strings will be used to match
+/// path segments exactly, and type identifiers are used just like
+/// [`param`](crate::path::param) filters.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // Match `/sum/:a/:b`
+/// let route = warp::path!("sum" / u32 / u32)
+///     .map(|a, b| {
+///         format!("{} + {} = {}", a, b, a + b)
+///     });
+/// ```
+///
+/// The equivalent filter chain without using the `path!` macro looks this:
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::path("sum")
+///     .and(warp::path::param::<u32>())
+///     .and(warp::path::param::<u32>())
+///     .and(warp::path::end())
+///     .map(|a, b| {
+///         format!("{} + {} = {}", a, b, a + b)
+///     });
+/// ```
+///
+/// # Path Prefixes
+///
+/// The `path!` macro automatically assumes the path should include an `end()`
+/// filter. To build up a path filter *prefix*, such that the `end()` isn't
+/// included, use the `/ ..` syntax.
+///
+///
+/// ```
+/// use warp::Filter;
+///
+/// let prefix = warp::path!("math" / "sum" / ..);
+///
+/// let sum = warp::path!(u32 / u32)
+///     .map(|a, b| {
+///         format!("{} + {} = {}", a, b, a + b)
+///     });
+///
+/// let help = warp::path::end()
+///     .map(|| "This API returns the sum of two u32's");
+///
+/// let api = prefix.and(sum.or(help));
+/// ```
+#[macro_export]
+macro_rules! path {
+    ($($pieces:tt)*) => {
+        { $crate ::__internal_path!(@ start $($pieces)*) }
+    };
+}
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __internal_path {
+    (@ start) => {
+        $crate ::path::end()
+    };
+    (@ start ..) => {
+        { compile_error!("'..' cannot be the only segment") }
+    };
+    (@ start $first:tt $(/ $tail:tt)*) => {
+        { $crate ::__internal_path!(@ munch $crate ::any(); [$first] [$(/ $tail)*]) }
+    };
+    (@ munch $sum:expr; [$cur:tt] [/ $next:tt $(/ $tail:tt)*]) => {
+        { $crate ::__internal_path!(@ munch $crate ::Filter::and($sum, $crate
+        ::__internal_path!(@ segment $cur)); [$next] [$(/ $tail)*]) }
+    };
+    (@ munch $sum:expr; [$cur:tt] []) => {
+        { $crate ::__internal_path!(@ last $sum; $cur) }
+    };
+    (@ last $sum:expr; ..) => {
+        $sum
+    };
+    (@ last $sum:expr; $end:tt) => {
+        $crate ::Filter::and($crate ::Filter::and($sum, $crate ::__internal_path!(@
+        segment $end)), $crate ::path::end())
+    };
+    (@ segment ..) => {
+        compile_error!("'..' must be the last segment")
+    };
+    (@ segment $param:ty) => {
+        $crate ::path::param::<$param > ()
+    };
+    (@ segment $s:literal) => {
+        { #[derive(Clone, Copy)] struct __StaticPath; impl ::std::convert::AsRef < str >
+        for __StaticPath { fn as_ref(& self) -> & str { static S : & str = $s; S } }
+        $crate ::path(__StaticPath) }
+    };
+}
+/// ```compile_fail
+/// warp::path!("foo" / .. / "bar");
+/// ```
+///
+/// ```compile_fail
+/// warp::path!(.. / "bar");
+/// ```
+///
+/// ```compile_fail
+/// warp::path!("foo" ..);
+/// ```
+///
+/// ```compile_fail
+/// warp::path!("foo" / .. /);
+/// ```
+///
+/// ```compile_fail
+/// warp::path!(..);
+/// ```
+fn _path_macro_compile_fail() {}
+mod internal {
+    #[allow(missing_debug_implementations)]
+    #[derive(Clone, Copy)]
+    pub struct Opaque<T>(pub(super) T);
+    impl<T: AsRef<str>> AsRef<str> for Opaque<T> {
+        #[inline]
+        fn as_ref(&self) -> &str {
+            loop {}
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_path_exact_size() {
+        loop {}
+    }
+}
diff --git a/warp/src/filters/query.rs b/warp/src/filters/query.rs
new file mode 100644
index 0000000..7aee569
--- /dev/null
+++ b/warp/src/filters/query.rs
@@ -0,0 +1,91 @@
+//! Query Filters
+
+use futures_util::future;
+use serde::de::DeserializeOwned;
+use serde_urlencoded;
+
+use crate::filter::{filter_fn_one, Filter, One};
+use crate::reject::{self, Rejection};
+
+/// Creates a `Filter` that decodes query parameters to the type `T`.
+///
+/// If cannot decode into a `T`, the request is rejected with a `400 Bad Request`.
+///
+/// # Example
+///
+/// ```
+/// use std::collections::HashMap;
+/// use warp::{
+///     http::Response,
+///     Filter,
+/// };
+///
+/// let route = warp::any()
+///     .and(warp::query::<HashMap<String, String>>())
+///     .map(|map: HashMap<String, String>| {
+///         let mut response: Vec<String> = Vec::new();
+///         for (key, value) in map.into_iter() {
+///             response.push(format!("{}={}", key, value))
+///         }
+///         Response::builder().body(response.join(";"))
+///     });
+/// ```
+///
+/// You can define your custom query object and deserialize with [Serde][Serde]. Ensure to include
+/// the crate in your dependencies before usage.
+///
+/// ```
+/// use serde_derive::{Deserialize, Serialize};
+/// use std::collections::HashMap;
+/// use warp::{
+///     http::Response,
+///     Filter,
+/// };
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct FooQuery {
+///     foo: Option<String>,
+///     bar: u8,
+/// }
+///
+/// let route = warp::any()
+///     .and(warp::query::<FooQuery>())
+///     .map(|q: FooQuery| {
+///         if let Some(foo) = q.foo {
+///             Response::builder().body(format!("foo={}", foo))
+///         } else {
+///             Response::builder().body(format!("bar={}", q.bar))
+///         }
+///     });
+/// ```
+///
+/// For more examples, please take a look at [examples/query_string.rs](https://github.com/seanmonstar/warp/blob/master/examples/query_string.rs).
+///
+/// [Serde]: https://docs.rs/serde
+pub fn query<T: DeserializeOwned + Send + 'static>(
+) -> impl Filter<Extract = One<T>, Error = Rejection> + Copy {
+    filter_fn_one(|route| {
+        let query_string = route.query().unwrap_or_else(|| {
+            tracing::debug!("route was called without a query string, defaulting to empty");
+            ""
+        });
+
+        let query_encoded = serde_urlencoded::from_str(query_string).map_err(|e| {
+            tracing::debug!("failed to decode query string '{}': {:?}", query_string, e);
+            reject::invalid_query()
+        });
+        future::ready(query_encoded)
+    })
+}
+
+/// Creates a `Filter` that returns the raw query string as type String.
+pub fn raw() -> impl Filter<Extract = One<String>, Error = Rejection> + Copy {
+    filter_fn_one(|route| {
+        let route = route
+            .query()
+            .map(|q| q.to_owned())
+            .map(Ok)
+            .unwrap_or_else(|| Err(reject::invalid_query()));
+        future::ready(route)
+    })
+}
diff --git a/warp/src/filters/reply.rs b/warp/src/filters/reply.rs
new file mode 100644
index 0000000..e202888
--- /dev/null
+++ b/warp/src/filters/reply.rs
@@ -0,0 +1,201 @@
+//! Reply Filters
+//!
+//! These "filters" behave a little differently than the rest. Instead of
+//! being used directly on requests, these filters "wrap" other filters.
+//!
+//!
+//! ## Wrapping a `Filter` (`with`)
+//!
+//! ```
+//! use warp::Filter;
+//!
+//! let with_server = warp::reply::with::header("server", "warp");
+//!
+//! let route = warp::any()
+//!     .map(warp::reply)
+//!     .with(with_server);
+//! ```
+//!
+//! Wrapping allows adding in conditional logic *before* the request enters
+//! the inner filter (though the `with::header` wrapper does not).
+use std::convert::TryFrom;
+use std::sync::Arc;
+use http::header::{HeaderMap, HeaderName, HeaderValue};
+use self::sealed::{WithDefaultHeader_, WithHeader_, WithHeaders_};
+use crate::filter::{Filter, Map, WrapSealed};
+use crate::reply::Reply;
+/// Wrap a [`Filter`](crate::Filter) that adds a header to the reply.
+///
+/// # Note
+///
+/// This **only** adds a header if the underlying filter is successful, and
+/// returns a [`Reply`](Reply). If the underlying filter was rejected, the
+/// header is not added.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // Always set `foo: bar` header.
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(warp::reply::with::header("foo", "bar"));
+/// ```
+pub fn header<K, V>(name: K, value: V) -> WithHeader
+where
+    HeaderName: TryFrom<K>,
+    <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
+    HeaderValue: TryFrom<V>,
+    <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
+{
+    loop {}
+}
+/// Wrap a [`Filter`](crate::Filter) that adds multiple headers to the reply.
+///
+/// # Note
+///
+/// This **only** adds a header if the underlying filter is successful, and
+/// returns a [`Reply`](Reply). If the underlying filter was rejected, the
+/// header is not added.
+///
+/// # Example
+///
+/// ```
+/// use warp::http::header::{HeaderMap, HeaderValue};
+/// use warp::Filter;
+///
+/// let mut headers = HeaderMap::new();
+/// headers.insert("server", HeaderValue::from_static("wee/0"));
+/// headers.insert("foo", HeaderValue::from_static("bar"));
+///
+/// // Always set `server: wee/0` and `foo: bar` headers.
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(warp::reply::with::headers(headers));
+/// ```
+pub fn headers(headers: HeaderMap) -> WithHeaders {
+    loop {}
+}
+/// Wrap a [`Filter`](crate::Filter) that adds a header to the reply, if they
+/// aren't already set.
+///
+/// # Note
+///
+/// This **only** adds a header if the underlying filter is successful, and
+/// returns a [`Reply`](Reply). If the underlying filter was rejected, the
+/// header is not added.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // Set `server: warp` if not already set.
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(warp::reply::with::default_header("server", "warp"));
+/// ```
+pub fn default_header<K, V>(name: K, value: V) -> WithDefaultHeader
+where
+    HeaderName: TryFrom<K>,
+    <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
+    HeaderValue: TryFrom<V>,
+    <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
+{
+    loop {}
+}
+/// Wrap a `Filter` to always set a header.
+#[derive(Clone, Debug)]
+pub struct WithHeader {
+    name: HeaderName,
+    value: HeaderValue,
+}
+impl<F, R> WrapSealed<F> for WithHeader
+where
+    F: Filter<Extract = (R,)>,
+    R: Reply,
+{
+    type Wrapped = Map<F, WithHeader_>;
+    fn wrap(&self, filter: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+/// Wrap a `Filter` to always set multiple headers.
+#[derive(Clone, Debug)]
+pub struct WithHeaders {
+    headers: Arc<HeaderMap>,
+}
+impl<F, R> WrapSealed<F> for WithHeaders
+where
+    F: Filter<Extract = (R,)>,
+    R: Reply,
+{
+    type Wrapped = Map<F, WithHeaders_>;
+    fn wrap(&self, filter: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+/// Wrap a `Filter` to set a header if it is not already set.
+#[derive(Clone, Debug)]
+pub struct WithDefaultHeader {
+    name: HeaderName,
+    value: HeaderValue,
+}
+impl<F, R> WrapSealed<F> for WithDefaultHeader
+where
+    F: Filter<Extract = (R,)>,
+    R: Reply,
+{
+    type Wrapped = Map<F, WithDefaultHeader_>;
+    fn wrap(&self, filter: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+fn assert_name_and_value<K, V>(name: K, value: V) -> (HeaderName, HeaderValue)
+where
+    HeaderName: TryFrom<K>,
+    <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
+    HeaderValue: TryFrom<V>,
+    <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
+{
+    loop {}
+}
+mod sealed {
+    use super::{WithDefaultHeader, WithHeader, WithHeaders};
+    use crate::generic::{Func, One};
+    use crate::reply::{Reply, Reply_};
+    #[derive(Clone)]
+    #[allow(missing_debug_implementations)]
+    pub struct WithHeader_ {
+        pub(super) with: WithHeader,
+    }
+    impl<R: Reply> Func<One<R>> for WithHeader_ {
+        type Output = Reply_;
+        fn call(&self, args: One<R>) -> Self::Output {
+            loop {}
+        }
+    }
+    #[derive(Clone)]
+    #[allow(missing_debug_implementations)]
+    pub struct WithHeaders_ {
+        pub(super) with: WithHeaders,
+    }
+    impl<R: Reply> Func<One<R>> for WithHeaders_ {
+        type Output = Reply_;
+        fn call(&self, args: One<R>) -> Self::Output {
+            loop {}
+        }
+    }
+    #[derive(Clone)]
+    #[allow(missing_debug_implementations)]
+    pub struct WithDefaultHeader_ {
+        pub(super) with: WithDefaultHeader,
+    }
+    impl<R: Reply> Func<One<R>> for WithDefaultHeader_ {
+        type Output = Reply_;
+        fn call(&self, args: One<R>) -> Self::Output {
+            loop {}
+        }
+    }
+}
diff --git a/warp/src/filters/sse.rs b/warp/src/filters/sse.rs
new file mode 100644
index 0000000..519412a
--- /dev/null
+++ b/warp/src/filters/sse.rs
@@ -0,0 +1,380 @@
+//! Server-Sent Events (SSE)
+//!
+//! # Example
+//!
+//! ```
+//!
+//! use std::time::Duration;
+//! use std::convert::Infallible;
+//! use warp::{Filter, sse::Event};
+//! use futures_util::{stream::iter, Stream};
+//!
+//! fn sse_events() -> impl Stream<Item = Result<Event, Infallible>> {
+//!     iter(vec![
+//!         Ok(Event::default().data("unnamed event")),
+//!         Ok(
+//!             Event::default().event("chat")
+//!             .data("chat message")
+//!         ),
+//!         Ok(
+//!             Event::default().id(13.to_string())
+//!             .event("chat")
+//!             .data("other chat message\nwith next line")
+//!             .retry(Duration::from_millis(5000))
+//!         )
+//!     ])
+//! }
+//!
+//! let app = warp::path("push-notifications")
+//!     .and(warp::get())
+//!     .map(|| {
+//!         warp::sse::reply(warp::sse::keep_alive().stream(sse_events()))
+//!     });
+//! ```
+//!
+//! Each field already is event which can be sent to client.
+//! The events with multiple fields can be created by combining fields using tuples.
+//!
+//! See also the [EventSource](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) API,
+//! which specifies the expected behavior of Server Sent Events.
+//!
+use serde::Serialize;
+use std::borrow::Cow;
+use std::error::Error as StdError;
+use std::fmt::{self, Write};
+
+use std::pin::Pin;
+use std::str::FromStr;
+use std::task::{Context, Poll};
+use std::time::Duration;
+use futures_util::{Stream, TryStream};
+
+
+use pin_project::pin_project;
+use serde_json::{self, Error};
+use tokio::time::{self, Sleep};
+use self::sealed::SseError;
+use super::header;
+use crate::filter::One;
+use crate::reply::Response;
+use crate::{Filter, Rejection, Reply};
+#[derive(Debug)]
+enum DataType {
+    Text(String),
+    Json(String),
+}
+/// Server-sent event
+#[derive(Default, Debug)]
+pub struct Event {
+    id: Option<String>,
+    data: Option<DataType>,
+    event: Option<String>,
+    comment: Option<String>,
+    retry: Option<Duration>,
+}
+impl Event {
+    /// Set Server-sent event data
+    /// data field(s) ("data:<content>")
+    pub fn data<T: Into<String>>(mut self, data: T) -> Event {
+        loop {}
+    }
+    /// Set Server-sent event data
+    /// data field(s) ("data:<content>")
+    pub fn json_data<T: Serialize>(mut self, data: T) -> Result<Event, Error> {
+        loop {}
+    }
+    /// Set Server-sent event comment
+    /// Comment field (":<comment-text>")
+    pub fn comment<T: Into<String>>(mut self, comment: T) -> Event {
+        loop {}
+    }
+    /// Set Server-sent event event
+    /// Event name field ("event:<event-name>")
+    pub fn event<T: Into<String>>(mut self, event: T) -> Event {
+        loop {}
+    }
+    /// Set Server-sent event retry
+    /// Retry timeout field ("retry:<timeout>")
+    pub fn retry(mut self, duration: Duration) -> Event {
+        loop {}
+    }
+    /// Set Server-sent event id
+    /// Identifier field ("id:<identifier>")
+    pub fn id<T: Into<String>>(mut self, id: T) -> Event {
+        loop {}
+    }
+}
+impl fmt::Display for Event {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+/// Gets the optional last event id from request.
+/// Typically this identifier represented as number or string.
+///
+/// ```
+/// let app = warp::sse::last_event_id::<u32>();
+///
+/// // The identifier is present
+/// async {
+///     assert_eq!(
+///         warp::test::request()
+///            .header("Last-Event-ID", "12")
+///            .filter(&app)
+///            .await
+///            .unwrap(),
+///         Some(12)
+///     );
+///
+///     // The identifier is missing
+///     assert_eq!(
+///        warp::test::request()
+///            .filter(&app)
+///            .await
+///            .unwrap(),
+///         None
+///     );
+///
+///     // The identifier is not a valid
+///     assert!(
+///        warp::test::request()
+///            .header("Last-Event-ID", "abc")
+///            .filter(&app)
+///            .await
+///            .is_err(),
+///     );
+///};
+/// ```
+pub fn last_event_id<T>() -> impl Filter<
+    Extract = One<Option<T>>,
+    Error = Rejection,
+> + Copy
+where
+    T: FromStr + Send + Sync + 'static,
+{
+    header::optional("last-event-id")
+}
+/// Server-sent events reply
+///
+/// This function converts stream of server events into a `Reply` with:
+///
+/// - Status of `200 OK`
+/// - Header `content-type: text/event-stream`
+/// - Header `cache-control: no-cache`.
+///
+/// # Example
+///
+/// ```
+///
+/// use std::time::Duration;
+/// use futures_util::Stream;
+/// use futures_util::stream::iter;
+/// use std::convert::Infallible;
+/// use warp::{Filter, sse::Event};
+/// use serde_derive::Serialize;
+///
+/// #[derive(Serialize)]
+/// struct Msg {
+///     from: u32,
+///     text: String,
+/// }
+///
+/// fn event_stream() -> impl Stream<Item = Result<Event, Infallible>> {
+///         iter(vec![
+///             // Unnamed event with data only
+///             Ok(Event::default().data("payload")),
+///             // Named event with ID and retry timeout
+///             Ok(
+///                 Event::default().data("other message\nwith next line")
+///                 .event("chat")
+///                 .id(1.to_string())
+///                 .retry(Duration::from_millis(15000))
+///             ),
+///             // Event with JSON data
+///             Ok(
+///                 Event::default().id(2.to_string())
+///                 .json_data(Msg {
+///                     from: 2,
+///                     text: "hello".into(),
+///                 }).unwrap(),
+///             )
+///         ])
+/// }
+///
+/// async {
+///     let app = warp::path("sse").and(warp::get()).map(|| {
+///        warp::sse::reply(event_stream())
+///     });
+///
+///     let res = warp::test::request()
+///         .method("GET")
+///         .header("Connection", "Keep-Alive")
+///         .path("/sse")
+///         .reply(&app)
+///         .await
+///         .into_body();
+///
+///     assert_eq!(
+///         res,
+///         r#"data:payload
+///
+/// event:chat
+/// data:other message
+/// data:with next line
+/// id:1
+/// retry:15000
+///
+/// data:{"from":2,"text":"hello"}
+/// id:2
+///
+/// "#
+///     );
+/// };
+/// ```
+pub fn reply<S>(event_stream: S) -> impl Reply
+where
+    S: TryStream<Ok = Event> + Send + 'static,
+    S::Error: StdError + Send + Sync + 'static,
+{
+    SseReply { event_stream }
+}
+#[allow(missing_debug_implementations)]
+struct SseReply<S> {
+    event_stream: S,
+}
+impl<S> Reply for SseReply<S>
+where
+    S: TryStream<Ok = Event> + Send + 'static,
+    S::Error: StdError + Send + Sync + 'static,
+{
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+/// Configure the interval between keep-alive messages, the content
+/// of each message, and the associated stream.
+#[derive(Debug)]
+pub struct KeepAlive {
+    comment_text: Cow<'static, str>,
+    max_interval: Duration,
+}
+impl KeepAlive {
+    /// Customize the interval between keep-alive messages.
+    ///
+    /// Default is 15 seconds.
+    pub fn interval(mut self, time: Duration) -> Self {
+        loop {}
+    }
+    /// Customize the text of the keep-alive message.
+    ///
+    /// Default is an empty comment.
+    pub fn text(mut self, text: impl Into<Cow<'static, str>>) -> Self {
+        loop {}
+    }
+    /// Wrap an event stream with keep-alive functionality.
+    ///
+    /// See [`keep_alive`](keep_alive) for more.
+    pub fn stream<S>(
+        self,
+        event_stream: S,
+    ) -> impl TryStream<
+        Ok = Event,
+        Error = impl StdError + Send + Sync + 'static,
+    > + Send + 'static
+    where
+        S: TryStream<Ok = Event> + Send + 'static,
+        S::Error: StdError + Send + Sync + 'static,
+    {
+        let alive_timer = time::sleep(self.max_interval);
+        SseKeepAlive {
+            event_stream,
+            comment_text: self.comment_text,
+            max_interval: self.max_interval,
+            alive_timer,
+        }
+    }
+}
+#[allow(missing_debug_implementations)]
+#[pin_project]
+struct SseKeepAlive<S> {
+    #[pin]
+    event_stream: S,
+    comment_text: Cow<'static, str>,
+    max_interval: Duration,
+    #[pin]
+    alive_timer: Sleep,
+}
+/// Keeps event source connection alive when no events sent over a some time.
+///
+/// Some proxy servers may drop HTTP connection after a some timeout of inactivity.
+/// This function helps to prevent such behavior by sending comment events every
+/// `keep_interval` of inactivity.
+///
+/// By default the comment is `:` (an empty comment) and the time interval between
+/// events is 15 seconds. Both may be customized using the builder pattern
+/// as shown below.
+///
+/// ```
+/// use std::time::Duration;
+/// use std::convert::Infallible;
+/// use futures_util::StreamExt;
+/// use tokio::time::interval;
+/// use tokio_stream::wrappers::IntervalStream;
+/// use warp::{Filter, Stream, sse::Event};
+///
+/// // create server-sent event
+/// fn sse_counter(counter: u64) ->  Result<Event, Infallible> {
+///     Ok(Event::default().data(counter.to_string()))
+/// }
+///
+/// fn main() {
+///     let routes = warp::path("ticks")
+///         .and(warp::get())
+///         .map(|| {
+///             let mut counter: u64 = 0;
+///             let interval = interval(Duration::from_secs(15));
+///             let stream = IntervalStream::new(interval);
+///             let event_stream = stream.map(move |_| {
+///                 counter += 1;
+///                 sse_counter(counter)
+///             });
+///             // reply using server-sent events
+///             let stream = warp::sse::keep_alive()
+///                 .interval(Duration::from_secs(5))
+///                 .text("thump".to_string())
+///                 .stream(event_stream);
+///             warp::sse::reply(stream)
+///         });
+/// }
+/// ```
+///
+/// See [notes](https://www.w3.org/TR/2009/WD-eventsource-20090421/#notes).
+pub fn keep_alive() -> KeepAlive {
+    loop {}
+}
+impl<S> Stream for SseKeepAlive<S>
+where
+    S: TryStream<Ok = Event> + Send + 'static,
+    S::Error: StdError + Send + Sync + 'static,
+{
+    type Item = Result<Event, SseError>;
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {}
+    }
+}
+mod sealed {
+    use super::*;
+    /// SSE error type
+    #[derive(Debug)]
+    pub struct SseError;
+    impl fmt::Display for SseError {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            loop {}
+        }
+    }
+    impl StdError for SseError {}
+}
diff --git a/warp/src/filters/trace.rs b/warp/src/filters/trace.rs
new file mode 100644
index 0000000..5843ed5
--- /dev/null
+++ b/warp/src/filters/trace.rs
@@ -0,0 +1,206 @@
+//! [`tracing`] filters.
+//!
+//! [`tracing`] is a framework for instrumenting Rust programs to
+//! collect scoped, structured, and async-aware diagnostics. This module
+//! provides a set of filters for instrumenting Warp applications with `tracing`
+//! spans. [`Spans`] can be used to associate individual events  with a request,
+//! and track contexts through the application.
+//!
+//! [`tracing`]: https://crates.io/crates/tracing
+//! [`Spans`]: https://docs.rs/tracing/latest/tracing/#spans
+use tracing::Span;
+use std::net::SocketAddr;
+use http::{self};
+use crate::filter::{Filter, WrapSealed};
+use crate::reject::IsReject;
+use crate::reply::Reply;
+use crate::route::Route;
+use self::internal::WithTrace;
+/// Create a wrapping filter that instruments every request with a `tracing`
+/// [`Span`] at the [`INFO`] level, containing a summary of the request.
+/// Additionally, if the [`DEBUG`] level is enabled, the span will contain an
+/// event recording the request's headers.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(warp::trace::request());
+/// ```
+///
+/// [`Span`]: https://docs.rs/tracing/latest/tracing/#spans
+/// [`INFO`]: https://docs.rs/tracing/0.1.16/tracing/struct.Level.html#associatedconstant.INFO
+/// [`DEBUG`]: https://docs.rs/tracing/0.1.16/tracing/struct.Level.html#associatedconstant.DEBUG
+pub fn request() -> Trace<impl Fn(Info<'_>) -> Span + Clone> {
+    trace(|info: Info<'_>| {
+        loop {}
+    })
+}
+/// Create a wrapping filter that instruments every request with a custom
+/// `tracing` [`Span`] provided by a function.
+///
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .with(warp::trace(|info| {
+///         // Create a span using tracing macros
+///         tracing::info_span!(
+///             "request",
+///             method = %info.method(),
+///             path = %info.path(),
+///         )
+///     }));
+/// ```
+///
+/// [`Span`]: https://docs.rs/tracing/latest/tracing/#spans
+pub fn trace<F>(func: F) -> Trace<F>
+where
+    F: Fn(Info<'_>) -> Span + Clone,
+{
+    loop {}
+}
+/// Create a wrapping filter that instruments every request with a `tracing`
+/// [`Span`] at the [`DEBUG`] level representing a named context.
+///
+/// This can be used to instrument multiple routes with their own sub-spans in a
+/// per-request trace.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let hello = warp::path("hello")
+///     .map(warp::reply)
+///     .with(warp::trace::named("hello"));
+///
+/// let goodbye = warp::path("goodbye")
+///     .map(warp::reply)
+///     .with(warp::trace::named("goodbye"));
+///
+/// let routes = hello.or(goodbye);
+/// ```
+///
+/// [`Span`]: https://docs.rs/tracing/latest/tracing/#spans
+/// [`DEBUG`]: https://docs.rs/tracing/0.1.16/tracing/struct.Level.html#associatedconstant.DEBUG
+pub fn named(name: &'static str) -> Trace<impl Fn(Info<'_>) -> Span + Copy> {
+    trace(move |_| tracing::debug_span!("context", "{}", name,))
+}
+/// Decorates a [`Filter`](crate::Filter) to create a [`tracing`] [span] for
+/// requests and responses.
+///
+/// [`tracing`]: https://crates.io/crates/tracing
+/// [span]: https://docs.rs/tracing/latest/tracing/#spans
+#[derive(Clone, Copy, Debug)]
+pub struct Trace<F> {
+    func: F,
+}
+/// Information about the request/response that can be used to prepare log lines.
+#[allow(missing_debug_implementations)]
+pub struct Info<'a> {
+    route: &'a Route,
+}
+impl<FN, F> WrapSealed<F> for Trace<FN>
+where
+    FN: Fn(Info<'_>) -> Span + Clone + Send,
+    F: Filter + Clone + Send,
+    F::Extract: Reply,
+    F::Error: IsReject,
+{
+    type Wrapped = WithTrace<FN, F>;
+    fn wrap(&self, filter: F) -> Self::Wrapped {
+        loop {}
+    }
+}
+impl<'a> Info<'a> {
+    /// View the remote `SocketAddr` of the request.
+    pub fn remote_addr(&self) -> Option<SocketAddr> {
+        loop {}
+    }
+    /// View the `http::Method` of the request.
+    pub fn method(&self) -> &http::Method {
+        loop {}
+    }
+    /// View the URI path of the request.
+    pub fn path(&self) -> &str {
+        loop {}
+    }
+    /// View the `http::Version` of the request.
+    pub fn version(&self) -> http::Version {
+        loop {}
+    }
+    /// View the referer of the request.
+    pub fn referer(&self) -> Option<&str> {
+        loop {}
+    }
+    /// View the user agent of the request.
+    pub fn user_agent(&self) -> Option<&str> {
+        loop {}
+    }
+    /// View the host of the request
+    pub fn host(&self) -> Option<&str> {
+        loop {}
+    }
+    /// View the request headers.
+    pub fn request_headers(&self) -> &http::HeaderMap {
+        loop {}
+    }
+}
+mod internal {
+    use futures_util::{future::Inspect, future::MapOk};
+    use super::{Info, Trace};
+    use crate::filter::{Filter, FilterBase, Internal};
+    use crate::reject::IsReject;
+    use crate::reply::Reply;
+    use crate::reply::Response;
+    
+    #[allow(missing_debug_implementations)]
+    pub struct Traced(pub(super) Response);
+    impl Reply for Traced {
+        #[inline]
+        fn into_response(self) -> Response {
+            loop {}
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    #[derive(Clone, Copy)]
+    pub struct WithTrace<FN, F> {
+        pub(super) filter: F,
+        pub(super) trace: Trace<FN>,
+    }
+    use tracing::instrument::{Instrumented};
+    use tracing::Span;
+    fn finished_logger<E: IsReject>(reply: &Result<(Traced,), E>) {
+        loop {}
+    }
+    fn convert_reply<R: Reply>(reply: R) -> (Traced,) {
+        loop {}
+    }
+    impl<FN, F> FilterBase for WithTrace<FN, F>
+    where
+        FN: Fn(Info<'_>) -> Span + Clone + Send,
+        F: Filter + Clone + Send,
+        F::Extract: Reply,
+        F::Error: IsReject,
+    {
+        type Extract = (Traced,);
+        type Error = F::Error;
+        type Future = Instrumented<
+            Inspect<
+                MapOk<F::Future, fn(F::Extract) -> Self::Extract>,
+                fn(&Result<Self::Extract, F::Error>),
+            >,
+        >;
+        fn filter(&self, _: Internal) -> Self::Future {
+            loop {}
+        }
+    }
+}
diff --git a/warp/src/filters/ws.rs b/warp/src/filters/ws.rs
new file mode 100644
index 0000000..3b10983
--- /dev/null
+++ b/warp/src/filters/ws.rs
@@ -0,0 +1,255 @@
+//! Websockets Filters
+use std::borrow::Cow;
+use std::fmt;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use super::header;
+use crate::filter::{filter_fn_one, Filter, One};
+use crate::reject::Rejection;
+use crate::reply::{Reply, Response};
+use futures_util::{future, ready, FutureExt, Sink, Stream, TryFutureExt};
+use headers::{Connection, HeaderMapExt, SecWebsocketAccept, SecWebsocketKey, Upgrade};
+use http;
+use hyper::upgrade::OnUpgrade;
+use tokio_tungstenite::{
+    tungstenite::protocol::{self, WebSocketConfig},
+    WebSocketStream,
+};
+/// Creates a Websocket Filter.
+///
+/// The yielded `Ws` is used to finish the websocket upgrade.
+///
+/// # Note
+///
+/// This filter combines multiple filters internally, so you don't need them:
+///
+/// - Method must be `GET`
+/// - Header `connection` must be `upgrade`
+/// - Header `upgrade` must be `websocket`
+/// - Header `sec-websocket-version` must be `13`
+/// - Header `sec-websocket-key` must be set.
+///
+/// If the filters are met, yields a `Ws`. Calling `Ws::on_upgrade` will
+/// return a reply with:
+///
+/// - Status of `101 Switching Protocols`
+/// - Header `connection: upgrade`
+/// - Header `upgrade: websocket`
+/// - Header `sec-websocket-accept` with the hash value of the received key.
+pub fn ws() -> impl Filter<Extract = One<Ws>, Error = Rejection> + Copy {
+    loop {}
+}
+/// Extracted by the [`ws`](ws) filter, and used to finish an upgrade.
+pub struct Ws {
+    config: Option<WebSocketConfig>,
+    key: SecWebsocketKey,
+    on_upgrade: Option<OnUpgrade>,
+}
+impl Ws {
+    /// Finish the upgrade, passing a function to handle the `WebSocket`.
+    ///
+    /// The passed function must return a `Future`.
+    pub fn on_upgrade<F, U>(self, func: F) -> impl Reply
+    where
+        F: FnOnce(WebSocket) -> U + Send + 'static,
+        U: Future<Output = ()> + Send + 'static,
+    {
+        loop {}
+    }
+    /// Set the size of the internal message send queue.
+    pub fn max_send_queue(mut self, max: usize) -> Self {
+        loop {}
+    }
+    /// Set the maximum message size (defaults to 64 megabytes)
+    pub fn max_message_size(mut self, max: usize) -> Self {
+        loop {}
+    }
+    /// Set the maximum frame size (defaults to 16 megabytes)
+    pub fn max_frame_size(mut self, max: usize) -> Self {
+        loop {}
+    }
+}
+impl fmt::Debug for Ws {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+#[allow(missing_debug_implementations)]
+struct WsReply<F> {
+    ws: Ws,
+    on_upgrade: F,
+}
+impl<F, U> Reply for WsReply<F>
+where
+    F: FnOnce(WebSocket) -> U + Send + 'static,
+    U: Future<Output = ()> + Send + 'static,
+{
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+fn on_upgrade() -> impl Filter<
+    Extract = (Option<OnUpgrade>,),
+    Error = Rejection,
+> + Copy {
+    loop {}
+}
+/// A websocket `Stream` and `Sink`, provided to `ws` filters.
+///
+/// Ping messages sent from the client will be handled internally by replying with a Pong message.
+/// Close messages need to be handled explicitly: usually by closing the `Sink` end of the
+/// `WebSocket`.
+///
+/// **Note!**
+/// Due to rust futures nature, pings won't be handled until read part of `WebSocket` is polled
+pub struct WebSocket {
+    inner: WebSocketStream<hyper::upgrade::Upgraded>,
+}
+impl WebSocket {
+    pub(crate) async fn from_raw_socket(
+        upgraded: hyper::upgrade::Upgraded,
+        role: protocol::Role,
+        config: Option<protocol::WebSocketConfig>,
+    ) -> Self {
+        loop {}
+    }
+    /// Gracefully close this websocket.
+    pub async fn close(mut self) -> Result<(), crate::Error> {
+        loop {}
+    }
+}
+impl Stream for WebSocket {
+    type Item = Result<Message, crate::Error>;
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {}
+    }
+}
+impl Sink<Message> for WebSocket {
+    type Error = crate::Error;
+    fn poll_ready(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+    fn start_send(mut self: Pin<&mut Self>, item: Message) -> Result<(), Self::Error> {
+        loop {}
+    }
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+    fn poll_close(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+}
+impl fmt::Debug for WebSocket {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+/// A WebSocket message.
+///
+/// This will likely become a `non-exhaustive` enum in the future, once that
+/// language feature has stabilized.
+#[derive(Eq, PartialEq, Clone)]
+pub struct Message {
+    inner: protocol::Message,
+}
+impl Message {
+    /// Construct a new Text `Message`.
+    pub fn text<S: Into<String>>(s: S) -> Message {
+        loop {}
+    }
+    /// Construct a new Binary `Message`.
+    pub fn binary<V: Into<Vec<u8>>>(v: V) -> Message {
+        loop {}
+    }
+    /// Construct a new Ping `Message`.
+    pub fn ping<V: Into<Vec<u8>>>(v: V) -> Message {
+        loop {}
+    }
+    /// Construct a new Pong `Message`.
+    ///
+    /// Note that one rarely needs to manually construct a Pong message because the underlying tungstenite socket
+    /// automatically responds to the Ping messages it receives. Manual construction might still be useful in some cases
+    /// like in tests or to send unidirectional heartbeats.
+    pub fn pong<V: Into<Vec<u8>>>(v: V) -> Message {
+        loop {}
+    }
+    /// Construct the default Close `Message`.
+    pub fn close() -> Message {
+        loop {}
+    }
+    /// Construct a Close `Message` with a code and reason.
+    pub fn close_with(
+        code: impl Into<u16>,
+        reason: impl Into<Cow<'static, str>>,
+    ) -> Message {
+        loop {}
+    }
+    /// Returns true if this message is a Text message.
+    pub fn is_text(&self) -> bool {
+        loop {}
+    }
+    /// Returns true if this message is a Binary message.
+    pub fn is_binary(&self) -> bool {
+        loop {}
+    }
+    /// Returns true if this message a is a Close message.
+    pub fn is_close(&self) -> bool {
+        loop {}
+    }
+    /// Returns true if this message is a Ping message.
+    pub fn is_ping(&self) -> bool {
+        loop {}
+    }
+    /// Returns true if this message is a Pong message.
+    pub fn is_pong(&self) -> bool {
+        loop {}
+    }
+    /// Try to get the close frame (close code and reason)
+    pub fn close_frame(&self) -> Option<(u16, &str)> {
+        loop {}
+    }
+    /// Try to get a reference to the string text, if this is a Text message.
+    pub fn to_str(&self) -> Result<&str, ()> {
+        loop {}
+    }
+    /// Return the bytes of this message, if the message can contain data.
+    pub fn as_bytes(&self) -> &[u8] {
+        loop {}
+    }
+    /// Destructure this message into binary data.
+    pub fn into_bytes(self) -> Vec<u8> {
+        loop {}
+    }
+}
+impl fmt::Debug for Message {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl From<Message> for Vec<u8> {
+    fn from(m: Message) -> Self {
+        loop {}
+    }
+}
+/// Connection header did not include 'upgrade'
+#[derive(Debug)]
+pub struct MissingConnectionUpgrade;
+impl fmt::Display for MissingConnectionUpgrade {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl ::std::error::Error for MissingConnectionUpgrade {}
diff --git a/warp/src/generic.rs b/warp/src/generic.rs
new file mode 100644
index 0000000..a9712fe
--- /dev/null
+++ b/warp/src/generic.rs
@@ -0,0 +1,144 @@
+#[derive(Debug)]
+pub struct Product<H, T: HList>(pub(crate) H, pub(crate) T);
+pub type One<T> = (T,);
+#[inline]
+pub(crate) fn one<T>(val: T) -> One<T> {
+    loop {}
+}
+#[derive(Debug)]
+pub enum Either<T, U> {
+    A(T),
+    B(U),
+}
+pub trait HList: Sized {
+    type Tuple: Tuple<HList = Self>;
+    fn flatten(self) -> Self::Tuple;
+}
+pub trait Tuple: Sized {
+    type HList: HList<Tuple = Self>;
+    fn hlist(self) -> Self::HList;
+    #[inline]
+    fn combine<T>(self, other: T) -> CombinedTuples<Self, T>
+    where
+        Self: Sized,
+        T: Tuple,
+        Self::HList: Combine<T::HList>,
+    {
+        loop {}
+    }
+}
+pub type CombinedTuples<T, U> = <<<T as Tuple>::HList as Combine<
+    <U as Tuple>::HList,
+>>::Output as HList>::Tuple;
+pub trait Combine<T: HList> {
+    type Output: HList;
+    fn combine(self, other: T) -> Self::Output;
+}
+pub trait Func<Args> {
+    type Output;
+    fn call(&self, args: Args) -> Self::Output;
+}
+impl<T: HList> Combine<T> for () {
+    type Output = T;
+    #[inline]
+    fn combine(self, other: T) -> Self::Output {
+        loop {}
+    }
+}
+impl<H, T: HList, U: HList> Combine<U> for Product<H, T>
+where
+    T: Combine<U>,
+    Product<H, <T as Combine<U>>::Output>: HList,
+{
+    type Output = Product<H, <T as Combine<U>>::Output>;
+    #[inline]
+    fn combine(self, other: U) -> Self::Output {
+        loop {}
+    }
+}
+impl HList for () {
+    type Tuple = ();
+    #[inline]
+    fn flatten(self) -> Self::Tuple {}
+}
+impl Tuple for () {
+    type HList = ();
+    #[inline]
+    fn hlist(self) -> Self::HList {}
+}
+impl<F, R> Func<()> for F
+where
+    F: Fn() -> R,
+{
+    type Output = R;
+    #[inline]
+    fn call(&self, _args: ()) -> Self::Output {
+        loop {}
+    }
+}
+impl<F, R> Func<crate::Rejection> for F
+where
+    F: Fn(crate::Rejection) -> R,
+{
+    type Output = R;
+    #[inline]
+    fn call(&self, arg: crate::Rejection) -> Self::Output {
+        loop {}
+    }
+}
+macro_rules! product {
+    ($H:expr) => {
+        Product($H, ())
+    };
+    ($H:expr, $($T:expr),*) => {
+        Product($H, product!($($T),*))
+    };
+}
+macro_rules! Product {
+    ($H:ty) => {
+        Product <$H, () >
+    };
+    ($H:ty, $($T:ty),*) => {
+        Product <$H, Product!($($T),*) >
+    };
+}
+macro_rules! product_pat {
+    ($H:pat) => {
+        Product($H, ())
+    };
+    ($H:pat, $($T:pat),*) => {
+        Product($H, product_pat!($($T),*))
+    };
+}
+macro_rules! generics {
+    ($type:ident) => {
+        impl <$type > HList for Product!($type) { type Tuple = ($type,); #[inline] fn
+        flatten(self) -> Self::Tuple { (self.0,) } } impl <$type > Tuple for ($type,) {
+        type HList = Product!($type); #[inline] fn hlist(self) -> Self::HList {
+        product!(self.0) } } impl < F, R, $type > Func < Product!($type) > for F where F
+        : Fn($type) -> R, { type Output = R; #[inline] fn call(& self, args :
+        Product!($type)) -> Self::Output { (* self) (args.0) } } impl < F, R, $type >
+        Func < ($type,) > for F where F : Fn($type) -> R, { type Output = R; #[inline] fn
+        call(& self, args : ($type,)) -> Self::Output { (* self) (args.0) } }
+    };
+    ($type1:ident, $($type:ident),*) => {
+        generics!($($type),*); impl <$type1, $($type),*> HList for Product!($type1,
+        $($type),*) { type Tuple = ($type1, $($type),*); #[inline] fn flatten(self) ->
+        Self::Tuple { #[allow(non_snake_case)] let product_pat!($type1, $($type),*) =
+        self; ($type1, $($type),*) } } impl <$type1, $($type),*> Tuple for ($type1,
+        $($type),*) { type HList = Product!($type1, $($type),*); #[inline] fn hlist(self)
+        -> Self::HList { #[allow(non_snake_case)] let ($type1, $($type),*) = self;
+        product!($type1, $($type),*) } } impl < F, R, $type1, $($type),*> Func <
+        Product!($type1, $($type),*) > for F where F : Fn($type1, $($type),*) -> R, {
+        type Output = R; #[inline] fn call(& self, args : Product!($type1, $($type),*))
+        -> Self::Output { #[allow(non_snake_case)] let product_pat!($type1, $($type),*) =
+        args; (* self) ($type1, $($type),*) } } impl < F, R, $type1, $($type),*> Func <
+        ($type1, $($type),*) > for F where F : Fn($type1, $($type),*) -> R, { type Output
+        = R; #[inline] fn call(& self, args : ($type1, $($type),*)) -> Self::Output {
+        #[allow(non_snake_case)] let ($type1, $($type),*) = args; (* self) ($type1,
+        $($type),*) } }
+    };
+}
+generics! {
+    T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16
+}
diff --git a/warp/src/lib.rs b/warp/src/lib.rs
new file mode 100644
index 0000000..a965b1d
--- /dev/null
+++ b/warp/src/lib.rs
@@ -0,0 +1,179 @@
+#![doc(html_root_url = "https://docs.rs/warp/0.3.3")]
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![deny(rust_2018_idioms)]
+#![cfg_attr(test, deny(warnings))]
+
+//! # warp
+//!
+//! warp is a super-easy, composable, web server framework for warp speeds.
+//!
+//! Thanks to its [`Filter`][Filter] system, warp provides these out of the box:
+//!
+//! - Path routing and parameter extraction
+//! - Header requirements and extraction
+//! - Query string deserialization
+//! - JSON and Form bodies
+//! - Multipart form data
+//! - Static Files and Directories
+//! - Websockets
+//! - Access logging
+//! - Etc
+//!
+//! Since it builds on top of [hyper](https://hyper.rs), you automatically get:
+//!
+//! - HTTP/1
+//! - HTTP/2
+//! - Asynchronous
+//! - One of the fastest HTTP implementations
+//! - Tested and **correct**
+//!
+//! ## Filters
+//!
+//! The main concept in warp is the [`Filter`][Filter], which allows composition
+//! to describe various endpoints in your web service. Besides this powerful
+//! trait, warp comes with several built in [filters](filters/index.html), which
+//! can be combined for your specific needs.
+//!
+//! As a small example, consider an endpoint that has path and header requirements:
+//!
+//! ```
+//! use warp::Filter;
+//!
+//! let hi = warp::path("hello")
+//!     .and(warp::path::param())
+//!     .and(warp::header("user-agent"))
+//!     .map(|param: String, agent: String| {
+//!         format!("Hello {}, whose agent is {}", param, agent)
+//!     });
+//! ```
+//!
+//! This example composes several [`Filter`s][Filter] together using `and`:
+//!
+//! - A path prefix of "hello"
+//! - A path parameter of a `String`
+//! - The `user-agent` header parsed as a `String`
+//!
+//! These specific filters will [`reject`][reject] requests that don't match
+//! their requirements.
+//!
+//! This ends up matching requests like:
+//!
+//! ```notrust
+//! GET /hello/sean HTTP/1.1
+//! Host: hyper.rs
+//! User-Agent: reqwest/v0.8.6
+//!
+//! ```
+//! And it returns a response similar to this:
+//!
+//! ```notrust
+//! HTTP/1.1 200 OK
+//! Content-Length: 41
+//! Date: ...
+//!
+//! Hello sean, whose agent is reqwest/v0.8.6
+//! ```
+//!
+//! Take a look at the full list of [`filters`](filters/index.html) to see what
+//! you can build.
+//!
+//! ## Testing
+//!
+//! Testing your web services easily is extremely important, and warp provides
+//! a [`test`](self::test) module to help send mocked requests through your service.
+//!
+//! [Filter]: trait.Filter.html
+//! [reject]: reject/index.html
+
+#[macro_use]
+mod error;
+mod filter;
+pub mod filters;
+mod generic;
+pub mod redirect;
+pub mod reject;
+pub mod reply;
+mod route;
+mod server;
+mod service;
+pub mod test;
+#[cfg(feature = "tls")]
+mod tls;
+mod transport;
+
+pub use self::error::Error;
+pub use self::filter::Filter;
+// This otherwise shows a big dump of re-exports in the doc homepage,
+// with zero context, so just hide it from the docs. Doc examples
+// on each can show that a convenient import exists.
+#[cfg(feature = "compression")]
+#[doc(hidden)]
+pub use self::filters::compression;
+#[cfg(feature = "multipart")]
+#[doc(hidden)]
+pub use self::filters::multipart;
+#[cfg(feature = "websocket")]
+#[doc(hidden)]
+pub use self::filters::ws;
+#[doc(hidden)]
+pub use self::filters::{
+    addr,
+    // any() function
+    any::any,
+    body,
+    cookie,
+    // cookie() function
+    cookie::cookie,
+    cors,
+    // cors() function
+    cors::cors,
+    ext,
+    fs,
+    header,
+    // header() function
+    header::header,
+    host,
+    log,
+    // log() function
+    log::log,
+    method::{delete, get, head, method, options, patch, post, put},
+    path,
+    // path() function and macro
+    path::path,
+    query,
+    // query() function
+    query::query,
+    sse,
+    trace,
+    // trace() function
+    trace::trace,
+};
+// ws() function
+pub use self::filter::wrap_fn;
+#[cfg(feature = "websocket")]
+#[doc(hidden)]
+pub use self::filters::ws::ws;
+#[doc(hidden)]
+pub use self::redirect::redirect;
+#[doc(hidden)]
+#[allow(deprecated)]
+pub use self::reject::{reject, Rejection};
+#[doc(hidden)]
+pub use self::reply::{reply, Reply};
+#[cfg(feature = "tls")]
+pub use self::server::TlsServer;
+pub use self::server::{serve, Server};
+pub use self::service::service;
+#[doc(hidden)]
+pub use http;
+#[doc(hidden)]
+pub use hyper;
+
+#[doc(hidden)]
+pub use bytes::Buf;
+#[doc(hidden)]
+pub use futures_util::{Future, Sink, Stream};
+#[doc(hidden)]
+
+pub(crate) type Request = http::Request<hyper::Body>;
diff --git a/warp/src/redirect.rs b/warp/src/redirect.rs
new file mode 100644
index 0000000..4fd5423
--- /dev/null
+++ b/warp/src/redirect.rs
@@ -0,0 +1,120 @@
+//! Redirect requests to a new location.
+//!
+//! The types in this module are helpers that implement [`Reply`](Reply), and easy
+//! to use in order to setup redirects.
+use http::{header, StatusCode};
+pub use self::sealed::AsLocation;
+use crate::reply::{self, Reply};
+/// A simple `301` permanent redirect to a different location.
+///
+/// # Example
+///
+/// ```
+/// use warp::{http::Uri, Filter};
+///
+/// let route = warp::path("v1")
+///     .map(|| {
+///         warp::redirect(Uri::from_static("/v2"))
+///     });
+/// ```
+pub fn redirect(uri: impl AsLocation) -> impl Reply {
+    reply::with_header(
+        StatusCode::MOVED_PERMANENTLY,
+        header::LOCATION,
+        uri.header_value(),
+    )
+}
+/// A simple `302` found redirect to a different location
+///
+/// # Example
+///
+/// ```
+/// use warp::{http::Uri, Filter};
+///
+/// let route = warp::path("v1")
+///     .map(|| {
+///         warp::redirect::found(Uri::from_static("/v2"))
+///     });
+/// ```
+pub fn found(uri: impl AsLocation) -> impl Reply {
+    reply::with_header(StatusCode::FOUND, header::LOCATION, uri.header_value())
+}
+/// A simple `303` redirect to a different location.
+///
+/// The HTTP method of the request to the new location will always be `GET`.
+///
+/// # Example
+///
+/// ```
+/// use warp::{http::Uri, Filter};
+///
+/// let route = warp::path("v1")
+///     .map(|| {
+///         warp::redirect::see_other(Uri::from_static("/v2"))
+///     });
+/// ```
+pub fn see_other(uri: impl AsLocation) -> impl Reply {
+    reply::with_header(StatusCode::SEE_OTHER, header::LOCATION, uri.header_value())
+}
+/// A simple `307` temporary redirect to a different location.
+///
+/// This is similar to [`see_other`](fn@see_other) but the HTTP method and the body of the request
+/// to the new location will be the same as the method and body of the current request.
+///
+/// # Example
+///
+/// ```
+/// use warp::{http::Uri, Filter};
+///
+/// let route = warp::path("v1")
+///     .map(|| {
+///         warp::redirect::temporary(Uri::from_static("/v2"))
+///     });
+/// ```
+pub fn temporary(uri: impl AsLocation) -> impl Reply {
+    reply::with_header(
+        StatusCode::TEMPORARY_REDIRECT,
+        header::LOCATION,
+        uri.header_value(),
+    )
+}
+/// A simple `308` permanent redirect to a different location.
+///
+/// This is similar to [`redirect`](fn@redirect) but the HTTP method of the request to the new
+/// location will be the same as the method of the current request.
+///
+/// # Example
+///
+/// ```
+/// use warp::{http::Uri, Filter};
+///
+/// let route = warp::path("v1")
+///     .map(|| {
+///         warp::redirect::permanent(Uri::from_static("/v2"))
+///     });
+/// ```
+pub fn permanent(uri: impl AsLocation) -> impl Reply {
+    reply::with_header(
+        StatusCode::PERMANENT_REDIRECT,
+        header::LOCATION,
+        uri.header_value(),
+    )
+}
+mod sealed {
+    
+    use http::{header::HeaderValue, Uri};
+    /// Trait for redirect locations. Currently only a `Uri` can be used in
+    /// redirect.
+    /// This sealed trait exists to allow adding possibly new impls so other
+    /// arguments could be accepted, like maybe just `warp::redirect("/v2")`.
+    pub trait AsLocation: Sealed {}
+    pub trait Sealed {
+        fn header_value(self) -> HeaderValue;
+    }
+    impl AsLocation for Uri {}
+    impl Sealed for Uri {
+        fn header_value(self) -> HeaderValue {
+            loop {}
+        }
+    }
+}
diff --git a/warp/src/reject.rs b/warp/src/reject.rs
new file mode 100644
index 0000000..d75069d
--- /dev/null
+++ b/warp/src/reject.rs
@@ -0,0 +1,452 @@
+//! Rejections
+//!
+//! Part of the power of the [`Filter`](../trait.Filter.html) system is being able to
+//! reject a request from a filter chain. This allows for filters to be
+//! combined with `or`, so that if one side of the chain finds that a request
+//! doesn't fulfill its requirements, the other side can try to process
+//! the request.
+//!
+//! Many of the built-in [`filters`](../filters) will automatically reject
+//! the request with an appropriate rejection. However, you can also build
+//! new custom [`Filter`](../trait.Filter.html)s and still want other routes to be
+//! matchable in the case a predicate doesn't hold.
+//!
+//! As a request is processed by a Filter chain, the rejections are accumulated into
+//! a list contained by the [`Rejection`](struct.Rejection.html) type. Rejections from
+//! filters can be handled using [`Filter::recover`](../trait.Filter.html#method.recover).
+//! This is a convenient way to map rejections into a [`Reply`](../reply/trait.Reply.html).
+//!
+//! For a more complete example see the
+//! [Rejection Example](https://github.com/seanmonstar/warp/blob/master/examples/rejections.rs)
+//! from the repository.
+//!
+//! # Example
+//!
+//! ```
+//! use warp::{reply, Reply, Filter, reject, Rejection, http::StatusCode};
+//!
+//! #[derive(Debug)]
+//! struct InvalidParameter;
+//!
+//! impl reject::Reject for InvalidParameter {}
+//!
+//! // Custom rejection handler that maps rejections into responses.
+//! async fn handle_rejection(err: Rejection) -> Result<impl Reply, std::convert::Infallible> {
+//!     if err.is_not_found() {
+//!         Ok(reply::with_status("NOT_FOUND", StatusCode::NOT_FOUND))
+//!     } else if let Some(e) = err.find::<InvalidParameter>() {
+//!         Ok(reply::with_status("BAD_REQUEST", StatusCode::BAD_REQUEST))
+//!     } else {
+//!         eprintln!("unhandled rejection: {:?}", err);
+//!         Ok(reply::with_status("INTERNAL_SERVER_ERROR", StatusCode::INTERNAL_SERVER_ERROR))
+//!     }
+//! }
+//!
+//!
+//! // Filter on `/:id`, but reject with InvalidParameter if the `id` is `0`.
+//! // Recover from this rejection using a custom rejection handler.
+//! let route = warp::path::param()
+//!     .and_then(|id: u32| async move {
+//!         if id == 0 {
+//!             Err(warp::reject::custom(InvalidParameter))
+//!         } else {
+//!             Ok("id is valid")
+//!         }
+//!     })
+//!     .recover(handle_rejection);
+//! ```
+use std::any::Any;
+use std::convert::Infallible;
+use std::error::Error as StdError;
+use std::fmt;
+use http::{self, StatusCode};
+pub(crate) use self::sealed::{CombineRejection, IsReject};
+/// Rejects a request with `404 Not Found`.
+#[inline]
+pub fn reject() -> Rejection {
+    loop {}
+}
+/// Rejects a request with `404 Not Found`.
+#[inline]
+pub fn not_found() -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn invalid_query() -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn missing_header(name: &'static str) -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn invalid_header(name: &'static str) -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn missing_cookie(name: &'static str) -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn method_not_allowed() -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn length_required() -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn payload_too_large() -> Rejection {
+    loop {}
+}
+#[inline]
+pub(crate) fn unsupported_media_type() -> Rejection {
+    loop {}
+}
+/// Rejects a request with a custom cause.
+///
+/// A [`recover`][] filter should convert this `Rejection` into a `Reply`,
+/// or else this will be returned as a `500 Internal Server Error`.
+///
+/// [`recover`]: ../trait.Filter.html#method.recover
+pub fn custom<T: Reject>(err: T) -> Rejection {
+    loop {}
+}
+/// Protect against re-rejecting a rejection.
+///
+/// ```compile_fail
+/// fn with(r: warp::Rejection) {
+///     let _wat = warp::reject::custom(r);
+/// }
+/// ```
+fn __reject_custom_compilefail() {}
+/// A marker trait to ensure proper types are used for custom rejections.
+///
+/// Can be converted into Rejection.
+///
+/// # Example
+///
+/// ```
+/// use warp::{Filter, reject::Reject};
+///
+/// #[derive(Debug)]
+/// struct RateLimited;
+///
+/// impl Reject for RateLimited {}
+///
+/// let route = warp::any().and_then(|| async {
+///     Err::<(), _>(warp::reject::custom(RateLimited))
+/// });
+/// ```
+pub trait Reject: fmt::Debug + Sized + Send + Sync + 'static {}
+trait Cause: fmt::Debug + Send + Sync + 'static {
+    fn as_any(&self) -> &dyn Any;
+}
+impl<T> Cause for T
+where
+    T: fmt::Debug + Send + Sync + 'static,
+{
+    fn as_any(&self) -> &dyn Any {
+        loop {}
+    }
+}
+impl dyn Cause {}
+pub(crate) fn known<T: Into<Known>>(err: T) -> Rejection {
+    loop {}
+}
+/// Rejection of a request by a [`Filter`](crate::Filter).
+///
+/// See the [`reject`](module@crate::reject) documentation for more.
+pub struct Rejection {
+    reason: Reason,
+}
+enum Reason {
+    NotFound,
+    Other(Box<Rejections>),
+}
+enum Rejections {
+    Known(Known),
+    Custom(Box<dyn Cause>),
+    Combined(Box<Rejections>, Box<Rejections>),
+}
+macro_rules! enum_known {
+    ($($(#[$attr:meta])* $var:ident ($ty:path),)+) => {
+        pub (crate) enum Known { $($(#[$attr])* $var ($ty),)+ } impl Known { fn
+        inner_as_any(& self) -> & dyn Any { match * self { $($(#[$attr])* Known::$var
+        (ref t) => t,)+ } } } impl fmt::Debug for Known { fn fmt(& self, f : & mut
+        fmt::Formatter <'_ >) -> fmt::Result { match * self { $($(#[$attr])* Known::$var
+        (ref t) => t.fmt(f),)+ } } } impl fmt::Display for Known { fn fmt(& self, f : &
+        mut fmt::Formatter <'_ >) -> fmt::Result { match * self { $($(#[$attr])*
+        Known::$var (ref t) => t.fmt(f),)+ } } } $(#[doc(hidden)] $(#[$attr])* impl From
+        <$ty > for Known { fn from(ty : $ty) -> Known { Known::$var (ty) } })+
+    };
+}
+enum_known! {
+    MethodNotAllowed(MethodNotAllowed), InvalidHeader(InvalidHeader),
+    MissingHeader(MissingHeader), MissingCookie(MissingCookie),
+    InvalidQuery(InvalidQuery), LengthRequired(LengthRequired),
+    PayloadTooLarge(PayloadTooLarge), UnsupportedMediaType(UnsupportedMediaType),
+    FileOpenError(crate ::fs::FileOpenError), FilePermissionError(crate
+    ::fs::FilePermissionError), BodyReadError(crate ::body::BodyReadError),
+    BodyDeserializeError(crate ::body::BodyDeserializeError), CorsForbidden(crate
+    ::cors::CorsForbidden), #[cfg(feature = "websocket")] MissingConnectionUpgrade(crate
+    ::ws::MissingConnectionUpgrade), MissingExtension(crate ::ext::MissingExtension),
+    BodyConsumedMultipleTimes(crate ::body::BodyConsumedMultipleTimes),
+}
+impl Rejection {
+    /// Searches this `Rejection` for a specific cause.
+    ///
+    /// A `Rejection` will accumulate causes over a `Filter` chain. This method
+    /// can search through them and return the first cause of this type.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// #[derive(Debug)]
+    /// struct Nope;
+    ///
+    /// impl warp::reject::Reject for Nope {}
+    ///
+    /// let reject = warp::reject::custom(Nope);
+    ///
+    /// if let Some(nope) = reject.find::<Nope>() {
+    ///    println!("found it: {:?}", nope);
+    /// }
+    /// ```
+    pub fn find<T: 'static>(&self) -> Option<&T> {
+        loop {}
+    }
+    /// Returns true if this Rejection was made via `warp::reject::not_found`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let rejection = warp::reject();
+    ///
+    /// assert!(rejection.is_not_found());
+    /// ```
+    pub fn is_not_found(&self) -> bool {
+        loop {}
+    }
+}
+impl<T: Reject> From<T> for Rejection {
+    #[inline]
+    fn from(err: T) -> Rejection {
+        loop {}
+    }
+}
+impl From<Infallible> for Rejection {
+    #[inline]
+    fn from(infallible: Infallible) -> Rejection {
+        loop {}
+    }
+}
+impl IsReject for Infallible {
+    fn status(&self) -> StatusCode {
+        loop {}
+    }
+    fn into_response(&self) -> crate::reply::Response {
+        loop {}
+    }
+}
+impl IsReject for Rejection {
+    fn status(&self) -> StatusCode {
+        loop {}
+    }
+    fn into_response(&self) -> crate::reply::Response {
+        loop {}
+    }
+}
+impl fmt::Debug for Rejection {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl fmt::Debug for Reason {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl Rejections {}
+unit_error! {
+    #[doc = " Invalid query"] pub InvalidQuery : "Invalid query string"
+}
+unit_error! {
+    #[doc = " HTTP method not allowed"] pub MethodNotAllowed : "HTTP method not allowed"
+}
+unit_error! {
+    #[doc = " A content-length header is required"] pub LengthRequired :
+    "A content-length header is required"
+}
+unit_error! {
+    #[doc = " The request payload is too large"] pub PayloadTooLarge :
+    "The request payload is too large"
+}
+unit_error! {
+    #[doc = " The request's content-type is not supported"] pub UnsupportedMediaType :
+    "The request's content-type is not supported"
+}
+/// Missing request header
+#[derive(Debug)]
+pub struct MissingHeader {
+    name: &'static str,
+}
+impl MissingHeader {
+    /// Retrieve the name of the header that was missing
+    pub fn name(&self) -> &str {
+        loop {}
+    }
+}
+impl fmt::Display for MissingHeader {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for MissingHeader {}
+/// Invalid request header
+#[derive(Debug)]
+pub struct InvalidHeader {
+    name: &'static str,
+}
+impl InvalidHeader {
+    /// Retrieve the name of the header that was invalid
+    pub fn name(&self) -> &str {
+        loop {}
+    }
+}
+impl fmt::Display for InvalidHeader {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for InvalidHeader {}
+/// Missing cookie
+#[derive(Debug)]
+pub struct MissingCookie {
+    name: &'static str,
+}
+impl MissingCookie {
+    /// Retrieve the name of the cookie that was missing
+    pub fn name(&self) -> &str {
+        loop {}
+    }
+}
+impl fmt::Display for MissingCookie {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for MissingCookie {}
+mod sealed {
+    use super::Rejection;
+    use http::StatusCode;
+    use std::convert::Infallible;
+    use std::fmt;
+    pub trait IsReject: fmt::Debug + Send + Sync {
+        fn status(&self) -> StatusCode;
+        fn into_response(&self) -> crate::reply::Response;
+    }
+    fn _assert_object_safe() {
+        loop {}
+    }
+    pub trait CombineRejection<E>: Send + Sized {
+        /// The type that should be returned when only 1 of the two
+        /// "rejections" occurs.
+        ///
+        /// # For example:
+        ///
+        /// `warp::any().and(warp::path("foo"))` has the following steps:
+        ///
+        /// 1. Since this is `and`, only **one** of the rejections will occur,
+        ///    and as soon as it does, it will be returned.
+        /// 2. `warp::any()` rejects with `Never`. So, it will never return `Never`.
+        /// 3. `warp::path()` rejects with `Rejection`. It may return `Rejection`.
+        ///
+        /// Thus, if the above filter rejects, it will definitely be `Rejection`.
+        type One: IsReject + From<Self> + From<E> + Into<Rejection>;
+        /// The type that should be returned when both rejections occur,
+        /// and need to be combined.
+        type Combined: IsReject;
+        fn combine(self, other: E) -> Self::Combined;
+    }
+    impl CombineRejection<Rejection> for Rejection {
+        type One = Rejection;
+        type Combined = Rejection;
+        fn combine(self, other: Rejection) -> Self::Combined {
+            loop {}
+        }
+    }
+    impl CombineRejection<Infallible> for Rejection {
+        type One = Rejection;
+        type Combined = Infallible;
+        fn combine(self, other: Infallible) -> Self::Combined {
+            loop {}
+        }
+    }
+    impl CombineRejection<Rejection> for Infallible {
+        type One = Rejection;
+        type Combined = Infallible;
+        fn combine(self, _: Rejection) -> Self::Combined {
+            loop {}
+        }
+    }
+    impl CombineRejection<Infallible> for Infallible {
+        type One = Infallible;
+        type Combined = Infallible;
+        fn combine(self, _: Infallible) -> Self::Combined {
+            loop {}
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::StatusCode;
+    #[derive(Debug, PartialEq)]
+    struct Left;
+    #[derive(Debug, PartialEq)]
+    struct Right;
+    impl Reject for Left {}
+    impl Reject for Right {}
+    #[test]
+    fn rejection_status() {
+        loop {}
+    }
+    #[tokio::test]
+    async fn combine_rejection_causes_with_some_left_and_none_right() {
+        loop {}
+    }
+    #[tokio::test]
+    async fn combine_rejection_causes_with_none_left_and_some_right() {
+        loop {}
+    }
+    #[tokio::test]
+    async fn unhandled_customs() {
+        loop {}
+    }
+    async fn response_body_string(resp: crate::reply::Response) -> String {
+        loop {}
+    }
+    #[test]
+    fn find_cause() {
+        loop {}
+    }
+    #[test]
+    fn size_of_rejection() {
+        loop {}
+    }
+    #[derive(Debug)]
+    struct X(u32);
+    impl Reject for X {}
+    fn combine_n<F, R>(n: u32, new_reject: F) -> Rejection
+    where
+        F: Fn(u32) -> R,
+        R: Reject,
+    {
+        loop {}
+    }
+    #[test]
+    fn test_debug() {
+        loop {}
+    }
+}
diff --git a/warp/src/reply.rs b/warp/src/reply.rs
new file mode 100644
index 0000000..e91d8d4
--- /dev/null
+++ b/warp/src/reply.rs
@@ -0,0 +1,388 @@
+//! Reply to requests.
+//!
+//! A [`Reply`](./trait.Reply.html) is a type that can be converted into an HTTP
+//! response to be sent to the client. These are typically the successful
+//! counterpart to a [rejection](../reject).
+//!
+//! The functions in this module are helpers for quickly creating a reply.
+//! Besides them, you can return a type that implements [`Reply`](./trait.Reply.html). This
+//! could be any of the following:
+//!
+//! - [`http::Response<impl Into<hyper::Body>>`](https://docs.rs/http)
+//! - `String`
+//! - `&'static str`
+//! - `http::StatusCode`
+//!
+//! # Example
+//!
+//! ```
+//! use warp::{Filter, http::Response};
+//!
+//! // Returns an empty `200 OK` response.
+//! let empty_200 = warp::any().map(warp::reply);
+//!
+//! // Returns a `200 OK` response with custom header and body.
+//! let custom = warp::any().map(|| {
+//!     Response::builder()
+//!         .header("my-custom-header", "some-value")
+//!         .body("and a custom body")
+//! });
+//!
+//! // GET requests return the empty 200, POST return the custom.
+//! let routes = warp::get().and(empty_200)
+//!     .or(warp::post().and(custom));
+//! ```
+use std::borrow::Cow;
+use std::convert::TryFrom;
+use std::error::Error as StdError;
+use std::fmt;
+use crate::generic::{Either, One};
+use http::header::{HeaderName, HeaderValue};
+use http::StatusCode;
+use hyper::Body;
+use serde::Serialize;
+pub(crate) use self::sealed::Reply_;
+use self::sealed::BoxedReply;
+#[doc(hidden)]
+pub use crate::filters::reply as with;
+/// Response type into which types implementing the `Reply` trait are convertable.
+pub type Response = ::http::Response<Body>;
+/// Returns an empty `Reply` with status code `200 OK`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // GET /just-ok returns an empty `200 OK`.
+/// let route = warp::path("just-ok")
+///     .map(|| {
+///         println!("got a /just-ok request!");
+///         warp::reply()
+///     });
+/// ```
+#[inline]
+pub fn reply() -> impl Reply {
+    StatusCode::OK
+}
+/// Convert the value into a `Reply` with the value encoded as JSON.
+///
+/// The passed value must implement [`Serialize`][ser]. Many
+/// collections do, and custom domain types can have `Serialize` derived.
+///
+/// [ser]: https://serde.rs
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// // GET /ids returns a `200 OK` with a JSON array of ids:
+/// // `[1, 3, 7, 13]`
+/// let route = warp::path("ids")
+///     .map(|| {
+///         let our_ids = vec![1, 3, 7, 13];
+///         warp::reply::json(&our_ids)
+///     });
+/// ```
+///
+/// # Note
+///
+/// If a type fails to be serialized into JSON, the error is logged at the
+/// `error` level, and the returned `impl Reply` will be an empty
+/// `500 Internal Server Error` response.
+pub fn json<T>(val: &T) -> Json
+where
+    T: Serialize,
+{
+    loop {}
+}
+/// A JSON formatted reply.
+#[allow(missing_debug_implementations)]
+pub struct Json {
+    inner: Result<Vec<u8>, ()>,
+}
+impl Reply for Json {
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+#[derive(Debug)]
+pub(crate) struct ReplyJsonError;
+impl fmt::Display for ReplyJsonError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for ReplyJsonError {}
+/// Reply with a body and `content-type` set to `text/html; charset=utf-8`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let body = r#"
+/// <html>
+///     <head>
+///         <title>HTML with warp!</title>
+///     </head>
+///     <body>
+///         <h1>warp + HTML = &hearts;</h1>
+///     </body>
+/// </html>
+/// "#;
+///
+/// let route = warp::any()
+///     .map(move || {
+///         warp::reply::html(body)
+///     });
+/// ```
+pub fn html<T>(body: T) -> Html<T>
+where
+    Body: From<T>,
+    T: Send,
+{
+    loop {}
+}
+/// An HTML reply.
+#[allow(missing_debug_implementations)]
+pub struct Html<T> {
+    body: T,
+}
+impl<T> Reply for Html<T>
+where
+    Body: From<T>,
+    T: Send,
+{
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+/// Types that can be converted into a `Response`.
+///
+/// This trait is implemented for the following:
+///
+/// - `http::StatusCode`
+/// - `http::Response<impl Into<hyper::Body>>`
+/// - `String`
+/// - `&'static str`
+///
+/// # Example
+///
+/// ```rust
+/// use warp::{Filter, http::Response};
+///
+/// struct Message {
+///     msg: String
+/// }
+///
+/// impl warp::Reply for Message {
+///     fn into_response(self) -> warp::reply::Response {
+///         Response::new(format!("message: {}", self.msg).into())
+///     }
+/// }
+///
+/// fn handler() -> Message {
+///     Message { msg: "Hello".to_string() }
+/// }
+///
+/// let route = warp::any().map(handler);
+/// ```
+pub trait Reply: BoxedReply + Send {
+    /// Converts the given value into a [`Response`].
+    ///
+    /// [`Response`]: type.Response.html
+    fn into_response(self) -> Response;
+}
+impl<T: Reply + ?Sized> Reply for Box<T> {
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+fn _assert_object_safe() {
+    loop {}
+}
+/// Wrap an `impl Reply` to change its `StatusCode`.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .map(|reply| {
+///         warp::reply::with_status(reply, warp::http::StatusCode::CREATED)
+///     });
+/// ```
+pub fn with_status<T: Reply>(reply: T, status: StatusCode) -> WithStatus<T> {
+    loop {}
+}
+/// Wrap an `impl Reply` to change its `StatusCode`.
+///
+/// Returned by `warp::reply::with_status`.
+#[derive(Debug)]
+pub struct WithStatus<T> {
+    reply: T,
+    status: StatusCode,
+}
+impl<T: Reply> Reply for WithStatus<T> {
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+/// Wrap an `impl Reply` to add a header when rendering.
+///
+/// # Example
+///
+/// ```
+/// use warp::Filter;
+///
+/// let route = warp::any()
+///     .map(warp::reply)
+///     .map(|reply| {
+///         warp::reply::with_header(reply, "server", "warp")
+///     });
+/// ```
+pub fn with_header<T: Reply, K, V>(reply: T, name: K, value: V) -> WithHeader<T>
+where
+    HeaderName: TryFrom<K>,
+    <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
+    HeaderValue: TryFrom<V>,
+    <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
+{
+    loop {}
+}
+/// Wraps an `impl Reply` and adds a header when rendering.
+///
+/// Returned by `warp::reply::with_header`.
+#[derive(Debug)]
+pub struct WithHeader<T> {
+    header: Option<(HeaderName, HeaderValue)>,
+    reply: T,
+}
+impl<T: Reply> Reply for WithHeader<T> {
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl<T: Send> Reply for ::http::Response<T>
+where
+    Body: From<T>,
+{
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl Reply for ::http::StatusCode {
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl<T> Reply for Result<T, ::http::Error>
+where
+    T: Reply + Send,
+{
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl Reply for String {
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl Reply for Vec<u8> {
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl Reply for &'static str {
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl Reply for Cow<'static, str> {
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl Reply for &'static [u8] {
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl<T, U> Reply for Either<T, U>
+where
+    T: Reply,
+    U: Reply,
+{
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl<T> Reply for One<T>
+where
+    T: Reply,
+{
+    #[inline]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+impl Reply for std::convert::Infallible {
+    #[inline(always)]
+    fn into_response(self) -> Response {
+        loop {}
+    }
+}
+mod sealed {
+    use super::{Reply, Response};
+    #[allow(missing_debug_implementations)]
+    pub struct Reply_(pub(crate) Response);
+    impl Reply for Reply_ {
+        #[inline]
+        fn into_response(self) -> Response {
+            loop {}
+        }
+    }
+    #[allow(missing_debug_implementations)]
+    pub struct Internal;
+    pub trait BoxedReply {
+        fn boxed_into_response(self: Box<Self>, internal: Internal) -> Response;
+    }
+    impl<T: Reply> BoxedReply for T {
+        fn boxed_into_response(self: Box<Self>, _: Internal) -> Response {
+            loop {}
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use super::*;
+    #[test]
+    fn json_serde_error() {
+        loop {}
+    }
+    #[test]
+    fn response_builder_error() {
+        loop {}
+    }
+    #[test]
+    fn boxed_reply() {
+        loop {}
+    }
+}
diff --git a/warp/src/route.rs b/warp/src/route.rs
new file mode 100644
index 0000000..1be5a7f
--- /dev/null
+++ b/warp/src/route.rs
@@ -0,0 +1,82 @@
+use scoped_tls::scoped_thread_local;
+use std::cell::RefCell;
+
+use std::net::SocketAddr;
+use hyper::Body;
+use crate::Request;
+scoped_thread_local!(static ROUTE : RefCell < Route >);
+pub(crate) fn set<F, U>(r: &RefCell<Route>, func: F) -> U
+where
+    F: FnOnce() -> U,
+{
+    loop {}
+}
+pub(crate) fn is_set() -> bool {
+    loop {}
+}
+pub(crate) fn with<F, R>(func: F) -> R
+where
+    F: FnOnce(&mut Route) -> R,
+{
+    loop {}
+}
+#[derive(Debug)]
+pub(crate) struct Route {
+    body: BodyState,
+    remote_addr: Option<SocketAddr>,
+    req: Request,
+    segments_index: usize,
+}
+#[derive(Debug)]
+enum BodyState {
+    Ready,
+    Taken,
+}
+impl Route {
+    pub(crate) fn new(req: Request, remote_addr: Option<SocketAddr>) -> RefCell<Route> {
+        loop {}
+    }
+    pub(crate) fn method(&self) -> &http::Method {
+        loop {}
+    }
+    pub(crate) fn headers(&self) -> &http::HeaderMap {
+        loop {}
+    }
+    pub(crate) fn version(&self) -> http::Version {
+        loop {}
+    }
+    pub(crate) fn extensions(&self) -> &http::Extensions {
+        loop {}
+    }
+    #[cfg(feature = "websocket")]
+    pub(crate) fn extensions_mut(&mut self) -> &mut http::Extensions {
+        loop {}
+    }
+    pub(crate) fn uri(&self) -> &http::Uri {
+        loop {}
+    }
+    pub(crate) fn path(&self) -> &str {
+        loop {}
+    }
+    pub(crate) fn full_path(&self) -> &str {
+        loop {}
+    }
+    pub(crate) fn set_unmatched_path(&mut self, index: usize) {
+        loop {}
+    }
+    pub(crate) fn query(&self) -> Option<&str> {
+        loop {}
+    }
+    pub(crate) fn matched_path_index(&self) -> usize {
+        loop {}
+    }
+    pub(crate) fn reset_matched_path_index(&mut self, index: usize) {
+        loop {}
+    }
+    pub(crate) fn remote_addr(&self) -> Option<SocketAddr> {
+        loop {}
+    }
+    pub(crate) fn take_body(&mut self) -> Option<Body> {
+        loop {}
+    }
+}
diff --git a/warp/src/server.rs b/warp/src/server.rs
new file mode 100644
index 0000000..cefbc11
--- /dev/null
+++ b/warp/src/server.rs
@@ -0,0 +1,441 @@
+#[cfg(feature = "tls")]
+use crate::tls::TlsConfigBuilder;
+use std::convert::Infallible;
+use std::error::Error as StdError;
+use std::future::Future;
+use std::net::SocketAddr;
+#[cfg(feature = "tls")]
+use std::path::Path;
+use futures_util::{future, FutureExt, TryFuture, TryStream, TryStreamExt};
+use hyper::server::conn::AddrIncoming;
+use hyper::service::{make_service_fn, service_fn};
+use hyper::Server as HyperServer;
+use tokio::io::{AsyncRead, AsyncWrite};
+use tracing::Instrument;
+use crate::filter::Filter;
+use crate::reject::IsReject;
+use crate::reply::Reply;
+use crate::transport::Transport;
+/// Create a `Server` with the provided `Filter`.
+pub fn serve<F>(filter: F) -> Server<F>
+where
+    F: Filter + Clone + Send + Sync + 'static,
+    F::Extract: Reply,
+    F::Error: IsReject,
+{
+    loop {}
+}
+/// A Warp Server ready to filter requests.
+#[derive(Debug)]
+pub struct Server<F> {
+    pipeline: bool,
+    filter: F,
+}
+/// A Warp Server ready to filter requests over TLS.
+///
+/// *This type requires the `"tls"` feature.*
+#[cfg(feature = "tls")]
+pub struct TlsServer<F> {
+    server: Server<F>,
+    tls: TlsConfigBuilder,
+}
+macro_rules! into_service {
+    ($into:expr) => {
+        { let inner = crate ::service($into); make_service_fn(move | transport | { let
+        inner = inner.clone(); let remote_addr = Transport::remote_addr(transport);
+        future::ok::< _, Infallible > (service_fn(move | req | { inner
+        .call_with_addr(req, remote_addr) })) }) }
+    };
+}
+macro_rules! addr_incoming {
+    ($addr:expr) => {
+        { let mut incoming = AddrIncoming::bind($addr) ?; incoming.set_nodelay(true); let
+        addr = incoming.local_addr(); (addr, incoming) }
+    };
+}
+macro_rules! bind_inner {
+    ($this:ident, $addr:expr) => {
+        { let service = into_service!($this .filter); let (addr, incoming) =
+        addr_incoming!($addr); let srv = HyperServer::builder(incoming)
+        .http1_pipeline_flush($this .pipeline).serve(service); Ok::< _, hyper::Error >
+        ((addr, srv)) }
+    };
+    (tls : $this:ident, $addr:expr) => {
+        { let service = into_service!($this .server.filter); let (addr, incoming) =
+        addr_incoming!($addr); let tls = $this .tls.build() ?; let srv =
+        HyperServer::builder(crate ::tls::TlsAcceptor::new(tls, incoming))
+        .http1_pipeline_flush($this .server.pipeline).serve(service); Ok::< _, Box < dyn
+        std::error::Error + Send + Sync >> ((addr, srv)) }
+    };
+}
+macro_rules! bind {
+    ($this:ident, $addr:expr) => {
+        { let addr = $addr .into(); (| addr | bind_inner!($this, addr)) (& addr)
+        .unwrap_or_else(| e | { panic!("error binding to {}: {}", addr, e); }) }
+    };
+    (tls : $this:ident, $addr:expr) => {
+        { let addr = $addr .into(); (| addr | bind_inner!(tls : $this, addr)) (& addr)
+        .unwrap_or_else(| e | { panic!("error binding to {}: {}", addr, e); }) }
+    };
+}
+macro_rules! try_bind {
+    ($this:ident, $addr:expr) => {
+        { (| addr | bind_inner!($this, addr)) ($addr) }
+    };
+    (tls : $this:ident, $addr:expr) => {
+        { (| addr | bind_inner!(tls : $this, addr)) ($addr) }
+    };
+}
+impl<F> Server<F>
+where
+    F: Filter + Clone + Send + Sync + 'static,
+    <F::Future as TryFuture>::Ok: Reply,
+    <F::Future as TryFuture>::Error: IsReject,
+{
+    /// Run this `Server` forever on the current thread.
+    pub async fn run(self, addr: impl Into<SocketAddr>) {
+        loop {}
+    }
+    /// Run this `Server` forever on the current thread with a specific stream
+    /// of incoming connections.
+    ///
+    /// This can be used for Unix Domain Sockets, or TLS, etc.
+    pub async fn run_incoming<I>(self, incoming: I)
+    where
+        I: TryStream + Send,
+        I::Ok: AsyncRead + AsyncWrite + Send + 'static + Unpin,
+        I::Error: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        loop {}
+    }
+    /// Bind to a socket address, returning a `Future` that can be
+    /// executed on the current runtime.
+    ///
+    /// # Panics
+    ///
+    /// Panics if we are unable to bind to the provided address.
+    pub fn bind(
+        self,
+        addr: impl Into<SocketAddr> + 'static,
+    ) -> impl Future<Output = ()> + 'static {
+        let (_, fut) = self.bind_ephemeral(addr);
+        fut
+    }
+    /// Bind to a socket address, returning a `Future` that can be
+    /// executed on any runtime.
+    ///
+    /// In case we are unable to bind to the specified address, resolves to an
+    /// error and logs the reason.
+    pub async fn try_bind(self, addr: impl Into<SocketAddr>) {
+        loop {}
+    }
+    /// Bind to a possibly ephemeral socket address.
+    ///
+    /// Returns the bound address and a `Future` that can be executed on
+    /// the current runtime.
+    ///
+    /// # Panics
+    ///
+    /// Panics if we are unable to bind to the provided address.
+    pub fn bind_ephemeral(
+        self,
+        addr: impl Into<SocketAddr>,
+    ) -> (SocketAddr, impl Future<Output = ()> + 'static) {
+        let (addr, srv) = bind!(self, addr);
+        let srv = srv
+            .map(|result| {
+                if let Err(err) = result {
+                    tracing::error!("server error: {}", err)
+                }
+            });
+        (addr, srv)
+    }
+    /// Tried to bind a possibly ephemeral socket address.
+    ///
+    /// Returns a `Result` which fails in case we are unable to bind with the
+    /// underlying error.
+    ///
+    /// Returns the bound address and a `Future` that can be executed on
+    /// the current runtime.
+    pub fn try_bind_ephemeral(
+        self,
+        addr: impl Into<SocketAddr>,
+    ) -> Result<(SocketAddr, impl Future<Output = ()> + 'static), crate::Error> {
+        let addr = addr.into();
+        let (addr, srv) = try_bind!(self, & addr).map_err(crate::Error::new)?;
+        let srv = srv
+            .map(|result| {
+                if let Err(err) = result {
+                    tracing::error!("server error: {}", err)
+                }
+            });
+        Ok((addr, srv))
+    }
+    /// Create a server with graceful shutdown signal.
+    ///
+    /// When the signal completes, the server will start the graceful shutdown
+    /// process.
+    ///
+    /// Returns the bound address and a `Future` that can be executed on
+    /// the current runtime.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use warp::Filter;
+    /// use futures_util::future::TryFutureExt;
+    /// use tokio::sync::oneshot;
+    ///
+    /// # fn main() {
+    /// let routes = warp::any()
+    ///     .map(|| "Hello, World!");
+    ///
+    /// let (tx, rx) = oneshot::channel();
+    ///
+    /// let (addr, server) = warp::serve(routes)
+    ///     .bind_with_graceful_shutdown(([127, 0, 0, 1], 3030), async {
+    ///          rx.await.ok();
+    ///     });
+    ///
+    /// // Spawn the server into a runtime
+    /// tokio::task::spawn(server);
+    ///
+    /// // Later, start the shutdown...
+    /// let _ = tx.send(());
+    /// # }
+    /// ```
+    pub fn bind_with_graceful_shutdown(
+        self,
+        addr: impl Into<SocketAddr> + 'static,
+        signal: impl Future<Output = ()> + Send + 'static,
+    ) -> (SocketAddr, impl Future<Output = ()> + 'static) {
+        let (addr, srv) = bind!(self, addr);
+        let fut = srv
+            .with_graceful_shutdown(signal)
+            .map(|result| {
+                if let Err(err) = result {
+                    tracing::error!("server error: {}", err)
+                }
+            });
+        (addr, fut)
+    }
+    /// Create a server with graceful shutdown signal.
+    ///
+    /// When the signal completes, the server will start the graceful shutdown
+    /// process.
+    pub fn try_bind_with_graceful_shutdown(
+        self,
+        addr: impl Into<SocketAddr> + 'static,
+        signal: impl Future<Output = ()> + Send + 'static,
+    ) -> Result<(SocketAddr, impl Future<Output = ()> + 'static), crate::Error> {
+        let addr = addr.into();
+        let (addr, srv) = try_bind!(self, & addr).map_err(crate::Error::new)?;
+        let srv = srv
+            .with_graceful_shutdown(signal)
+            .map(|result| {
+                if let Err(err) = result {
+                    tracing::error!("server error: {}", err)
+                }
+            });
+        Ok((addr, srv))
+    }
+    /// Setup this `Server` with a specific stream of incoming connections.
+    ///
+    /// This can be used for Unix Domain Sockets, or TLS, etc.
+    ///
+    /// Returns a `Future` that can be executed on the current runtime.
+    pub fn serve_incoming<I>(self, incoming: I) -> impl Future<Output = ()>
+    where
+        I: TryStream + Send,
+        I::Ok: AsyncRead + AsyncWrite + Send + 'static + Unpin,
+        I::Error: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        let incoming = incoming.map_ok(crate::transport::LiftIo);
+        self.serve_incoming2(incoming)
+            .instrument(tracing::info_span!("Server::serve_incoming"))
+    }
+    /// Setup this `Server` with a specific stream of incoming connections and a
+    /// signal to initiate graceful shutdown.
+    ///
+    /// This can be used for Unix Domain Sockets, or TLS, etc.
+    ///
+    /// When the signal completes, the server will start the graceful shutdown
+    /// process.
+    ///
+    /// Returns a `Future` that can be executed on the current runtime.
+    pub fn serve_incoming_with_graceful_shutdown<I>(
+        self,
+        incoming: I,
+        signal: impl Future<Output = ()> + Send + 'static,
+    ) -> impl Future<Output = ()>
+    where
+        I: TryStream + Send,
+        I::Ok: AsyncRead + AsyncWrite + Send + 'static + Unpin,
+        I::Error: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        let incoming = incoming.map_ok(crate::transport::LiftIo);
+        let service = into_service!(self.filter);
+        let pipeline = self.pipeline;
+        async move {
+            let srv = HyperServer::builder(
+                    hyper::server::accept::from_stream(incoming.into_stream()),
+                )
+                .http1_pipeline_flush(pipeline)
+                .serve(service)
+                .with_graceful_shutdown(signal)
+                .await;
+            if let Err(err) = srv {
+                tracing::error!("server error: {}", err);
+            }
+        }
+            .instrument(
+                tracing::info_span!("Server::serve_incoming_with_graceful_shutdown"),
+            )
+    }
+    async fn serve_incoming2<I>(self, incoming: I)
+    where
+        I: TryStream + Send,
+        I::Ok: Transport + Send + 'static + Unpin,
+        I::Error: Into<Box<dyn StdError + Send + Sync>>,
+    {
+        loop {}
+    }
+    #[doc(hidden)]
+    pub fn unstable_pipeline(mut self) -> Self {
+        loop {}
+    }
+    /// Configure a server to use TLS.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    #[cfg(feature = "tls")]
+    pub fn tls(self) -> TlsServer<F> {
+        loop {}
+    }
+}
+#[cfg(feature = "tls")]
+impl<F> TlsServer<F>
+where
+    F: Filter + Clone + Send + Sync + 'static,
+    <F::Future as TryFuture>::Ok: Reply,
+    <F::Future as TryFuture>::Error: IsReject,
+{
+    /// Specify the file path to read the private key.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn key_path(self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// Specify the file path to read the certificate.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn cert_path(self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// Specify the file path to read the trust anchor for optional client authentication.
+    ///
+    /// Anonymous and authenticated clients will be accepted. If no trust anchor is provided by any
+    /// of the `client_auth_` methods, then client authentication is disabled by default.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn client_auth_optional_path(self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// Specify the file path to read the trust anchor for required client authentication.
+    ///
+    /// Only authenticated clients will be accepted. If no trust anchor is provided by any of the
+    /// `client_auth_` methods, then client authentication is disabled by default.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn client_auth_required_path(self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// Specify the in-memory contents of the private key.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn key(self, key: impl AsRef<[u8]>) -> Self {
+        loop {}
+    }
+    /// Specify the in-memory contents of the certificate.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn cert(self, cert: impl AsRef<[u8]>) -> Self {
+        loop {}
+    }
+    /// Specify the in-memory contents of the trust anchor for optional client authentication.
+    ///
+    /// Anonymous and authenticated clients will be accepted. If no trust anchor is provided by any
+    /// of the `client_auth_` methods, then client authentication is disabled by default.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn client_auth_optional(self, trust_anchor: impl AsRef<[u8]>) -> Self {
+        loop {}
+    }
+    /// Specify the in-memory contents of the trust anchor for required client authentication.
+    ///
+    /// Only authenticated clients will be accepted. If no trust anchor is provided by any of the
+    /// `client_auth_` methods, then client authentication is disabled by default.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn client_auth_required(self, trust_anchor: impl AsRef<[u8]>) -> Self {
+        loop {}
+    }
+    /// Specify the DER-encoded OCSP response.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn ocsp_resp(self, resp: impl AsRef<[u8]>) -> Self {
+        loop {}
+    }
+    fn with_tls<Func>(self, func: Func) -> Self
+    where
+        Func: FnOnce(TlsConfigBuilder) -> TlsConfigBuilder,
+    {
+        loop {}
+    }
+    /// Run this `TlsServer` forever on the current thread.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub async fn run(self, addr: impl Into<SocketAddr>) {
+        loop {}
+    }
+    /// Bind to a socket address, returning a `Future` that can be
+    /// executed on a runtime.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub async fn bind(self, addr: impl Into<SocketAddr>) {
+        loop {}
+    }
+    /// Bind to a possibly ephemeral socket address.
+    ///
+    /// Returns the bound address and a `Future` that can be executed on
+    /// the current runtime.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn bind_ephemeral(
+        self,
+        addr: impl Into<SocketAddr>,
+    ) -> (SocketAddr, impl Future<Output = ()> + 'static) {
+        loop {}
+    }
+    /// Create a server with graceful shutdown signal.
+    ///
+    /// When the signal completes, the server will start the graceful shutdown
+    /// process.
+    ///
+    /// *This function requires the `"tls"` feature.*
+    pub fn bind_with_graceful_shutdown(
+        self,
+        addr: impl Into<SocketAddr> + 'static,
+        signal: impl Future<Output = ()> + Send + 'static,
+    ) -> (SocketAddr, impl Future<Output = ()> + 'static) {
+        loop {}
+    }
+}
+#[cfg(feature = "tls")]
+impl<F> ::std::fmt::Debug for TlsServer<F>
+where
+    F: ::std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        loop {}
+    }
+}
diff --git a/warp/src/service.rs b/warp/src/service.rs
new file mode 100644
index 0000000..4f93809
--- /dev/null
+++ b/warp/src/service.rs
@@ -0,0 +1,3 @@
+//! Convert `Filter`s into `Service`s
+
+pub use crate::filter::service::service;
diff --git a/warp/src/test.rs b/warp/src/test.rs
new file mode 100644
index 0000000..e74195c
--- /dev/null
+++ b/warp/src/test.rs
@@ -0,0 +1,537 @@
+//! Test utilities to test your filters.
+//!
+//! [`Filter`](../trait.Filter.html)s can be easily tested without starting up an HTTP
+//! server, by making use of the [`RequestBuilder`](./struct.RequestBuilder.html) in this
+//! module.
+//!
+//! # Testing Filters
+//!
+//! It's easy to test filters, especially if smaller filters are used to build
+//! up your full set. Consider these example filters:
+//!
+//! ```
+//! use warp::Filter;
+//!
+//! fn sum() -> impl Filter<Extract = (u32,), Error = warp::Rejection> + Copy {
+//!     warp::path::param()
+//!         .and(warp::path::param())
+//!         .map(|x: u32, y: u32| {
+//!             x + y
+//!         })
+//! }
+//!
+//! fn math() -> impl Filter<Extract = (String,), Error = warp::Rejection> + Copy {
+//!     warp::post()
+//!         .and(sum())
+//!         .map(|z: u32| {
+//!             format!("Sum = {}", z)
+//!         })
+//! }
+//! ```
+//!
+//! We can test some requests against the `sum` filter like this:
+//!
+//! ```
+//! # use warp::Filter;
+//! #[tokio::test]
+//! async fn test_sum() {
+//! #    let sum = || warp::any().map(|| 3);
+//!     let filter = sum();
+//!
+//!     // Execute `sum` and get the `Extract` back.
+//!     let value = warp::test::request()
+//!         .path("/1/2")
+//!         .filter(&filter)
+//!         .await
+//!         .unwrap();
+//!     assert_eq!(value, 3);
+//!
+//!     // Or simply test if a request matches (doesn't reject).
+//!     assert!(
+//!         warp::test::request()
+//!             .path("/1/-5")
+//!             .matches(&filter)
+//!             .await
+//!     );
+//! }
+//! ```
+//!
+//! If the filter returns something that implements `Reply`, and thus can be
+//! turned into a response sent back to the client, we can test what exact
+//! response is returned. The `math` filter uses the `sum` filter, but returns
+//! a `String` that can be turned into a response.
+//!
+//! ```
+//! # use warp::Filter;
+//! #[test]
+//! fn test_math() {
+//! #    let math = || warp::any().map(warp::reply);
+//!     let filter = math();
+//!
+//!     let res = warp::test::request()
+//!         .path("/1/2")
+//!         .reply(&filter);
+//!     assert_eq!(res.status(), 405, "GET is not allowed");
+//!
+//!     let res = warp::test::request()
+//!         .method("POST")
+//!         .path("/1/2")
+//!         .reply(&filter);
+//!     assert_eq!(res.status(), 200);
+//!     assert_eq!(res.body(), "Sum is 3");
+//! }
+//! ```
+use std::convert::TryFrom;
+use std::error::Error as StdError;
+use std::fmt;
+
+use std::net::SocketAddr;
+#[cfg(feature = "websocket")]
+use std::pin::Pin;
+#[cfg(feature = "websocket")]
+use std::task::Context;
+#[cfg(feature = "websocket")]
+use std::task::{self, Poll};
+use bytes::Bytes;
+#[cfg(feature = "websocket")]
+use futures_channel::mpsc;
+#[cfg(feature = "websocket")]
+use futures_util::StreamExt;
+
+use http::{
+    header::{HeaderName, HeaderValue},
+    Response,
+};
+use serde::Serialize;
+#[cfg(feature = "websocket")]
+use tokio::sync::oneshot;
+use crate::filter::Filter;
+#[cfg(feature = "websocket")]
+use crate::filters::ws::Message;
+use crate::reject::IsReject;
+use crate::reply::Reply;
+
+use crate::Request;
+#[cfg(feature = "websocket")]
+use crate::{Sink, Stream};
+use self::inner::OneOrTuple;
+/// Starts a new test `RequestBuilder`.
+pub fn request() -> RequestBuilder {
+    loop {}
+}
+/// Starts a new test `WsBuilder`.
+#[cfg(feature = "websocket")]
+pub fn ws() -> WsBuilder {
+    loop {}
+}
+/// A request builder for testing filters.
+///
+/// See [module documentation](crate::test) for an overview.
+#[must_use = "RequestBuilder does nothing on its own"]
+#[derive(Debug)]
+pub struct RequestBuilder {
+    remote_addr: Option<SocketAddr>,
+    req: Request,
+}
+/// A Websocket builder for testing filters.
+///
+/// See [module documentation](crate::test) for an overview.
+#[cfg(feature = "websocket")]
+#[must_use = "WsBuilder does nothing on its own"]
+#[derive(Debug)]
+pub struct WsBuilder {
+    req: RequestBuilder,
+}
+/// A test client for Websocket filters.
+#[cfg(feature = "websocket")]
+pub struct WsClient {
+    tx: mpsc::UnboundedSender<crate::ws::Message>,
+    rx: mpsc::UnboundedReceiver<Result<crate::ws::Message, crate::error::Error>>,
+}
+/// An error from Websocket filter tests.
+#[derive(Debug)]
+pub struct WsError {
+    cause: Box<dyn StdError + Send + Sync>,
+}
+impl RequestBuilder {
+    /// Sets the method of this builder.
+    ///
+    /// The default if not set is `GET`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let req = warp::test::request()
+    ///     .method("POST");
+    /// ```
+    ///
+    /// # Panic
+    ///
+    /// This panics if the passed string is not able to be parsed as a valid
+    /// `Method`.
+    pub fn method(mut self, method: &str) -> Self {
+        loop {}
+    }
+    /// Sets the request path of this builder.
+    ///
+    /// The default is not set is `/`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let req = warp::test::request()
+    ///     .path("/todos/33");
+    /// ```
+    ///
+    /// # Panic
+    ///
+    /// This panics if the passed string is not able to be parsed as a valid
+    /// `Uri`.
+    pub fn path(mut self, p: &str) -> Self {
+        loop {}
+    }
+    /// Set a header for this request.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let req = warp::test::request()
+    ///     .header("accept", "application/json");
+    /// ```
+    ///
+    /// # Panic
+    ///
+    /// This panics if the passed strings are not able to be parsed as a valid
+    /// `HeaderName` and `HeaderValue`.
+    pub fn header<K, V>(mut self, key: K, value: V) -> Self
+    where
+        HeaderName: TryFrom<K>,
+        HeaderValue: TryFrom<V>,
+    {
+        loop {}
+    }
+    /// Set the remote address of this request
+    ///
+    /// Default is no remote address.
+    ///
+    /// # Example
+    /// ```
+    /// use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+    ///
+    /// let req = warp::test::request()
+    ///     .remote_addr(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080));
+    /// ```
+    pub fn remote_addr(mut self, addr: SocketAddr) -> Self {
+        loop {}
+    }
+    /// Add a type to the request's `http::Extensions`.
+    pub fn extension<T>(mut self, ext: T) -> Self
+    where
+        T: Send + Sync + 'static,
+    {
+        loop {}
+    }
+    /// Set the bytes of this request body.
+    ///
+    /// Default is an empty body.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let req = warp::test::request()
+    ///     .body("foo=bar&baz=quux");
+    /// ```
+    pub fn body(mut self, body: impl AsRef<[u8]>) -> Self {
+        loop {}
+    }
+    /// Set the bytes of this request body by serializing a value into JSON.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let req = warp::test::request()
+    ///     .json(&true);
+    /// ```
+    pub fn json(mut self, val: &impl Serialize) -> Self {
+        loop {}
+    }
+    /// Tries to apply the `Filter` on this request.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// async {
+    ///     let param = warp::path::param::<u32>();
+    ///
+    ///     let ex = warp::test::request()
+    ///         .path("/41")
+    ///         .filter(&param)
+    ///         .await
+    ///         .unwrap();
+    ///
+    ///     assert_eq!(ex, 41);
+    ///
+    ///     assert!(
+    ///         warp::test::request()
+    ///             .path("/foo")
+    ///             .filter(&param)
+    ///             .await
+    ///             .is_err()
+    ///     );
+    ///};
+    /// ```
+    pub async fn filter<F>(
+        self,
+        f: &F,
+    ) -> Result<<F::Extract as OneOrTuple>::Output, F::Error>
+    where
+        F: Filter,
+        F::Future: Send + 'static,
+        F::Extract: OneOrTuple + Send + 'static,
+        F::Error: Send + 'static,
+    {
+        loop {}
+    }
+    /// Returns whether the `Filter` matches this request, or rejects it.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// async {
+    ///     let get = warp::get();
+    ///     let post = warp::post();
+    ///
+    ///     assert!(
+    ///         warp::test::request()
+    ///             .method("GET")
+    ///             .matches(&get)
+    ///             .await
+    ///     );
+    ///
+    ///     assert!(
+    ///         !warp::test::request()
+    ///             .method("GET")
+    ///             .matches(&post)
+    ///             .await
+    ///     );
+    ///};
+    /// ```
+    pub async fn matches<F>(self, f: &F) -> bool
+    where
+        F: Filter,
+        F::Future: Send + 'static,
+        F::Extract: Send + 'static,
+        F::Error: Send + 'static,
+    {
+        loop {}
+    }
+    /// Returns `Response` provided by applying the `Filter`.
+    ///
+    /// This requires that the supplied `Filter` return a [`Reply`](Reply).
+    pub async fn reply<F>(self, f: &F) -> Response<Bytes>
+    where
+        F: Filter + 'static,
+        F::Extract: Reply + Send,
+        F::Error: IsReject + Send,
+    {
+        loop {}
+    }
+}
+#[cfg(feature = "websocket")]
+impl WsBuilder {
+    /// Sets the request path of this builder.
+    ///
+    /// The default is not set is `/`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let req = warp::test::ws()
+    ///     .path("/chat");
+    /// ```
+    ///
+    /// # Panic
+    ///
+    /// This panics if the passed string is not able to be parsed as a valid
+    /// `Uri`.
+    pub fn path(self, p: &str) -> Self {
+        loop {}
+    }
+    /// Set a header for this request.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// let req = warp::test::ws()
+    ///     .header("foo", "bar");
+    /// ```
+    ///
+    /// # Panic
+    ///
+    /// This panics if the passed strings are not able to be parsed as a valid
+    /// `HeaderName` and `HeaderValue`.
+    pub fn header<K, V>(self, key: K, value: V) -> Self
+    where
+        HeaderName: TryFrom<K>,
+        HeaderValue: TryFrom<V>,
+    {
+        loop {}
+    }
+    /// Execute this Websocket request against the provided filter.
+    ///
+    /// If the handshake succeeds, returns a `WsClient`.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use futures_util::future;
+    /// use warp::Filter;
+    /// #[tokio::main]
+    /// # async fn main() {
+    ///
+    /// // Some route that accepts websockets (but drops them immediately).
+    /// let route = warp::ws()
+    ///     .map(|ws: warp::ws::Ws| {
+    ///         ws.on_upgrade(|_| future::ready(()))
+    ///     });
+    ///
+    /// let client = warp::test::ws()
+    ///     .handshake(route)
+    ///     .await
+    ///     .expect("handshake");
+    /// # }
+    /// ```
+    pub async fn handshake<F>(self, f: F) -> Result<WsClient, WsError>
+    where
+        F: Filter + Clone + Send + Sync + 'static,
+        F::Extract: Reply + Send,
+        F::Error: IsReject + Send,
+    {
+        loop {}
+    }
+}
+#[cfg(feature = "websocket")]
+impl WsClient {
+    /// Send a "text" websocket message to the server.
+    pub async fn send_text(&mut self, text: impl Into<String>) {
+        loop {}
+    }
+    /// Send a websocket message to the server.
+    pub async fn send(&mut self, msg: crate::ws::Message) {
+        loop {}
+    }
+    /// Receive a websocket message from the server.
+    pub async fn recv(&mut self) -> Result<crate::filters::ws::Message, WsError> {
+        loop {}
+    }
+    /// Assert the server has closed the connection.
+    pub async fn recv_closed(&mut self) -> Result<(), WsError> {
+        loop {}
+    }
+    fn pinned_tx(
+        self: Pin<&mut Self>,
+    ) -> Pin<&mut mpsc::UnboundedSender<crate::ws::Message>> {
+        loop {}
+    }
+}
+#[cfg(feature = "websocket")]
+impl fmt::Debug for WsClient {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+#[cfg(feature = "websocket")]
+impl Sink<crate::ws::Message> for WsClient {
+    type Error = WsError;
+    fn poll_ready(
+        self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+    fn start_send(self: Pin<&mut Self>, message: Message) -> Result<(), Self::Error> {
+        loop {}
+    }
+    fn poll_flush(
+        self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+    fn poll_close(
+        self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+}
+#[cfg(feature = "websocket")]
+impl Stream for WsClient {
+    type Item = Result<crate::ws::Message, WsError>;
+    fn poll_next(
+        self: Pin<&mut Self>,
+        context: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {}
+    }
+}
+#[cfg(feature = "websocket")]
+impl WsError {
+    fn new<E: Into<Box<dyn StdError + Send + Sync>>>(cause: E) -> Self {
+        loop {}
+    }
+}
+impl fmt::Display for WsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl StdError for WsError {
+    fn description(&self) -> &str {
+        loop {}
+    }
+}
+#[cfg(feature = "websocket")]
+#[derive(Clone)]
+struct AddrConnect(SocketAddr);
+#[cfg(feature = "websocket")]
+impl tower_service::Service<::http::Uri> for AddrConnect {
+    type Response = ::tokio::net::TcpStream;
+    type Error = ::std::io::Error;
+    type Future = Pin<
+        Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>,
+    >;
+    fn poll_ready(
+        &mut self,
+        _cx: &mut task::Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
+        loop {}
+    }
+    fn call(&mut self, _: ::http::Uri) -> Self::Future {
+        loop {}
+    }
+}
+mod inner {
+    pub trait OneOrTuple {
+        type Output;
+        fn one_or_tuple(self) -> Self::Output;
+    }
+    impl OneOrTuple for () {
+        type Output = ();
+        fn one_or_tuple(self) -> Self::Output {}
+    }
+    macro_rules! one_or_tuple {
+        ($type1:ident) => {
+            impl <$type1 > OneOrTuple for ($type1,) { type Output = $type1; fn
+            one_or_tuple(self) -> Self::Output { self.0 } }
+        };
+        ($type1:ident, $($type:ident),*) => {
+            one_or_tuple!($($type),*); impl <$type1, $($type),*> OneOrTuple for ($type1,
+            $($type),*) { type Output = Self; fn one_or_tuple(self) -> Self::Output {
+            self } }
+        };
+    }
+    one_or_tuple! {
+        T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16
+    }
+}
diff --git a/warp/src/tls.rs b/warp/src/tls.rs
new file mode 100644
index 0000000..350a2d7
--- /dev/null
+++ b/warp/src/tls.rs
@@ -0,0 +1,212 @@
+use std::fmt;
+use std::fs::File;
+use std::future::Future;
+use std::io::{self, BufReader, Cursor, Read};
+use std::net::SocketAddr;
+use std::path::{Path, PathBuf};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use futures_util::ready;
+use hyper::server::accept::Accept;
+use hyper::server::conn::{AddrIncoming, AddrStream};
+use crate::transport::Transport;
+use tokio_rustls::rustls::{
+    server::{
+        AllowAnyAnonymousOrAuthenticatedClient, AllowAnyAuthenticatedClient, NoClientAuth,
+    },
+    Certificate, Error as TlsError, PrivateKey, RootCertStore, ServerConfig,
+};
+/// Represents errors that can occur building the TlsConfig
+#[derive(Debug)]
+pub(crate) enum TlsConfigError {
+    Io(io::Error),
+    /// An Error parsing the Certificate
+    CertParseError,
+    /// An Error parsing a Pkcs8 key
+    Pkcs8ParseError,
+    /// An Error parsing a Rsa key
+    RsaParseError,
+    /// An error from an empty key
+    EmptyKey,
+    /// An error from an invalid key
+    InvalidKey(TlsError),
+}
+impl fmt::Display for TlsConfigError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl std::error::Error for TlsConfigError {}
+/// Tls client authentication configuration.
+pub(crate) enum TlsClientAuth {
+    /// No client auth.
+    Off,
+    /// Allow any anonymous or authenticated client.
+    Optional(Box<dyn Read + Send + Sync>),
+    /// Allow any authenticated client.
+    Required(Box<dyn Read + Send + Sync>),
+}
+/// Builder to set the configuration for the Tls server.
+pub(crate) struct TlsConfigBuilder {
+    cert: Box<dyn Read + Send + Sync>,
+    key: Box<dyn Read + Send + Sync>,
+    client_auth: TlsClientAuth,
+    ocsp_resp: Vec<u8>,
+}
+impl fmt::Debug for TlsConfigBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        loop {}
+    }
+}
+impl TlsConfigBuilder {
+    /// Create a new TlsConfigBuilder
+    pub(crate) fn new() -> TlsConfigBuilder {
+        loop {}
+    }
+    /// sets the Tls key via File Path, returns `TlsConfigError::IoError` if the file cannot be open
+    pub(crate) fn key_path(mut self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// sets the Tls key via bytes slice
+    pub(crate) fn key(mut self, key: &[u8]) -> Self {
+        loop {}
+    }
+    /// Specify the file path for the TLS certificate to use.
+    pub(crate) fn cert_path(mut self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// sets the Tls certificate via bytes slice
+    pub(crate) fn cert(mut self, cert: &[u8]) -> Self {
+        loop {}
+    }
+    /// Sets the trust anchor for optional Tls client authentication via file path.
+    ///
+    /// Anonymous and authenticated clients will be accepted. If no trust anchor is provided by any
+    /// of the `client_auth_` methods, then client authentication is disabled by default.
+    pub(crate) fn client_auth_optional_path(mut self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// Sets the trust anchor for optional Tls client authentication via bytes slice.
+    ///
+    /// Anonymous and authenticated clients will be accepted. If no trust anchor is provided by any
+    /// of the `client_auth_` methods, then client authentication is disabled by default.
+    pub(crate) fn client_auth_optional(mut self, trust_anchor: &[u8]) -> Self {
+        loop {}
+    }
+    /// Sets the trust anchor for required Tls client authentication via file path.
+    ///
+    /// Only authenticated clients will be accepted. If no trust anchor is provided by any of the
+    /// `client_auth_` methods, then client authentication is disabled by default.
+    pub(crate) fn client_auth_required_path(mut self, path: impl AsRef<Path>) -> Self {
+        loop {}
+    }
+    /// Sets the trust anchor for required Tls client authentication via bytes slice.
+    ///
+    /// Only authenticated clients will be accepted. If no trust anchor is provided by any of the
+    /// `client_auth_` methods, then client authentication is disabled by default.
+    pub(crate) fn client_auth_required(mut self, trust_anchor: &[u8]) -> Self {
+        loop {}
+    }
+    /// sets the DER-encoded OCSP response
+    pub(crate) fn ocsp_resp(mut self, ocsp_resp: &[u8]) -> Self {
+        loop {}
+    }
+    pub(crate) fn build(mut self) -> Result<ServerConfig, TlsConfigError> {
+        loop {}
+    }
+}
+struct LazyFile {
+    path: PathBuf,
+    file: Option<File>,
+}
+impl LazyFile {
+    fn lazy_read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        loop {}
+    }
+}
+impl Read for LazyFile {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        loop {}
+    }
+}
+impl Transport for TlsStream {
+    fn remote_addr(&self) -> Option<SocketAddr> {
+        loop {}
+    }
+}
+enum State {
+    Handshaking(tokio_rustls::Accept<AddrStream>),
+    Streaming(tokio_rustls::server::TlsStream<AddrStream>),
+}
+pub(crate) struct TlsStream {
+    state: State,
+    remote_addr: SocketAddr,
+}
+impl TlsStream {
+    fn new(stream: AddrStream, config: Arc<ServerConfig>) -> TlsStream {
+        loop {}
+    }
+}
+impl AsyncRead for TlsStream {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        loop {}
+    }
+}
+impl AsyncWrite for TlsStream {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        loop {}
+    }
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<io::Result<()>> {
+        loop {}
+    }
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<io::Result<()>> {
+        loop {}
+    }
+}
+pub(crate) struct TlsAcceptor {
+    config: Arc<ServerConfig>,
+    incoming: AddrIncoming,
+}
+impl TlsAcceptor {
+    pub(crate) fn new(config: ServerConfig, incoming: AddrIncoming) -> TlsAcceptor {
+        loop {}
+    }
+}
+impl Accept for TlsAcceptor {
+    type Conn = TlsStream;
+    type Error = io::Error;
+    fn poll_accept(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
+        loop {}
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn file_cert_key() {
+        loop {}
+    }
+    #[test]
+    fn bytes_cert_key() {
+        loop {}
+    }
+}
diff --git a/warp/src/transport.rs b/warp/src/transport.rs
new file mode 100644
index 0000000..7f4c6eb
--- /dev/null
+++ b/warp/src/transport.rs
@@ -0,0 +1,50 @@
+use std::io;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use hyper::server::conn::AddrStream;
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+pub trait Transport: AsyncRead + AsyncWrite {
+    fn remote_addr(&self) -> Option<SocketAddr>;
+}
+impl Transport for AddrStream {
+    fn remote_addr(&self) -> Option<SocketAddr> {
+        loop {}
+    }
+}
+pub(crate) struct LiftIo<T>(pub(crate) T);
+impl<T: AsyncRead + Unpin> AsyncRead for LiftIo<T> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        loop {}
+    }
+}
+impl<T: AsyncWrite + Unpin> AsyncWrite for LiftIo<T> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        loop {}
+    }
+    fn poll_flush(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        loop {}
+    }
+    fn poll_shutdown(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        loop {}
+    }
+}
+impl<T: AsyncRead + AsyncWrite + Unpin> Transport for LiftIo<T> {
+    fn remote_addr(&self) -> Option<SocketAddr> {
+        loop {}
+    }
+}