the big three point oh (#1668)

Co-authored-by: Rob Ede <robjtede@icloud.com>

.appveyor.yml

@@ -1,41 +0,0 @@
-environment:
-  global:
-    PROJECT_NAME: actix-web
-  matrix:
-    # Stable channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: stable
-    # Nightly channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: nightly
-
-# Install Rust and Cargo
-# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
-install:
-  - ps: >-
-        If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
-           $Env:PATH += ';C:\msys64\mingw64\bin'
-        } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
-           $Env:PATH += ';C:\MinGW\bin'
-        }
-  - curl -sSf -o rustup-init.exe https://win.rustup.rs
-  - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -Vv
-  - cargo -V
-
-# 'cargo test' takes care of building for us, so disable Appveyor's build stage.
-build: false
-
-# Equivalent to Travis' `script` phase
-test_script:
-  - cargo clean
-  - cargo test --no-default-features --features="flate2-rust"

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,37 @@
+---
+name: Bug Report
+about: Create a bug report.
+---
+
+Your issue may already be reported!
+Please search on the [Actix Web issue tracker](https://github.com/actix/actix-web/issues) before creating one.
+
+## Expected Behavior
+<!--- If you're describing a bug, tell us what should happen -->
+<!--- If you're suggesting a change/improvement, tell us how it should work -->
+
+## Current Behavior
+<!--- If describing a bug, tell us what happens instead of the expected behavior -->
+<!--- If suggesting a change/improvement, explain the difference from current behavior -->
+
+## Possible Solution
+<!--- Not obligatory, but suggest a fix/reason for the bug, -->
+<!--- or ideas how to implement the addition or change -->
+
+## Steps to Reproduce (for bugs)
+<!--- Provide a link to a live example, or an unambiguous set of steps to -->
+<!--- reproduce this bug. Include code to reproduce, if relevant -->
+1.
+2.
+3.
+4.
+
+## Context
+<!--- How has this issue affected you? What are you trying to accomplish? -->
+<!--- Providing context helps us come up with a solution that is most useful in the real world -->
+
+## Your Environment
+<!--- Include as many relevant details about the environment you experienced the bug in -->
+
+* Rust Version (I.e, output of `rustc -V`):
+* Actix Web Version:

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Gitter channel (actix-web)
+    url: https://gitter.im/actix/actix-web
+    about: Please ask and answer questions about the actix-web here.
+  - name: Gitter channel (actix)
+    url: https://gitter.im/actix/actix
+    about: Please ask and answer questions about the actix here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,27 @@
+<!-- Thanks for considering contributing actix! -->
+<!-- Please fill out the following to make our reviews easy. -->
+
+## PR Type
+<!-- What kind of change does this PR make? -->
+<!-- Bug Fix / Feature / Refactor / Code Style / Other -->
+INSERT_PR_TYPE
+
+
+## PR Checklist
+Check your PR fulfills the following:
+
+<!-- For draft PRs check the boxes as you complete them. -->
+
+- [ ] Tests for the changes have been added / updated.
+- [ ] Documentation comments have been added / updated.
+- [ ] A changelog entry has been made for the appropriate packages.
+- [ ] Format code with the latest stable rustfmt
+
+
+## Overview
+<!-- Describe the current and new behavior. -->
+<!-- Emphasize any breaking changes. -->
+
+
+<!-- If this PR fixes or closes an issue, reference it here. -->
+<!-- Closes #000 -->

.github/workflows/bench.yml

@@ -0,0 +1,28 @@
+name: Benchmark (Linux)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+
+jobs:
+  check_benchmark:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          profile: minimal
+          override: true
+
+      - name: Check benchmark
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: --bench=server -- --sample-size=15

.github/workflows/clippy-fmt.yml

@@ -0,0 +1,32 @@
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+name: Clippy and rustfmt Check
+jobs:
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          components: rustfmt
+          override: true
+      - name: Check with rustfmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          components: clippy
+          override: true
+      - name: Check with Clippy
+        uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features --all --tests

.github/workflows/linux.yml

@@ -0,0 +1,69 @@
+name: CI (Linux)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - 1.42.0 # MSRV
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-unknown-linux-gnu
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 40
+        with:
+          command: test
+          args: --all --all-features --no-fail-fast -- --nocapture
+
+      - name: tests (actix-http)
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 40
+        with:
+          command: test
+          args: --package=actix-http --no-default-features --features=rustls -- --nocapture
+
+      - name: tests (awc)
+        uses: actions-rs/cargo@v1
+        timeout-minutes: 40
+        with:
+          command: test
+          args: --package=awc --no-default-features --features=rustls -- --nocapture
+
+      - name: Generate coverage file
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        run: |
+          cargo install cargo-tarpaulin --vers "^0.13"
+          cargo tarpaulin --out Xml
+      - name: Upload to Codecov
+        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
+        uses: codecov/codecov-action@v1
+        with:
+          file: cobertura.xml

.github/workflows/macos.yml

@@ -0,0 +1,44 @@
+name: CI (macOS)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-apple-darwin
+    runs-on: macOS-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-apple-darwin
+          profile: minimal
+          override: true
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all --all-features --no-fail-fast -- --nocapture
+                --skip=test_h2_content_length
+                --skip=test_reading_deflate_encoding_large_random_rustls

.github/workflows/main.yml

@@ -1,67 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-env:
-  VCPKGRS_DYNAMIC: 1
-
-jobs:
-  build_and_test:
-    strategy:
-      fail-fast: false
-      matrix:
-        toolchain:
-          - x86_64-pc-windows-msvc
-          # - i686-pc-windows-msvc
-          - x86_64-apple-darwin
-        version:
-          - stable
-          - nightly
-        include:
-        - toolchain: x86_64-pc-windows-msvc
-          os: windows-latest
-          arch: x64
-        # - toolchain: i686-pc-windows-msvc
-          # os: windows-latest
-          # arch: x86
-        - toolchain: x86_64-apple-darwin
-          os: macOS-latest
-
-    name: ${{ matrix.version }} - ${{ matrix.toolchain }}
-    runs-on: ${{ matrix.os }}
-
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Install ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-${{ matrix.toolchain }}
-          default: true
-
-      - name: Install OpenSSL
-        if: matrix.os == 'windows-latest'
-        run: |
-          vcpkg integrate install
-          vcpkg install openssl:${{ matrix.arch }}-windows
-
-      - name: check nightly
-        if: matrix.version == 'nightly'
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all --benches --bins --examples --tests
-
-      - name: check stable
-        if: matrix.version == 'stable'
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all --bins --examples --tests
-
-      - name: tests
-        if: matrix.toolchain != 'x86_64-pc-windows-gnu'
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --all --all-features -- --nocapture

.github/workflows/upload-doc.yml

@@ -0,0 +1,37 @@
+name: Upload documentation
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    if: github.repository == 'actix/actix-web'
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable-x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: doc
+          args: --no-deps --workspace --all-features
+
+      - name: Tweak HTML
+        run: echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html
+
+      - name: Deploy to GitHub Pages
+        uses: JamesIves/github-pages-deploy-action@3.5.8
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          BRANCH: gh-pages
+          FOLDER: target/doc

.github/workflows/windows.yml

@@ -0,0 +1,64 @@
+name: CI (Windows)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches:
+      - master
+
+env:
+  VCPKGRS_DYNAMIC: 1
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - stable
+          - nightly
+
+    name: ${{ matrix.version }} - x86_64-pc-windows-msvc
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-x86_64-pc-windows-msvc
+          profile: minimal
+          override: true
+
+      - name: Install OpenSSL
+        run: |
+          vcpkg integrate install
+          vcpkg install openssl:x64-windows
+          Copy-Item C:\vcpkg\installed\x64-windows\bin\libcrypto-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libcrypto.dll
+          Copy-Item C:\vcpkg\installed\x64-windows\bin\libssl-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libssl.dll
+          Get-ChildItem C:\vcpkg\installed\x64-windows\bin
+          Get-ChildItem C:\vcpkg\installed\x64-windows\lib
+
+      - name: check build
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all --all-features --no-fail-fast -- --nocapture
+                --skip=test_h2_content_length
+                --skip=test_reading_deflate_encoding_large_random_rustls
+                --skip=test_params
+                --skip=test_simple
+                --skip=test_expect_continue
+                --skip=test_http10_keepalive
+                --skip=test_slow_request
+                --skip=test_connection_force_close
+                --skip=test_connection_server_close
+                --skip=test_connection_wait_queue_force_close

.gitignore

@@ -9,6 +9,7 @@ guide/build/
 *.pid
 *.sock
 *~
+.DS_Store
 
 # These are backup files generated by rustfmt
 **/*.rs.bk

.travis.yml

@@ -1,61 +0,0 @@
-language: rust
-sudo: required
-dist: trusty
-
-cache:
-  # cargo: true
-  apt: true
-
-matrix:
-  include:
-    - rust: stable
-    - rust: beta
-    - rust: nightly-2019-11-20
-  allow_failures:
-    - rust: nightly-2019-11-20
-
-env:
-  global:
-    # - RUSTFLAGS="-C link-dead-code"
-    - OPENSSL_VERSION=openssl-1.0.2
-
-before_install:
-  - sudo add-apt-repository -y ppa:0k53d-karl-f830m/openssl
-  - sudo apt-get update -qq
-  - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
-
-before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-11-20" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
-  fi
-
-# Add clippy
-before_script:
-  - export PATH=$PATH:~/.cargo/bin
-
-script:
-  - cargo update
-  - cargo check --all --no-default-features
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == "stable" || "$TRAVIS_RUST_VERSION" == "beta" ]]; then
-      cargo test --all-features --all -- --nocapture
-      cd actix-http; cargo test --no-default-features --features="rustls" -- --nocapture; cd ..
-      cd awc; cargo test --no-default-features --features="rustls" -- --nocapture; cd ..
-    fi
-
-# Upload docs
-after_success:
-  - |
-    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "stable" ]]; then
-      cargo doc --no-deps --all-features &&
-      echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
-      git clone https://github.com/davisp/ghp-import.git &&
-      ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
-      echo "Uploaded documentation"
-    fi
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-11-20" ]]; then
-        taskset -c 0 cargo tarpaulin --out Xml --all --all-features
-        bash <(curl -s https://codecov.io/bash)
-        echo "Uploaded code coverage"
-    fi

CHANGES.md

@@ -1,6 +1,118 @@
 # Changes
 
-## [2.0.0] - 2019-12-xx
+## Unreleased - 2020-xx-xx
+
+
+## 3.0.0 - 2020-09-11
+* No significant changes from `3.0.0-beta.4`.
+
+
+## 3.0.0-beta.4 - 2020-09-09
+### Added
+* `middleware::NormalizePath` now has configurable behaviour for either always having a trailing
+  slash, or as the new addition, always trimming trailing slashes. [#1639]
+
+### Changed
+* Update actix-codec and actix-utils dependencies. [#1634]
+* `FormConfig` and `JsonConfig` configurations are now also considered when set
+  using `App::data`. [#1641]
+* `HttpServer::maxconn` is renamed to the more expressive `HttpServer::max_connections`. [#1655]
+* `HttpServer::maxconnrate` is renamed to the more expressive
+  `HttpServer::max_connection_rate`. [#1655]
+
+[#1639]: https://github.com/actix/actix-web/pull/1639
+[#1641]: https://github.com/actix/actix-web/pull/1641
+[#1634]: https://github.com/actix/actix-web/pull/1634
+[#1655]: https://github.com/actix/actix-web/pull/1655
+
+## 3.0.0-beta.3 - 2020-08-17
+### Changed
+* Update `rustls` to 0.18
+
+
+## 3.0.0-beta.2 - 2020-08-17
+### Changed
+* `PayloadConfig` is now also considered in `Bytes` and `String` extractors when set
+  using `App::data`. [#1610]
+* `web::Path` now has a public representation: `web::Path(pub T)` that enables
+  destructuring. [#1594]
+* `ServiceRequest::app_data` allows retrieval of non-Data data without splitting into parts to
+  access `HttpRequest` which already allows this. [#1618]
+* Re-export all error types from `awc`. [#1621]
+* MSRV is now 1.42.0.
+
+### Fixed
+* Memory leak of app data in pooled requests. [#1609]
+
+[#1594]: https://github.com/actix/actix-web/pull/1594
+[#1609]: https://github.com/actix/actix-web/pull/1609
+[#1610]: https://github.com/actix/actix-web/pull/1610
+[#1618]: https://github.com/actix/actix-web/pull/1618
+[#1621]: https://github.com/actix/actix-web/pull/1621
+
+
+## 3.0.0-beta.1 - 2020-07-13
+### Added
+* Re-export `actix_rt::main` as `actix_web::main`.
+* `HttpRequest::match_pattern` and `ServiceRequest::match_pattern` for extracting the matched
+  resource pattern.
+* `HttpRequest::match_name` and `ServiceRequest::match_name` for extracting matched resource name.
+
+### Changed
+* Fix actix_http::h1::dispatcher so it returns when HW_BUFFER_SIZE is reached. Should reduce peak memory consumption during large uploads. [#1550]
+* Migrate cookie handling to `cookie` crate. Actix-web no longer requires `ring` dependency.
+* MSRV is now 1.41.1
+
+### Fixed
+* `NormalizePath` improved consistency when path needs slashes added _and_ removed.
+
+
+## 3.0.0-alpha.3 - 2020-05-21
+### Added
+* Add option to create `Data<T>` from `Arc<T>` [#1509]
+
+### Changed
+* Resources and Scopes can now access non-overridden data types set on App (or containing scopes) when setting their own data. [#1486]
+* Fix audit issue logging by default peer address [#1485]
+* Bump minimum supported Rust version to 1.40
+* Replace deprecated `net2` crate with `socket2`
+
+[#1485]: https://github.com/actix/actix-web/pull/1485
+[#1509]: https://github.com/actix/actix-web/pull/1509
+
+## [3.0.0-alpha.2] - 2020-05-08
+
+### Changed
+
+* `{Resource,Scope}::default_service(f)` handlers now support app data extraction. [#1452]
+* Implement `std::error::Error` for our custom errors [#1422]
+* NormalizePath middleware now appends trailing / so that routes of form /example/ respond to /example requests. [#1433]
+* Remove the `failure` feature and support.
+
+[#1422]: https://github.com/actix/actix-web/pull/1422
+[#1433]: https://github.com/actix/actix-web/pull/1433
+[#1452]: https://github.com/actix/actix-web/pull/1452
+[#1486]: https://github.com/actix/actix-web/pull/1486
+
+
+## [3.0.0-alpha.1] - 2020-03-11
+
+### Added
+
+* Add helper function for creating routes with `TRACE` method guard `web::trace()`
+* Add convenience functions `test::read_body_json()` and `test::TestRequest::send_request()` for testing.
+
+### Changed
+
+* Use `sha-1` crate instead of unmaintained `sha1` crate
+* Skip empty chunks when returning response from a `Stream` [#1308]
+* Update the `time` dependency to 0.2.7
+* Update `actix-tls` dependency to 2.0.0-alpha.1
+* Update `rustls` dependency to 0.17
+
+[#1308]: https://github.com/actix/actix-web/pull/1308
+
+## [2.0.0] - 2019-12-25
 
 ### Changed
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "2.0.0"
+version = "3.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
@@ -11,7 +11,7 @@ documentation = "https://docs.rs/actix-web/"
 categories = ["network-programming", "asynchronous",
               "web-programming::http-server",
               "web-programming::websocket"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
@@ -30,11 +30,7 @@ members = [
   ".",
   "awc",
   "actix-http",
-  "actix-cors",
   "actix-files",
-  "actix-framed",
-  "actix-session",
-  "actix-identity",
   "actix-multipart",
   "actix-web-actors",
   "actix-web-codegen",
@@ -42,63 +38,78 @@ members = [
 ]
 
 [features]
-default = ["compress", "failure"]
+default = ["compress"]
 
 # content-encoding support
 compress = ["actix-http/compress", "awc/compress"]
 
-# sessions feature, session require "ring" crate and c compiler
+# sessions feature
 secure-cookies = ["actix-http/secure-cookies"]
 
-failure = ["actix-http/failure"]
-
 # openssl
 openssl = ["actix-tls/openssl", "awc/openssl", "open-ssl"]
 
 # rustls
 rustls = ["actix-tls/rustls", "awc/rustls", "rust-tls"]
 
+[[example]]
+name = "basic"
+required-features = ["compress"]
+
+[[example]]
+name = "uds"
+required-features = ["compress"]
+
+[[test]]
+name = "test_server"
+required-features = ["compress"]
+
 [dependencies]
-actix-codec = "0.2.0"
-actix-service = "1.0.1"
-actix-utils = "1.0.4"
-actix-router = "0.2.1"
-actix-rt = "1.0.0"
+actix-codec = "0.3.0"
+actix-service = "1.0.6"
+actix-utils = "2.0.0"
+actix-router = "0.2.4"
+actix-rt = "1.1.1"
 actix-server = "1.0.0"
 actix-testing = "1.0.0"
 actix-macros = "0.1.0"
 actix-threadpool = "0.3.1"
-actix-tls = "1.0.0"
+actix-tls = "2.0.0"
 
-actix-web-codegen = "0.2.0"
-actix-http = "1.0.1"
-awc = { version = "1.0.1", default-features = false }
+actix-web-codegen = "0.3.0"
+actix-http = "2.0.0"
+awc = { version = "2.0.0", default-features = false }
 
 bytes = "0.5.3"
 derive_more = "0.99.2"
 encoding_rs = "0.8"
-futures = "0.3.1"
+futures-channel = { version = "0.3.5", default-features = false }
+futures-core = { version = "0.3.5", default-features = false }
+futures-util = { version = "0.3.5", default-features = false }
 fxhash = "0.2.1"
 log = "0.4"
 mime = "0.3"
-net2 = "0.2.33"
-pin-project = "0.4.6"
+socket2 = "0.3"
+pin-project = "0.4.17"
 regex = "1.3"
-serde = { version = "1.0", features=["derive"] }
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.6.1"
-time = "0.1.42"
+time = { version = "0.2.7", default-features = false, features = ["std"] }
 url = "2.1"
-open-ssl = { version="0.10", package = "openssl", optional = true }
-rust-tls = { version = "0.16.0", package = "rustls", optional = true }
+open-ssl = { package = "openssl", version = "0.10", optional = true }
+rust-tls = { package = "rustls", version = "0.18.0", optional = true }
+tinyvec = { version = "0.3", features = ["alloc"] }
 
 [dev-dependencies]
-actix = "0.9.0"
+actix = "0.10.0"
+actix-http = { version = "2.0.0-beta.4", features = ["actors"] }
 rand = "0.7"
-env_logger = "0.6"
+env_logger = "0.7"
 serde_derive = "1.0"
 brotli2 = "0.3.2"
 flate2 = "1.0.13"
+criterion = "0.3"
 
 [profile.release]
 lto = true
@@ -110,9 +121,18 @@ actix-web = { path = "." }
 actix-http = { path = "actix-http" }
 actix-http-test = { path = "test-server" }
 actix-web-codegen = { path = "actix-web-codegen" }
-actix-cors = { path = "actix-cors" }
-actix-identity = { path = "actix-identity" }
-actix-session = { path = "actix-session" }
 actix-files = { path = "actix-files" }
 actix-multipart = { path = "actix-multipart" }
-awc = { path = "awc" }
+awc = { path = "awc" }
+
+[[example]]
+name = "client"
+required-features = ["rustls"]
+
+[[bench]]
+name = "server"
+harness = false
+
+[[bench]]
+name = "service"
+harness = false

LICENSE-APACHE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2017-NOW Nikolay Kim
+   Copyright 2017-NOW Actix Team
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2017 Nikolay Kim
+Copyright (c) 2017 Actix Team
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

MIGRATION.md

@@ -1,3 +1,49 @@
+## Unreleased
+
+
+## 3.0.0
+
+* Setting a cookie's SameSite property, explicitly, to `SameSite::None` will now
+  result in `SameSite=None` being sent with the response Set-Cookie header.
+  To create a cookie without a SameSite attribute, remove any calls setting same_site.
+
+* actix-http support for Actors messages was moved to actix-http crate and is enabled 
+  with feature `actors`
+* content_length function is removed from actix-http.
+  You can set Content-Length by normally setting the response body or calling no_chunking function. 
+
+* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
+  `u64` instead of a `usize`.
+
+* Code that was using `path.<index>` to access a `web::Path<(A, B, C)>`s elements now needs to use
+  destructuring or `.into_inner()`. For example:
+
+  ```rust
+  // Previously:
+  async fn some_route(path: web::Path<(String, String)>) -> String {
+    format!("Hello, {} {}", path.0, path.1)
+  }
+
+  // Now (this also worked before):
+  async fn some_route(path: web::Path<(String, String)>) -> String {
+    let (first_name, last_name) = path.into_inner();
+    format!("Hello, {} {}", first_name, last_name)
+  }
+  // Or (this wasn't previously supported):
+  async fn some_route(web::Path((first_name, last_name)): web::Path<(String, String)>) -> String {
+    format!("Hello, {} {}", first_name, last_name)
+  }
+  ```
+
+* `middleware::NormalizePath` can now also be configured to trim trailing slashes instead of always keeping one.
+  It will need `middleware::normalize::TrailingSlash` when being constructed with `NormalizePath::new(...)`,
+  or for an easier migration you can replace `wrap(middleware::NormalizePath)` with `wrap(middleware::NormalizePath::default())`.
+
+* `HttpServer::maxconn` is renamed to the more expressive `HttpServer::max_connections`.
+
+* `HttpServer::maxconnrate` is renamed to the more expressive `HttpServer::max_connection_rate`.
+
+
 ## 2.0.0
 
 * `HttpServer::start()` renamed to `HttpServer::run()`. It also possible to
@@ -14,6 +60,37 @@
 * `actix_http_test::TestServer` moved to `actix_web::test` module. To start
   test server use `test::start()` or `test_start_with_config()` methods
 
+* `ResponseError` trait has been reafctored. `ResponseError::error_response()` renders
+  http response.
+
+* Feature `rust-tls` renamed to `rustls`
+
+  instead of
+
+    ```rust
+    actix-web = { version = "2.0.0", features = ["rust-tls"] }
+    ```
+
+  use
+
+    ```rust
+    actix-web = { version = "2.0.0", features = ["rustls"] }
+    ```
+
+* Feature `ssl` renamed to `openssl`
+
+  instead of
+
+    ```rust
+    actix-web = { version = "2.0.0", features = ["ssl"] }
+    ```
+
+  use
+
+    ```rust
+    actix-web = { version = "2.0.0", features = ["openssl"] }
+    ```
+* `Cors` builder now requires that you call `.finish()` to construct the middleware
 
 ## 1.0.1
 
@@ -321,7 +398,7 @@
 
 * `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
 
-* StaticFiles and NamedFile has been move to separate create.
+* StaticFiles and NamedFile have been moved to a separate crate.
 
   instead of `use actix_web::fs::StaticFile`
 
@@ -331,7 +408,7 @@
 
   use `use actix_files::NamedFile`
 
-* Multipart has been move to separate create.
+* Multipart has been moved to a separate crate.
 
   instead of `use actix_web::multipart::Multipart`
 

README.md

@@ -1,55 +1,66 @@
 <div align="center">
- <p><h1>Actix web</h1> </p>
-  <p><strong>Actix web is a small, pragmatic, and extremely fast rust web framework</strong> </p>
+  <h1>Actix web</h1>
+  <p>
+    <strong>Actix web is a powerful, pragmatic, and extremely fast web framework for Rust</strong>
+  </p>
   <p>
 
+[![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web)
+[![Documentation](https://docs.rs/actix-web/badge.svg)](https://docs.rs/actix-web)
+[![Version](https://img.shields.io/badge/rustc-1.42+-ab6000.svg)](https://blog.rust-lang.org/2020/03/12/Rust-1.42.html)
+![License](https://img.shields.io/crates/l/actix-web.svg)
+<br />
 [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) 
 [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) 
-[![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web)
-[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Documentation](https://docs.rs/actix-web/badge.svg)](https://docs.rs/actix-web)
 [![Download](https://img.shields.io/crates/d/actix-web.svg)](https://crates.io/crates/actix-web)
-[![Version](https://img.shields.io/badge/rustc-1.39+-lightgray.svg)](https://blog.rust-lang.org/2019/11/07/Rust-1.39.0.html)
-![License](https://img.shields.io/crates/l/actix-web.svg)
+[![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
   </p>
-
-  <h3>
-    <a href="https://actix.rs">Website</a>
-    <span> | </span>
-    <a href="https://gitter.im/actix/actix">Chat</a>
-    <span> | </span>
-    <a href="https://github.com/actix/examples">Examples</a>
-  </h3>
 </div>
-<br>
 
-Actix web is a simple, pragmatic and extremely fast web framework for Rust.
+## Features
 
-* Supported *HTTP/1.x* and *HTTP/2.0* protocols
+* Supports *HTTP/1.x* and *HTTP/2*
 * Streaming and pipelining
 * Keep-alive and slow requests handling
 * Client/server [WebSockets](https://actix.rs/docs/websockets/) support
 * Transparent content compression/decompression (br, gzip, deflate)
-* Configurable [request routing](https://actix.rs/docs/url-dispatch/)
+* Powerful [request routing](https://actix.rs/docs/url-dispatch/)
 * Multipart streams
 * Static assets
-* SSL support with OpenSSL or Rustls
+* SSL support using OpenSSL or Rustls
 * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
+* Includes an async [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
 * Supports [Actix actor framework](https://github.com/actix/actix)
+* Runs on stable Rust 1.42+
+
+## Documentation
+
+* [Website & User Guide](https://actix.rs)
+* [Examples Repository](https://github.com/actix/examples)
+* [API Documentation](https://docs.rs/actix-web)
+* [API Documentation (master branch)](https://actix.rs/actix-web/actix_web)
 
 ## Example
 
+Dependencies:
+
+```toml
+[dependencies]
+actix-web = "3"
+```
+
+Code:
+
 ```rust
 use actix_web::{get, web, App, HttpServer, Responder};
 
 #[get("/{id}/{name}/index.html")]
-async fn index(info: web::Path<(u32, String)>) -> impl Responder {
-    format!("Hello {}! id:{}", info.1, info.0)
+async fn index(web::Path((id, name)): web::Path<(u32, String)>) -> impl Responder {
+    format!("Hello {}! id:{}", name, id)
 }
 
-#[actix_rt::main]
+#[actix_web::main]
 async fn main() -> std::io::Result<()> {
     HttpServer::new(|| App::new().service(index))
         .bind("127.0.0.1:8080")?
@@ -60,36 +71,39 @@ async fn main() -> std::io::Result<()> {
 
 ### More examples
 
-* [Basics](https://github.com/actix/examples/tree/master/basics/)
-* [Stateful](https://github.com/actix/examples/tree/master/state/)
-* [Multipart streams](https://github.com/actix/examples/tree/master/multipart/)
-* [Simple websocket](https://github.com/actix/examples/tree/master/websocket/)
-* [Tera](https://github.com/actix/examples/tree/master/template_tera/) /
-  [Askama](https://github.com/actix/examples/tree/master/template_askama/) templates
-* [Diesel integration](https://github.com/actix/examples/tree/master/diesel/)
-* [r2d2](https://github.com/actix/examples/tree/master/r2d2/)
-* [SSL / HTTP/2.0](https://github.com/actix/examples/tree/master/tls/)
-* [Tcp/Websocket chat](https://github.com/actix/examples/tree/master/websocket-chat/)
-* [Json](https://github.com/actix/examples/tree/master/json/)
+* [Basic Setup](https://github.com/actix/examples/tree/master/basics/)
+* [Application State](https://github.com/actix/examples/tree/master/state/)
+* [JSON Handling](https://github.com/actix/examples/tree/master/json/)
+* [Multipart Streams](https://github.com/actix/examples/tree/master/multipart/)
+* [Diesel Integration](https://github.com/actix/examples/tree/master/diesel/)
+* [r2d2 Integration](https://github.com/actix/examples/tree/master/r2d2/)
+* [Simple WebSocket](https://github.com/actix/examples/tree/master/websocket/)
+* [Tera Templates](https://github.com/actix/examples/tree/master/template_tera/)
+* [Askama Templates](https://github.com/actix/examples/tree/master/template_askama/)
+* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/rustls/)
+* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/openssl/)
+* [WebSocket Chat](https://github.com/actix/examples/tree/master/websocket-chat/)
 
 You may consider checking out
 [this directory](https://github.com/actix/examples/tree/master/) for more examples.
 
 ## Benchmarks
 
-* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r18)
+One of the fastest web frameworks available according to the
+[TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r19).
 
 ## License
 
 This project is licensed under either of
 
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
+* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+  [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or
+  [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
 
 at your option.
 
 ## Code of Conduct
 
-Contribution to the actix-web crate is organized under the terms of the
-Contributor Covenant, the maintainer of actix-web, @fafhrd91, promises to
-intervene to uphold that code of conduct.
+Contribution to the actix-web crate is organized under the terms of the Contributor Covenant, the
+maintainers of Actix web, promises to intervene to uphold that code of conduct.

actix-cors/CHANGES.md

@@ -1,15 +0,0 @@
-# Changes
-
-## [0.2.0] - 2019-12-20
-
-* Release
-
-## [0.2.0-alpha.3] - 2019-12-07
-
-* Migrate to actix-web 2.0.0
-
-* Bump `derive_more` crate version to 0.99.0
-
-## [0.1.0] - 2019-06-15
-
-* Move cors middleware to separate crate

actix-cors/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "actix-cors"
-version = "0.2.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Cross-origin resource sharing (CORS) for Actix applications."
-readme = "README.md"
-keywords = ["web", "framework"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-cors/"
-license = "MIT/Apache-2.0"
-edition = "2018"
-workspace = ".."
-
-[lib]
-name = "actix_cors"
-path = "src/lib.rs"
-
-[dependencies]
-actix-web = "2.0.0-rc"
-actix-service = "1.0.1"
-derive_more = "0.99.2"
-futures = "0.3.1"
-
-[dev-dependencies]
-actix-rt = "1.0.0"

actix-cors/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-cors/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-cors/README.md

@@ -1,9 +0,0 @@
-# Cors Middleware for actix web framework [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-cors)](https://crates.io/crates/actix-cors) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & community resources
-
-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-cors/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-cors](https://crates.io/crates/actix-cors)
-* Minimum supported Rust version: 1.34 or later

actix-files/CHANGES.md

@@ -1,5 +1,19 @@
 # Changes
 
+## [Unreleased] - 2020-xx-xx
+
+## [0.3.0-beta.1] - 2020-07-15
+* Update `v_htmlescape` to 0.10
+* Update `actix-web` and `actix-http` dependencies to beta.1
+
+## [0.3.0-alpha.1] - 2020-05-23
+* Update `actix-web` and `actix-http` dependencies to alpha
+* Fix some typos in the docs
+* Bump minimum supported Rust version to 1.40
+* Support sending Content-Length when Content-Range is specified [#1384]
+
+[#1384]: https://github.com/actix/actix-web/pull/1384
+
 ## [0.2.1] - 2019-12-22
 
 * Use the same format for file URLs regardless of platforms

actix-files/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.2.1"
+version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static files support for actix web."
 readme = "README.md"
@@ -9,28 +9,28 @@ homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
 documentation = "https://docs.rs/actix-files/"
 categories = ["asynchronous", "web-programming::http-server"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_files"
 path = "src/lib.rs"
 
 [dependencies]
-actix-web = { version = "2.0.0-rc", default-features = false }
-actix-http = "1.0.1"
-actix-service = "1.0.1"
+actix-web = { version = "3.0.0", default-features = false }
+actix-http = "2.0.0"
+actix-service = "1.0.6"
 bitflags = "1"
 bytes = "0.5.3"
-futures = "0.3.1"
+futures-core = { version = "0.3.5", default-features = false }
+futures-util = { version = "0.3.5", default-features = false }
 derive_more = "0.99.2"
 log = "0.4"
 mime = "0.3"
 mime_guess = "2.0.1"
 percent-encoding = "2.1"
-v_htmlescape = "0.4"
+v_htmlescape = "0.10"
 
 [dev-dependencies]
 actix-rt = "1.0.0"
-actix-web = { version = "2.0.0-rc", features=["openssl"] }
+actix-web = { version = "3.0.0", features = ["openssl"] }

actix-files/README.md

@@ -6,4 +6,4 @@
 * [API Documentation](https://docs.rs/actix-files/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-files](https://crates.io/crates/actix-files)
-* Minimum supported Rust version: 1.33 or later
+* Minimum supported Rust version: 1.40 or later

actix-files/src/error.rs

@@ -5,6 +5,7 @@ use derive_more::Display;
 #[derive(Display, Debug, PartialEq)]
 pub enum FilesError {
     /// Path is not a directory
+    #[allow(dead_code)]
     #[display(fmt = "Path is not a directory. Unable to serve static files")]
     IsNotDirectory,
 

actix-files/src/lib.rs

@@ -1,6 +1,8 @@
-#![allow(clippy::borrow_interior_mutable_const, clippy::type_complexity)]
-
 //! Static files support
+
+#![deny(rust_2018_idioms)]
+#![allow(clippy::borrow_interior_mutable_const)]
+
 use std::cell::RefCell;
 use std::fmt::Write;
 use std::fs::{DirEntry, File};
@@ -24,9 +26,8 @@ use actix_web::http::header::{self, DispositionType};
 use actix_web::http::Method;
 use actix_web::{web, FromRequest, HttpRequest, HttpResponse};
 use bytes::Bytes;
-use futures::future::{ok, ready, Either, FutureExt, LocalBoxFuture, Ready};
-use futures::Stream;
-use mime;
+use futures_core::Stream;
+use futures_util::future::{ok, ready, Either, FutureExt, LocalBoxFuture, Ready};
 use mime_guess::from_ext;
 use percent_encoding::{utf8_percent_encode, CONTROLS};
 use v_htmlescape::escape as escape_html_entity;
@@ -63,6 +64,7 @@ pub struct ChunkedReadFile {
     size: u64,
     offset: u64,
     file: Option<File>,
+    #[allow(clippy::type_complexity)]
     fut:
         Option<LocalBoxFuture<'static, Result<(File, Bytes), BlockingError<io::Error>>>>,
     counter: u64,
@@ -73,7 +75,7 @@ impl Stream for ChunkedReadFile {
 
     fn poll_next(
         mut self: Pin<&mut Self>,
-        cx: &mut Context,
+        cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         if let Some(ref mut fut) = self.fut {
             return match Pin::new(fut).poll(cx) {
@@ -225,7 +227,7 @@ fn directory_listing(
     ))
 }
 
-type MimeOverride = dyn Fn(&mime::Name) -> DispositionType;
+type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
 
 /// Static files handling
 ///
@@ -233,12 +235,10 @@ type MimeOverride = dyn Fn(&mime::Name) -> DispositionType;
 ///
 /// ```rust
 /// use actix_web::App;
-/// use actix_files as fs;
+/// use actix_files::Files;
 ///
-/// fn main() {
-///     let app = App::new()
-///         .service(fs::Files::new("/static", "."));
-/// }
+/// let app = App::new()
+///     .service(Files::new("/static", "."));
 /// ```
 pub struct Files {
     path: String,
@@ -250,6 +250,8 @@ pub struct Files {
     renderer: Rc<DirectoryRenderer>,
     mime_override: Option<Rc<MimeOverride>>,
     file_flags: named::Flags,
+    // FIXME: Should re-visit later.
+    #[allow(clippy::redundant_allocation)]
     guards: Option<Rc<Box<dyn Guard>>>,
 }
 
@@ -275,7 +277,7 @@ impl Files {
     ///
     /// `File` uses `ThreadPool` for blocking filesystem operations.
     /// By default pool with 5x threads of available cpus is used.
-    /// Pool size can be changed by setting ACTIX_CPU_POOL environment variable.
+    /// Pool size can be changed by setting ACTIX_THREADPOOL environment variable.
     pub fn new<T: Into<PathBuf>>(path: &str, dir: T) -> Files {
         let orig_dir = dir.into();
         let dir = match orig_dir.canonicalize() {
@@ -329,7 +331,7 @@ impl Files {
     /// Specifies mime override callback
     pub fn mime_override<F>(mut self, f: F) -> Self
     where
-        F: Fn(&mime::Name) -> DispositionType + 'static,
+        F: Fn(&mime::Name<'_>) -> DispositionType + 'static,
     {
         self.mime_override = Some(Rc::new(f));
         self
@@ -462,10 +464,13 @@ pub struct FilesService {
     renderer: Rc<DirectoryRenderer>,
     mime_override: Option<Rc<MimeOverride>>,
     file_flags: named::Flags,
+    // FIXME: Should re-visit later.
+    #[allow(clippy::redundant_allocation)]
     guards: Option<Rc<Box<dyn Guard>>>,
 }
 
 impl FilesService {
+    #[allow(clippy::type_complexity)]
     fn handle_err(
         &mut self,
         e: io::Error,
@@ -487,12 +492,13 @@ impl Service for FilesService {
     type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
+    #[allow(clippy::type_complexity)]
     type Future = Either<
         Ready<Result<Self::Response, Self::Error>>,
         LocalBoxFuture<'static, Result<Self::Response, Self::Error>>,
     >;
 
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -501,11 +507,8 @@ impl Service for FilesService {
             // execute user defined guards
             (**guard).check(req.head())
         } else {
-            // default behaviour
-            match *req.method() {
-                Method::HEAD | Method::GET => true,
-                _ => false,
-            }
+            // default behavior
+            matches!(*req.method(), Method::HEAD | Method::GET)
         };
 
         if !is_method_valid {
@@ -521,7 +524,7 @@ impl Service for FilesService {
             Err(e) => return Either::Left(ok(req.error_response(e))),
         };
 
-        // full filepath
+        // full file path
         let path = match self.directory.join(&real_path.0).canonicalize() {
             Ok(path) => path,
             Err(e) => return self.handle_err(e, req),
@@ -898,7 +901,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_mime_override() {
-        fn all_attachment(_: &mime::Name) -> DispositionType {
+        fn all_attachment(_: &mime::Name<'_>) -> DispositionType {
             DispositionType::Attachment
         }
 
@@ -952,135 +955,82 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_named_file_content_range_headers() {
-        let mut srv = test::init_service(
-            App::new().service(Files::new("/test", ".").index_file("tests/test.binary")),
-        )
-        .await;
+        let srv = test::start(|| App::new().service(Files::new("/", ".")));
 
         // Valid range header
-        let request = TestRequest::get()
-            .uri("/t%65st/tests/test.binary")
+        let response = srv
+            .get("/tests/test.binary")
             .header(header::RANGE, "bytes=10-20")
-            .to_request();
-
-        let response = test::call_service(&mut srv, request).await;
-        let contentrange = response
-            .headers()
-            .get(header::CONTENT_RANGE)
-            .unwrap()
-            .to_str()
+            .send()
+            .await
             .unwrap();
-
-        assert_eq!(contentrange, "bytes 10-20/100");
+        let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
+        assert_eq!(content_range.to_str().unwrap(), "bytes 10-20/100");
 
         // Invalid range header
-        let request = TestRequest::get()
-            .uri("/t%65st/tests/test.binary")
+        let response = srv
+            .get("/tests/test.binary")
             .header(header::RANGE, "bytes=10-5")
-            .to_request();
-        let response = test::call_service(&mut srv, request).await;
-
-        let contentrange = response
-            .headers()
-            .get(header::CONTENT_RANGE)
-            .unwrap()
-            .to_str()
+            .send()
+            .await
             .unwrap();
-
-        assert_eq!(contentrange, "bytes */100");
+        let content_range = response.headers().get(header::CONTENT_RANGE).unwrap();
+        assert_eq!(content_range.to_str().unwrap(), "bytes */100");
     }
 
     #[actix_rt::test]
     async fn test_named_file_content_length_headers() {
-        // use actix_web::body::{MessageBody, ResponseBody};
-
-        let mut srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
-        )
-        .await;
+        let srv = test::start(|| App::new().service(Files::new("/", ".")));
 
         // Valid range header
-        let request = TestRequest::get()
-            .uri("/t%65st/tests/test.binary")
+        let response = srv
+            .get("/tests/test.binary")
             .header(header::RANGE, "bytes=10-20")
-            .to_request();
-        let _response = test::call_service(&mut srv, request).await;
+            .send()
+            .await
+            .unwrap();
+        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
+        assert_eq!(content_length.to_str().unwrap(), "11");
 
-        // let contentlength = response
-        //     .headers()
-        //     .get(header::CONTENT_LENGTH)
-        //     .unwrap()
-        //     .to_str()
-        //     .unwrap();
-        // assert_eq!(contentlength, "11");
-
-        // Invalid range header
-        let request = TestRequest::get()
-            .uri("/t%65st/tests/test.binary")
-            .header(header::RANGE, "bytes=10-8")
-            .to_request();
-        let response = test::call_service(&mut srv, request).await;
-        assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
+        // Valid range header, starting from 0
+        let response = srv
+            .get("/tests/test.binary")
+            .header(header::RANGE, "bytes=0-20")
+            .send()
+            .await
+            .unwrap();
+        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
+        assert_eq!(content_length.to_str().unwrap(), "21");
 
         // Without range header
-        let request = TestRequest::get()
-            .uri("/t%65st/tests/test.binary")
-            // .no_default_headers()
-            .to_request();
-        let _response = test::call_service(&mut srv, request).await;
+        let mut response = srv.get("/tests/test.binary").send().await.unwrap();
+        let content_length = response.headers().get(header::CONTENT_LENGTH).unwrap();
+        assert_eq!(content_length.to_str().unwrap(), "100");
 
-        // let contentlength = response
-        //     .headers()
-        //     .get(header::CONTENT_LENGTH)
-        //     .unwrap()
-        //     .to_str()
-        //     .unwrap();
-        // assert_eq!(contentlength, "100");
+        // Should be no transfer-encoding
+        let transfer_encoding = response.headers().get(header::TRANSFER_ENCODING);
+        assert!(transfer_encoding.is_none());
 
-        // chunked
-        let request = TestRequest::get()
-            .uri("/t%65st/tests/test.binary")
-            .to_request();
-        let response = test::call_service(&mut srv, request).await;
-
-        // with enabled compression
-        // {
-        //     let te = response
-        //         .headers()
-        //         .get(header::TRANSFER_ENCODING)
-        //         .unwrap()
-        //         .to_str()
-        //         .unwrap();
-        //     assert_eq!(te, "chunked");
-        // }
-
-        let bytes = test::read_body(response).await;
+        // Check file contents
+        let bytes = response.body().await.unwrap();
         let data = Bytes::from(fs::read("tests/test.binary").unwrap());
         assert_eq!(bytes, data);
     }
 
     #[actix_rt::test]
     async fn test_head_content_length_headers() {
-        let mut srv = test::init_service(
-            App::new().service(Files::new("test", ".").index_file("tests/test.binary")),
-        )
-        .await;
+        let srv = test::start(|| App::new().service(Files::new("/", ".")));
 
-        // Valid range header
-        let request = TestRequest::default()
-            .method(Method::HEAD)
-            .uri("/t%65st/tests/test.binary")
-            .to_request();
-        let _response = test::call_service(&mut srv, request).await;
+        let response = srv.head("/tests/test.binary").send().await.unwrap();
 
-        // TODO: fix check
-        // let contentlength = response
-        //     .headers()
-        //     .get(header::CONTENT_LENGTH)
-        //     .unwrap()
-        //     .to_str()
-        //     .unwrap();
-        // assert_eq!(contentlength, "100");
+        let content_length = response
+            .headers()
+            .get(header::CONTENT_LENGTH)
+            .unwrap()
+            .to_str()
+            .unwrap();
+
+        assert_eq!(content_length, "100");
     }
 
     #[actix_rt::test]
@@ -1140,12 +1090,10 @@ mod tests {
     #[actix_rt::test]
     async fn test_named_file_content_encoding() {
         let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
-            web::resource("/").to(|| {
-                async {
-                    NamedFile::open("Cargo.toml")
-                        .unwrap()
-                        .set_content_encoding(header::ContentEncoding::Identity)
-                }
+            web::resource("/").to(|| async {
+                NamedFile::open("Cargo.toml")
+                    .unwrap()
+                    .set_content_encoding(header::ContentEncoding::Identity)
             }),
         ))
         .await;
@@ -1162,12 +1110,10 @@ mod tests {
     #[actix_rt::test]
     async fn test_named_file_content_encoding_gzip() {
         let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
-            web::resource("/").to(|| {
-                async {
-                    NamedFile::open("Cargo.toml")
-                        .unwrap()
-                        .set_content_encoding(header::ContentEncoding::Gzip)
-                }
+            web::resource("/").to(|| async {
+                NamedFile::open("Cargo.toml")
+                    .unwrap()
+                    .set_content_encoding(header::ContentEncoding::Gzip)
             }),
         ))
         .await;

actix-files/src/named.rs

@@ -8,7 +8,6 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use std::os::unix::fs::MetadataExt;
 
 use bitflags::bitflags;
-use mime;
 use mime_guess::from_path;
 
 use actix_http::body::SizedStream;
@@ -18,7 +17,7 @@ use actix_web::http::header::{
 };
 use actix_web::http::{ContentEncoding, StatusCode};
 use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse, Responder};
-use futures::future::{ready, Ready};
+use futures_util::future::{ready, Ready};
 
 use crate::range::HttpRange;
 use crate::ChunkedReadFile;
@@ -90,7 +89,7 @@ impl NamedFile {
             };
 
             let ct = from_path(&path).first_or_octet_stream();
-            let disposition_type = match ct.type_() {
+            let disposition = match ct.type_() {
                 mime::IMAGE | mime::TEXT | mime::VIDEO => DispositionType::Inline,
                 _ => DispositionType::Attachment,
             };
@@ -104,8 +103,8 @@ impl NamedFile {
                 }))
             }
             let cd = ContentDisposition {
-                disposition: disposition_type,
-                parameters: parameters,
+                disposition,
+                parameters,
             };
             (ct, cd)
         };
@@ -388,11 +387,12 @@ impl NamedFile {
             fut: None,
             counter: 0,
         };
+
         if offset != 0 || length != self.md.len() {
-            Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader))
-        } else {
-            Ok(resp.body(SizedStream::new(length, reader)))
+            resp.status(StatusCode::PARTIAL_CONTENT);
         }
+
+        Ok(resp.body(SizedStream::new(length, reader)))
     }
 }
 

actix-framed/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-name = "actix-framed"
-version = "0.3.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix framed app server"
-readme = "README.md"
-keywords = ["http", "web", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-framed/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
-license = "MIT/Apache-2.0"
-edition = "2018"
-
-[lib]
-name = "actix_framed"
-path = "src/lib.rs"
-
-[dependencies]
-actix-codec = "0.2.0"
-actix-service = "1.0.1"
-actix-router = "0.2.1"
-actix-rt = "1.0.0"
-actix-http = "1.0.1"
-
-bytes = "0.5.3"
-futures = "0.3.1"
-pin-project = "0.4.6"
-log = "0.4"
-
-[dev-dependencies]
-actix-server = "1.0.0"
-actix-connect = { version = "1.0.0", features=["openssl"] }
-actix-http-test = { version = "1.0.0", features=["openssl"] }
-actix-utils = "1.0.3"

actix-framed/LICENSE-APACHE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2017-NOW Nikolay Kim
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

actix-framed/LICENSE-MIT

@@ -1,25 +0,0 @@
-Copyright (c) 2017 Nikolay Kim
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

actix-framed/README.md

@@ -1,8 +0,0 @@
-# Framed app for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-framed)](https://crates.io/crates/actix-framed) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & community resources
-
-* [API Documentation](https://docs.rs/actix-framed/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-framed](https://crates.io/crates/actix-framed)
-* Minimum supported Rust version: 1.33 or later

actix-framed/changes.md

@@ -1,24 +0,0 @@
-# Changes
-
-## [0.3.0] - 2019-12-25
-
-* Migrate to actix-http 1.0
-
-## [0.2.1] - 2019-07-20
-
-* Remove unneeded actix-utils dependency
-
-
-## [0.2.0] - 2019-05-12
-
-* Update dependencies
-
-
-## [0.1.0] - 2019-04-16
-
-* Update tests
-
-
-## [0.1.0-alpha.1] - 2019-04-12
-
-* Initial release

actix-framed/src/app.rs

@@ -1,221 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_http::h1::{Codec, SendResponse};
-use actix_http::{Error, Request, Response};
-use actix_router::{Path, Router, Url};
-use actix_service::{IntoServiceFactory, Service, ServiceFactory};
-use futures::future::{ok, FutureExt, LocalBoxFuture};
-
-use crate::helpers::{BoxedHttpNewService, BoxedHttpService, HttpNewService};
-use crate::request::FramedRequest;
-use crate::state::State;
-
-type BoxedResponse = LocalBoxFuture<'static, Result<(), Error>>;
-
-pub trait HttpServiceFactory {
-    type Factory: ServiceFactory;
-
-    fn path(&self) -> &str;
-
-    fn create(self) -> Self::Factory;
-}
-
-/// Application builder
-pub struct FramedApp<T, S = ()> {
-    state: State<S>,
-    services: Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>,
-}
-
-impl<T: 'static> FramedApp<T, ()> {
-    pub fn new() -> Self {
-        FramedApp {
-            state: State::new(()),
-            services: Vec::new(),
-        }
-    }
-}
-
-impl<T: 'static, S: 'static> FramedApp<T, S> {
-    pub fn with(state: S) -> FramedApp<T, S> {
-        FramedApp {
-            services: Vec::new(),
-            state: State::new(state),
-        }
-    }
-
-    pub fn service<U>(mut self, factory: U) -> Self
-    where
-        U: HttpServiceFactory,
-        U::Factory: ServiceFactory<
-                Config = (),
-                Request = FramedRequest<T, S>,
-                Response = (),
-                Error = Error,
-                InitError = (),
-            > + 'static,
-        <U::Factory as ServiceFactory>::Future: 'static,
-        <U::Factory as ServiceFactory>::Service: Service<
-            Request = FramedRequest<T, S>,
-            Response = (),
-            Error = Error,
-            Future = LocalBoxFuture<'static, Result<(), Error>>,
-        >,
-    {
-        let path = factory.path().to_string();
-        self.services
-            .push((path, Box::new(HttpNewService::new(factory.create()))));
-        self
-    }
-}
-
-impl<T, S> IntoServiceFactory<FramedAppFactory<T, S>> for FramedApp<T, S>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-    S: 'static,
-{
-    fn into_factory(self) -> FramedAppFactory<T, S> {
-        FramedAppFactory {
-            state: self.state,
-            services: Rc::new(self.services),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct FramedAppFactory<T, S> {
-    state: State<S>,
-    services: Rc<Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>>,
-}
-
-impl<T, S> ServiceFactory for FramedAppFactory<T, S>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-    S: 'static,
-{
-    type Config = ();
-    type Request = (Request, Framed<T, Codec>);
-    type Response = ();
-    type Error = Error;
-    type InitError = ();
-    type Service = FramedAppService<T, S>;
-    type Future = CreateService<T, S>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        CreateService {
-            fut: self
-                .services
-                .iter()
-                .map(|(path, service)| {
-                    CreateServiceItem::Future(
-                        Some(path.clone()),
-                        service.new_service(()),
-                    )
-                })
-                .collect(),
-            state: self.state.clone(),
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct CreateService<T, S> {
-    fut: Vec<CreateServiceItem<T, S>>,
-    state: State<S>,
-}
-
-enum CreateServiceItem<T, S> {
-    Future(
-        Option<String>,
-        LocalBoxFuture<'static, Result<BoxedHttpService<FramedRequest<T, S>>, ()>>,
-    ),
-    Service(String, BoxedHttpService<FramedRequest<T, S>>),
-}
-
-impl<S: 'static, T: 'static> Future for CreateService<T, S>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    type Output = Result<FramedAppService<T, S>, ()>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        let mut done = true;
-
-        // poll http services
-        for item in &mut self.fut {
-            let res = match item {
-                CreateServiceItem::Future(ref mut path, ref mut fut) => {
-                    match Pin::new(fut).poll(cx) {
-                        Poll::Ready(Ok(service)) => {
-                            Some((path.take().unwrap(), service))
-                        }
-                        Poll::Ready(Err(e)) => return Poll::Ready(Err(e)),
-                        Poll::Pending => {
-                            done = false;
-                            None
-                        }
-                    }
-                }
-                CreateServiceItem::Service(_, _) => continue,
-            };
-
-            if let Some((path, service)) = res {
-                *item = CreateServiceItem::Service(path, service);
-            }
-        }
-
-        if done {
-            let router = self
-                .fut
-                .drain(..)
-                .fold(Router::build(), |mut router, item| {
-                    match item {
-                        CreateServiceItem::Service(path, service) => {
-                            router.path(&path, service);
-                        }
-                        CreateServiceItem::Future(_, _) => unreachable!(),
-                    }
-                    router
-                });
-            Poll::Ready(Ok(FramedAppService {
-                router: router.finish(),
-                state: self.state.clone(),
-            }))
-        } else {
-            Poll::Pending
-        }
-    }
-}
-
-pub struct FramedAppService<T, S> {
-    state: State<S>,
-    router: Router<BoxedHttpService<FramedRequest<T, S>>>,
-}
-
-impl<S: 'static, T: 'static> Service for FramedAppService<T, S>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    type Request = (Request, Framed<T, Codec>);
-    type Response = ();
-    type Error = Error;
-    type Future = BoxedResponse;
-
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
-        let mut path = Path::new(Url::new(req.uri().clone()));
-
-        if let Some((srv, _info)) = self.router.recognize_mut(&mut path) {
-            return srv.call(FramedRequest::new(req, framed, path, self.state.clone()));
-        }
-        SendResponse::new(framed, Response::NotFound().finish())
-            .then(|_| ok(()))
-            .boxed_local()
-    }
-}

actix-framed/src/helpers.rs

@@ -1,98 +0,0 @@
-use std::task::{Context, Poll};
-
-use actix_http::Error;
-use actix_service::{Service, ServiceFactory};
-use futures::future::{FutureExt, LocalBoxFuture};
-
-pub(crate) type BoxedHttpService<Req> = Box<
-    dyn Service<
-        Request = Req,
-        Response = (),
-        Error = Error,
-        Future = LocalBoxFuture<'static, Result<(), Error>>,
-    >,
->;
-
-pub(crate) type BoxedHttpNewService<Req> = Box<
-    dyn ServiceFactory<
-        Config = (),
-        Request = Req,
-        Response = (),
-        Error = Error,
-        InitError = (),
-        Service = BoxedHttpService<Req>,
-        Future = LocalBoxFuture<'static, Result<BoxedHttpService<Req>, ()>>,
-    >,
->;
-
-pub(crate) struct HttpNewService<T: ServiceFactory>(T);
-
-impl<T> HttpNewService<T>
-where
-    T: ServiceFactory<Response = (), Error = Error>,
-    T::Response: 'static,
-    T::Future: 'static,
-    T::Service: Service<Future = LocalBoxFuture<'static, Result<(), Error>>> + 'static,
-    <T::Service as Service>::Future: 'static,
-{
-    pub fn new(service: T) -> Self {
-        HttpNewService(service)
-    }
-}
-
-impl<T> ServiceFactory for HttpNewService<T>
-where
-    T: ServiceFactory<Config = (), Response = (), Error = Error>,
-    T::Request: 'static,
-    T::Future: 'static,
-    T::Service: Service<Future = LocalBoxFuture<'static, Result<(), Error>>> + 'static,
-    <T::Service as Service>::Future: 'static,
-{
-    type Config = ();
-    type Request = T::Request;
-    type Response = ();
-    type Error = Error;
-    type InitError = ();
-    type Service = BoxedHttpService<T::Request>;
-    type Future = LocalBoxFuture<'static, Result<Self::Service, ()>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        let fut = self.0.new_service(());
-
-        async move {
-            fut.await.map_err(|_| ()).map(|service| {
-                let service: BoxedHttpService<_> =
-                    Box::new(HttpServiceWrapper { service });
-                service
-            })
-        }
-        .boxed_local()
-    }
-}
-
-struct HttpServiceWrapper<T: Service> {
-    service: T,
-}
-
-impl<T> Service for HttpServiceWrapper<T>
-where
-    T: Service<
-        Response = (),
-        Future = LocalBoxFuture<'static, Result<(), Error>>,
-        Error = Error,
-    >,
-    T::Request: 'static,
-{
-    type Request = T::Request;
-    type Response = ();
-    type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<(), Error>>;
-
-    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(cx)
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        self.service.call(req)
-    }
-}

actix-framed/src/lib.rs

@@ -1,17 +0,0 @@
-#![allow(clippy::type_complexity, clippy::new_without_default, dead_code)]
-mod app;
-mod helpers;
-mod request;
-mod route;
-mod service;
-mod state;
-pub mod test;
-
-// re-export for convinience
-pub use actix_http::{http, Error, HttpMessage, Response, ResponseError};
-
-pub use self::app::{FramedApp, FramedAppService};
-pub use self::request::FramedRequest;
-pub use self::route::FramedRoute;
-pub use self::service::{SendError, VerifyWebSockets};
-pub use self::state::State;

actix-framed/src/request.rs

@@ -1,172 +0,0 @@
-use std::cell::{Ref, RefMut};
-
-use actix_codec::Framed;
-use actix_http::http::{HeaderMap, Method, Uri, Version};
-use actix_http::{h1::Codec, Extensions, Request, RequestHead};
-use actix_router::{Path, Url};
-
-use crate::state::State;
-
-pub struct FramedRequest<Io, S = ()> {
-    req: Request,
-    framed: Framed<Io, Codec>,
-    state: State<S>,
-    pub(crate) path: Path<Url>,
-}
-
-impl<Io, S> FramedRequest<Io, S> {
-    pub fn new(
-        req: Request,
-        framed: Framed<Io, Codec>,
-        path: Path<Url>,
-        state: State<S>,
-    ) -> Self {
-        Self {
-            req,
-            framed,
-            state,
-            path,
-        }
-    }
-}
-
-impl<Io, S> FramedRequest<Io, S> {
-    /// Split request into a parts
-    pub fn into_parts(self) -> (Request, Framed<Io, Codec>, State<S>) {
-        (self.req, self.framed, self.state)
-    }
-
-    /// This method returns reference to the request head
-    #[inline]
-    pub fn head(&self) -> &RequestHead {
-        self.req.head()
-    }
-
-    /// This method returns muttable reference to the request head.
-    /// panics if multiple references of http request exists.
-    #[inline]
-    pub fn head_mut(&mut self) -> &mut RequestHead {
-        self.req.head_mut()
-    }
-
-    /// Shared application state
-    #[inline]
-    pub fn state(&self) -> &S {
-        self.state.get_ref()
-    }
-
-    /// Request's uri.
-    #[inline]
-    pub fn uri(&self) -> &Uri {
-        &self.head().uri
-    }
-
-    /// Read the Request method.
-    #[inline]
-    pub fn method(&self) -> &Method {
-        &self.head().method
-    }
-
-    /// Read the Request Version.
-    #[inline]
-    pub fn version(&self) -> Version {
-        self.head().version
-    }
-
-    #[inline]
-    /// Returns request's headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    /// The target path of this Request.
-    #[inline]
-    pub fn path(&self) -> &str {
-        self.head().uri.path()
-    }
-
-    /// The query string in the URL.
-    ///
-    /// E.g., id=10
-    #[inline]
-    pub fn query_string(&self) -> &str {
-        if let Some(query) = self.uri().query().as_ref() {
-            query
-        } else {
-            ""
-        }
-    }
-
-    /// Get a reference to the Path parameters.
-    ///
-    /// Params is a container for url parameters.
-    /// A variable segment is specified in the form `{identifier}`,
-    /// where the identifier can be used later in a request handler to
-    /// access the matched value for that segment.
-    #[inline]
-    pub fn match_info(&self) -> &Path<Url> {
-        &self.path
-    }
-
-    /// Request extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<Extensions> {
-        self.head().extensions()
-    }
-
-    /// Mutable reference to a the request's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<Extensions> {
-        self.head().extensions_mut()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::convert::TryFrom;
-
-    use actix_http::http::{HeaderName, HeaderValue};
-    use actix_http::test::{TestBuffer, TestRequest};
-
-    use super::*;
-
-    #[test]
-    fn test_reqest() {
-        let buf = TestBuffer::empty();
-        let framed = Framed::new(buf, Codec::default());
-        let req = TestRequest::with_uri("/index.html?q=1")
-            .header("content-type", "test")
-            .finish();
-        let path = Path::new(Url::new(req.uri().clone()));
-
-        let mut freq = FramedRequest::new(req, framed, path, State::new(10u8));
-        assert_eq!(*freq.state(), 10);
-        assert_eq!(freq.version(), Version::HTTP_11);
-        assert_eq!(freq.method(), Method::GET);
-        assert_eq!(freq.path(), "/index.html");
-        assert_eq!(freq.query_string(), "q=1");
-        assert_eq!(
-            freq.headers()
-                .get("content-type")
-                .unwrap()
-                .to_str()
-                .unwrap(),
-            "test"
-        );
-
-        freq.head_mut().headers.insert(
-            HeaderName::try_from("x-hdr").unwrap(),
-            HeaderValue::from_static("test"),
-        );
-        assert_eq!(
-            freq.headers().get("x-hdr").unwrap().to_str().unwrap(),
-            "test"
-        );
-
-        freq.extensions_mut().insert(100usize);
-        assert_eq!(*freq.extensions().get::<usize>().unwrap(), 100usize);
-
-        let (_, _, state) = freq.into_parts();
-        assert_eq!(*state, 10);
-    }
-}

actix-framed/src/route.rs

@@ -1,159 +0,0 @@
-use std::fmt;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::task::{Context, Poll};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_http::{http::Method, Error};
-use actix_service::{Service, ServiceFactory};
-use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
-use log::error;
-
-use crate::app::HttpServiceFactory;
-use crate::request::FramedRequest;
-
-/// Resource route definition
-///
-/// Route uses builder-like pattern for configuration.
-/// If handler is not explicitly set, default *404 Not Found* handler is used.
-pub struct FramedRoute<Io, S, F = (), R = (), E = ()> {
-    handler: F,
-    pattern: String,
-    methods: Vec<Method>,
-    state: PhantomData<(Io, S, R, E)>,
-}
-
-impl<Io, S> FramedRoute<Io, S> {
-    pub fn new(pattern: &str) -> Self {
-        FramedRoute {
-            handler: (),
-            pattern: pattern.to_string(),
-            methods: Vec::new(),
-            state: PhantomData,
-        }
-    }
-
-    pub fn get(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::GET)
-    }
-
-    pub fn post(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::POST)
-    }
-
-    pub fn put(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::PUT)
-    }
-
-    pub fn delete(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::DELETE)
-    }
-
-    pub fn method(mut self, method: Method) -> Self {
-        self.methods.push(method);
-        self
-    }
-
-    pub fn to<F, R, E>(self, handler: F) -> FramedRoute<Io, S, F, R, E>
-    where
-        F: FnMut(FramedRequest<Io, S>) -> R,
-        R: Future<Output = Result<(), E>> + 'static,
-
-        E: fmt::Debug,
-    {
-        FramedRoute {
-            handler,
-            pattern: self.pattern,
-            methods: self.methods,
-            state: PhantomData,
-        }
-    }
-}
-
-impl<Io, S, F, R, E> HttpServiceFactory for FramedRoute<Io, S, F, R, E>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
-    R: Future<Output = Result<(), E>> + 'static,
-    E: fmt::Display,
-{
-    type Factory = FramedRouteFactory<Io, S, F, R, E>;
-
-    fn path(&self) -> &str {
-        &self.pattern
-    }
-
-    fn create(self) -> Self::Factory {
-        FramedRouteFactory {
-            handler: self.handler,
-            methods: self.methods,
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct FramedRouteFactory<Io, S, F, R, E> {
-    handler: F,
-    methods: Vec<Method>,
-    _t: PhantomData<(Io, S, R, E)>,
-}
-
-impl<Io, S, F, R, E> ServiceFactory for FramedRouteFactory<Io, S, F, R, E>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
-    R: Future<Output = Result<(), E>> + 'static,
-    E: fmt::Display,
-{
-    type Config = ();
-    type Request = FramedRequest<Io, S>;
-    type Response = ();
-    type Error = Error;
-    type InitError = ();
-    type Service = FramedRouteService<Io, S, F, R, E>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(FramedRouteService {
-            handler: self.handler.clone(),
-            methods: self.methods.clone(),
-            _t: PhantomData,
-        })
-    }
-}
-
-pub struct FramedRouteService<Io, S, F, R, E> {
-    handler: F,
-    methods: Vec<Method>,
-    _t: PhantomData<(Io, S, R, E)>,
-}
-
-impl<Io, S, F, R, E> Service for FramedRouteService<Io, S, F, R, E>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
-    R: Future<Output = Result<(), E>> + 'static,
-    E: fmt::Display,
-{
-    type Request = FramedRequest<Io, S>;
-    type Response = ();
-    type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<(), Error>>;
-
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: FramedRequest<Io, S>) -> Self::Future {
-        let fut = (self.handler)(req);
-
-        async move {
-            let res = fut.await;
-            if let Err(e) = res {
-                error!("Error in request handler: {}", e);
-            }
-            Ok(())
-        }
-        .boxed_local()
-    }
-}

actix-framed/src/service.rs

@@ -1,156 +0,0 @@
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_http::body::BodySize;
-use actix_http::error::ResponseError;
-use actix_http::h1::{Codec, Message};
-use actix_http::ws::{verify_handshake, HandshakeError};
-use actix_http::{Request, Response};
-use actix_service::{Service, ServiceFactory};
-use futures::future::{err, ok, Either, Ready};
-use futures::Future;
-
-/// Service that verifies incoming request if it is valid websocket
-/// upgrade request. In case of error returns `HandshakeError`
-pub struct VerifyWebSockets<T, C> {
-    _t: PhantomData<(T, C)>,
-}
-
-impl<T, C> Default for VerifyWebSockets<T, C> {
-    fn default() -> Self {
-        VerifyWebSockets { _t: PhantomData }
-    }
-}
-
-impl<T, C> ServiceFactory for VerifyWebSockets<T, C> {
-    type Config = C;
-    type Request = (Request, Framed<T, Codec>);
-    type Response = (Request, Framed<T, Codec>);
-    type Error = (HandshakeError, Framed<T, Codec>);
-    type InitError = ();
-    type Service = VerifyWebSockets<T, C>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: C) -> Self::Future {
-        ok(VerifyWebSockets { _t: PhantomData })
-    }
-}
-
-impl<T, C> Service for VerifyWebSockets<T, C> {
-    type Request = (Request, Framed<T, Codec>);
-    type Response = (Request, Framed<T, Codec>);
-    type Error = (HandshakeError, Framed<T, Codec>);
-    type Future = Ready<Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
-        match verify_handshake(req.head()) {
-            Err(e) => err((e, framed)),
-            Ok(_) => ok((req, framed)),
-        }
-    }
-}
-
-/// Send http/1 error response
-pub struct SendError<T, R, E, C>(PhantomData<(T, R, E, C)>);
-
-impl<T, R, E, C> Default for SendError<T, R, E, C>
-where
-    T: AsyncRead + AsyncWrite,
-    E: ResponseError,
-{
-    fn default() -> Self {
-        SendError(PhantomData)
-    }
-}
-
-impl<T, R, E, C> ServiceFactory for SendError<T, R, E, C>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-    R: 'static,
-    E: ResponseError + 'static,
-{
-    type Config = C;
-    type Request = Result<R, (E, Framed<T, Codec>)>;
-    type Response = R;
-    type Error = (E, Framed<T, Codec>);
-    type InitError = ();
-    type Service = SendError<T, R, E, C>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: C) -> Self::Future {
-        ok(SendError(PhantomData))
-    }
-}
-
-impl<T, R, E, C> Service for SendError<T, R, E, C>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-    R: 'static,
-    E: ResponseError + 'static,
-{
-    type Request = Result<R, (E, Framed<T, Codec>)>;
-    type Response = R;
-    type Error = (E, Framed<T, Codec>);
-    type Future = Either<Ready<Result<R, (E, Framed<T, Codec>)>>, SendErrorFut<T, R, E>>;
-
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: Result<R, (E, Framed<T, Codec>)>) -> Self::Future {
-        match req {
-            Ok(r) => Either::Left(ok(r)),
-            Err((e, framed)) => {
-                let res = e.error_response().drop_body();
-                Either::Right(SendErrorFut {
-                    framed: Some(framed),
-                    res: Some((res, BodySize::Empty).into()),
-                    err: Some(e),
-                    _t: PhantomData,
-                })
-            }
-        }
-    }
-}
-
-#[pin_project::pin_project]
-pub struct SendErrorFut<T, R, E> {
-    res: Option<Message<(Response<()>, BodySize)>>,
-    framed: Option<Framed<T, Codec>>,
-    err: Option<E>,
-    _t: PhantomData<R>,
-}
-
-impl<T, R, E> Future for SendErrorFut<T, R, E>
-where
-    E: ResponseError,
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    type Output = Result<R, (E, Framed<T, Codec>)>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        if let Some(res) = self.res.take() {
-            if self.framed.as_mut().unwrap().write(res).is_err() {
-                return Poll::Ready(Err((
-                    self.err.take().unwrap(),
-                    self.framed.take().unwrap(),
-                )));
-            }
-        }
-        match self.framed.as_mut().unwrap().flush(cx) {
-            Poll::Ready(Ok(_)) => {
-                Poll::Ready(Err((self.err.take().unwrap(), self.framed.take().unwrap())))
-            }
-            Poll::Ready(Err(_)) => {
-                Poll::Ready(Err((self.err.take().unwrap(), self.framed.take().unwrap())))
-            }
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}

actix-framed/src/state.rs

@@ -1,29 +0,0 @@
-use std::ops::Deref;
-use std::sync::Arc;
-
-/// Application state
-pub struct State<S>(Arc<S>);
-
-impl<S> State<S> {
-    pub fn new(state: S) -> State<S> {
-        State(Arc::new(state))
-    }
-
-    pub fn get_ref(&self) -> &S {
-        self.0.as_ref()
-    }
-}
-
-impl<S> Deref for State<S> {
-    type Target = S;
-
-    fn deref(&self) -> &S {
-        self.0.as_ref()
-    }
-}
-
-impl<S> Clone for State<S> {
-    fn clone(&self) -> State<S> {
-        State(self.0.clone())
-    }
-}

actix-framed/src/test.rs

@@ -1,155 +0,0 @@
-//! Various helpers for Actix applications to use during testing.
-use std::convert::TryFrom;
-use std::future::Future;
-
-use actix_codec::Framed;
-use actix_http::h1::Codec;
-use actix_http::http::header::{Header, HeaderName, IntoHeaderValue};
-use actix_http::http::{Error as HttpError, Method, Uri, Version};
-use actix_http::test::{TestBuffer, TestRequest as HttpTestRequest};
-use actix_router::{Path, Url};
-
-use crate::{FramedRequest, State};
-
-/// Test `Request` builder.
-pub struct TestRequest<S = ()> {
-    req: HttpTestRequest,
-    path: Path<Url>,
-    state: State<S>,
-}
-
-impl Default for TestRequest<()> {
-    fn default() -> TestRequest {
-        TestRequest {
-            req: HttpTestRequest::default(),
-            path: Path::new(Url::new(Uri::default())),
-            state: State::new(()),
-        }
-    }
-}
-
-impl TestRequest<()> {
-    /// Create TestRequest and set request uri
-    pub fn with_uri(path: &str) -> Self {
-        Self::get().uri(path)
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_hdr<H: Header>(hdr: H) -> Self {
-        Self::default().set(hdr)
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_header<K, V>(key: K, value: V) -> Self
-    where
-        HeaderName: TryFrom<K>,
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
-        V: IntoHeaderValue,
-    {
-        Self::default().header(key, value)
-    }
-
-    /// Create TestRequest and set method to `Method::GET`
-    pub fn get() -> Self {
-        Self::default().method(Method::GET)
-    }
-
-    /// Create TestRequest and set method to `Method::POST`
-    pub fn post() -> Self {
-        Self::default().method(Method::POST)
-    }
-}
-
-impl<S> TestRequest<S> {
-    /// Create TestRequest and set request uri
-    pub fn with_state(state: S) -> TestRequest<S> {
-        let req = TestRequest::get();
-        TestRequest {
-            state: State::new(state),
-            req: req.req,
-            path: req.path,
-        }
-    }
-
-    /// Set HTTP version of this request
-    pub fn version(mut self, ver: Version) -> Self {
-        self.req.version(ver);
-        self
-    }
-
-    /// Set HTTP method of this request
-    pub fn method(mut self, meth: Method) -> Self {
-        self.req.method(meth);
-        self
-    }
-
-    /// Set HTTP Uri of this request
-    pub fn uri(mut self, path: &str) -> Self {
-        self.req.uri(path);
-        self
-    }
-
-    /// Set a header
-    pub fn set<H: Header>(mut self, hdr: H) -> Self {
-        self.req.set(hdr);
-        self
-    }
-
-    /// Set a header
-    pub fn header<K, V>(mut self, key: K, value: V) -> Self
-    where
-        HeaderName: TryFrom<K>,
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
-        V: IntoHeaderValue,
-    {
-        self.req.header(key, value);
-        self
-    }
-
-    /// Set request path pattern parameter
-    pub fn param(mut self, name: &'static str, value: &'static str) -> Self {
-        self.path.add_static(name, value);
-        self
-    }
-
-    /// Complete request creation and generate `Request` instance
-    pub fn finish(mut self) -> FramedRequest<TestBuffer, S> {
-        let req = self.req.finish();
-        self.path.get_mut().update(req.uri());
-        let framed = Framed::new(TestBuffer::empty(), Codec::default());
-        FramedRequest::new(req, framed, self.path, self.state)
-    }
-
-    /// This method generates `FramedRequest` instance and executes async handler
-    pub async fn run<F, R, I, E>(self, f: F) -> Result<I, E>
-    where
-        F: FnOnce(FramedRequest<TestBuffer, S>) -> R,
-        R: Future<Output = Result<I, E>>,
-    {
-        f(self.finish()).await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test() {
-        let req = TestRequest::with_uri("/index.html")
-            .header("x-test", "test")
-            .param("test", "123")
-            .finish();
-
-        assert_eq!(*req.state(), ());
-        assert_eq!(req.version(), Version::HTTP_11);
-        assert_eq!(req.method(), Method::GET);
-        assert_eq!(req.path(), "/index.html");
-        assert_eq!(req.query_string(), "");
-        assert_eq!(
-            req.headers().get("x-test").unwrap().to_str().unwrap(),
-            "test"
-        );
-        assert_eq!(&req.match_info()["test"], "123");
-    }
-}

actix-framed/tests/test_server.rs

@@ -1,159 +0,0 @@
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_http::{body, http::StatusCode, ws, Error, HttpService, Response};
-use actix_http_test::test_server;
-use actix_service::{pipeline_factory, IntoServiceFactory, ServiceFactory};
-use actix_utils::framed::Dispatcher;
-use bytes::Bytes;
-use futures::{future, SinkExt, StreamExt};
-
-use actix_framed::{FramedApp, FramedRequest, FramedRoute, SendError, VerifyWebSockets};
-
-async fn ws_service<T: AsyncRead + AsyncWrite>(
-    req: FramedRequest<T>,
-) -> Result<(), Error> {
-    let (req, mut framed, _) = req.into_parts();
-    let res = ws::handshake(req.head()).unwrap().message_body(());
-
-    framed
-        .send((res, body::BodySize::None).into())
-        .await
-        .unwrap();
-    Dispatcher::new(framed.into_framed(ws::Codec::new()), service)
-        .await
-        .unwrap();
-
-    Ok(())
-}
-
-async fn service(msg: ws::Frame) -> Result<ws::Message, Error> {
-    let msg = match msg {
-        ws::Frame::Ping(msg) => ws::Message::Pong(msg),
-        ws::Frame::Text(text) => {
-            ws::Message::Text(String::from_utf8_lossy(&text).to_string())
-        }
-        ws::Frame::Binary(bin) => ws::Message::Binary(bin),
-        ws::Frame::Close(reason) => ws::Message::Close(reason),
-        _ => panic!(),
-    };
-    Ok(msg)
-}
-
-#[actix_rt::test]
-async fn test_simple() {
-    let mut srv = test_server(|| {
-        HttpService::build()
-            .upgrade(
-                FramedApp::new().service(FramedRoute::get("/index.html").to(ws_service)),
-            )
-            .finish(|_| future::ok::<_, Error>(Response::NotFound()))
-            .tcp()
-    });
-
-    assert!(srv.ws_at("/test").await.is_err());
-
-    // client service
-    let mut framed = srv.ws_at("/index.html").await.unwrap();
-    framed
-        .send(ws::Message::Text("text".to_string()))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Text(Bytes::from_static(b"text"))
-    );
-
-    framed
-        .send(ws::Message::Binary("text".into()))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Binary(Bytes::from_static(b"text"))
-    );
-
-    framed.send(ws::Message::Ping("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Pong("text".to_string().into())
-    );
-
-    framed
-        .send(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
-        .await
-        .unwrap();
-
-    let (item, _) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
-    );
-}
-
-#[actix_rt::test]
-async fn test_service() {
-    let mut srv = test_server(|| {
-        pipeline_factory(actix_http::h1::OneRequest::new().map_err(|_| ())).and_then(
-            pipeline_factory(
-                pipeline_factory(VerifyWebSockets::default())
-                    .then(SendError::default())
-                    .map_err(|_| ()),
-            )
-            .and_then(
-                FramedApp::new()
-                    .service(FramedRoute::get("/index.html").to(ws_service))
-                    .into_factory()
-                    .map_err(|_| ()),
-            ),
-        )
-    });
-
-    // non ws request
-    let res = srv.get("/index.html").send().await.unwrap();
-    assert_eq!(res.status(), StatusCode::BAD_REQUEST);
-
-    // not found
-    assert!(srv.ws_at("/test").await.is_err());
-
-    // client service
-    let mut framed = srv.ws_at("/index.html").await.unwrap();
-    framed
-        .send(ws::Message::Text("text".to_string()))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Text(Bytes::from_static(b"text"))
-    );
-
-    framed
-        .send(ws::Message::Binary("text".into()))
-        .await
-        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Binary(Bytes::from_static(b"text"))
-    );
-
-    framed.send(ws::Message::Ping("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Pong("text".to_string().into())
-    );
-
-    framed
-        .send(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
-        .await
-        .unwrap();
-
-    let (item, _) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
-    );
-}

actix-http/.appveyor.yml

@@ -1,41 +0,0 @@
-environment:
-  global:
-    PROJECT_NAME: actix-http
-  matrix:
-    # Stable channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: stable
-    # Nightly channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: nightly
-
-# Install Rust and Cargo
-# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
-install:
-  - ps: >-
-        If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
-           $Env:PATH += ';C:\msys64\mingw64\bin'
-        } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
-           $Env:PATH += ';C:\MinGW\bin'
-        }
-  - curl -sSf -o rustup-init.exe https://win.rustup.rs
-  - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -Vv
-  - cargo -V
-
-# 'cargo test' takes care of building for us, so disable Appveyor's build stage.
-build: false
-
-# Equivalent to Travis' `script` phase
-test_script:
-  - cargo clean
-  - cargo test

actix-http/CHANGES.md

@@ -1,5 +1,113 @@
 # Changes
 
+## Unreleased - 2020-xx-xx
+
+
+## 2.0.0 - 2020-09-11
+* No significant changes from `2.0.0-beta.4`.
+
+
+## 2.0.0-beta.4 - 2020-09-09
+### Changed
+* Update actix-codec and actix-utils dependencies.
+* Update actix-connect and actix-tls dependencies.
+
+
+## [2.0.0-beta.3] - 2020-08-14
+
+### Fixed
+* Memory leak of `client::pool::ConnectorPoolSupport`. [#1626]
+
+[#1626]: https://github.com/actix/actix-web/pull/1626
+
+
+## [2.0.0-beta.2] - 2020-07-21
+### Fixed
+* Potential UB in h1 decoder using uninitialized memory. [#1614]
+
+### Changed
+* Fix illegal chunked encoding. [#1615]
+
+[#1614]: https://github.com/actix/actix-web/pull/1614
+[#1615]: https://github.com/actix/actix-web/pull/1615
+
+
+## [2.0.0-beta.1] - 2020-07-11
+
+### Changed
+
+* Migrate cookie handling to `cookie` crate. [#1558]
+* Update `sha-1` to 0.9. [#1586]
+* Fix leak in client pool. [#1580]
+* MSRV is now 1.41.1.
+
+[#1558]: https://github.com/actix/actix-web/pull/1558
+[#1586]: https://github.com/actix/actix-web/pull/1586
+[#1580]: https://github.com/actix/actix-web/pull/1580
+
+## [2.0.0-alpha.4] - 2020-05-21
+
+### Changed
+
+* Bump minimum supported Rust version to 1.40
+* content_length function is removed, and you can set Content-Length by calling no_chunking function [#1439]
+* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
+  `u64` instead of a `usize`.
+* Update `base64` dependency to 0.12
+
+### Fixed
+
+* Support parsing of `SameSite=None` [#1503]
+
+[#1439]: https://github.com/actix/actix-web/pull/1439
+[#1503]: https://github.com/actix/actix-web/pull/1503
+
+## [2.0.0-alpha.3] - 2020-05-08
+
+### Fixed
+
+* Correct spelling of ConnectError::Unresolved [#1487]
+* Fix a mistake in the encoding of websocket continuation messages wherein
+  Item::FirstText and Item::FirstBinary are each encoded as the other.
+
+### Changed
+
+* Implement `std::error::Error` for our custom errors [#1422]
+* Remove `failure` support for `ResponseError` since that crate
+  will be deprecated in the near future.
+
+[#1422]: https://github.com/actix/actix-web/pull/1422
+[#1487]: https://github.com/actix/actix-web/pull/1487
+
+## [2.0.0-alpha.2] - 2020-03-07
+
+### Changed
+
+* Update `actix-connect` and `actix-tls` dependency to 2.0.0-alpha.1. [#1395]
+
+* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB respectively
+  to improve download speed for awc when downloading large objects. [#1394]
+
+* client::Connector accepts initial_window_size and initial_connection_window_size HTTP2 configuration. [#1394]
+
+* client::Connector allowing to set max_http_version to limit HTTP version to be used. [#1394]
+
+[#1394]: https://github.com/actix/actix-web/pull/1394
+[#1395]: https://github.com/actix/actix-web/pull/1395
+
+## [2.0.0-alpha.1] - 2020-02-27
+
+### Changed
+
+* Update the `time` dependency to 0.2.7.
+* Moved actors messages support from actix crate, enabled with feature `actors`.
+* Breaking change: trait MessageBody requires Unpin and accepting Pin<&mut Self> instead of &mut self in the poll_next().
+* MessageBody is not implemented for &'static [u8] anymore.
+
+### Fixed
+
+* Allow `SameSite=None` cookies to be sent in a response.
+
 ## [1.0.1] - 2019-12-20
 
 ### Fixed

actix-http/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "actix-http"
-version = "1.0.1"
+version = "2.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix http primitives"
+description = "Actix HTTP primitives"
 readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "futures"]
 homepage = "https://actix.rs"
@@ -11,11 +11,11 @@ documentation = "https://docs.rs/actix-http/"
 categories = ["network-programming", "asynchronous",
               "web-programming::http-server",
               "web-programming::websocket"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 edition = "2018"
 
 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "failure", "compress", "secure-cookies"]
+features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
 
 [lib]
 name = "actix_http"
@@ -33,69 +33,77 @@ rustls = ["actix-tls/rustls", "actix-connect/rustls"]
 # enable compressison support
 compress = ["flate2", "brotli2"]
 
-# failure integration. actix does not use failure anymore
-failure = ["fail-ure"]
-
 # support for secure cookies
-secure-cookies = ["ring"]
+secure-cookies = ["cookie/secure"]
+
+# support for actix Actor messages
+actors = ["actix"]
 
 [dependencies]
-actix-service = "1.0.1"
-actix-codec = "0.2.0"
-actix-connect = "1.0.1"
-actix-utils = "1.0.3"
+actix-service = "1.0.6"
+actix-codec = "0.3.0"
+actix-connect = "2.0.0"
+actix-utils = "2.0.0"
 actix-rt = "1.0.0"
 actix-threadpool = "0.3.1"
-actix-tls = { version = "1.0.0", optional = true }
+actix-tls = { version = "2.0.0", optional = true }
+actix = { version = "0.10.0", optional = true }
 
-base64 = "0.11"
+base64 = "0.12"
 bitflags = "1.2"
 bytes = "0.5.3"
+cookie = { version = "0.14.1", features = ["percent-encode"] }
 copyless = "0.1.4"
-chrono = "0.4.6"
 derive_more = "0.99.2"
 either = "1.5.3"
 encoding_rs = "0.8"
-futures-core = "0.3.1"
-futures-util = "0.3.1"
-futures-channel = "0.3.1"
+futures-channel = { version = "0.3.5", default-features = false }
+futures-core = { version = "0.3.5", default-features = false }
+futures-util = { version = "0.3.5", default-features = false }
 fxhash = "0.2.1"
 h2 = "0.2.1"
 http = "0.2.0"
 httparse = "1.3"
 indexmap = "1.3"
+itoa = "0.4"
 lazy_static = "1.4"
 language-tags = "0.2"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
-pin-project = "0.4.6"
+pin-project = "0.4.17"
 rand = "0.7"
 regex = "1.3"
 serde = "1.0"
 serde_json = "1.0"
-sha1 = "0.6"
+sha-1 = "0.9"
 slab = "0.4"
 serde_urlencoded = "0.6.1"
-time = "0.1.42"
-
-# for secure cookie
-ring = { version = "0.16.9", optional = true }
+time = { version = "0.2.7", default-features = false, features = ["std"] }
 
 # compression
 brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }
 
-# optional deps
-fail-ure = { version = "0.1.5", package="failure", optional = true }
-
 [dev-dependencies]
-actix-server = "1.0.0"
-actix-connect = { version = "1.0.0", features=["openssl"] }
-actix-http-test = { version = "1.0.0", features=["openssl"] }
-actix-tls = { version = "1.0.0", features=["openssl"] }
-futures = "0.3.1"
-env_logger = "0.6"
+actix-server = "1.0.1"
+actix-connect = { version = "2.0.0", features = ["openssl"] }
+actix-http-test = { version = "2.0.0", features = ["openssl"] }
+actix-tls = { version = "2.0.0", features = ["openssl"] }
+criterion = "0.3"
+env_logger = "0.7"
 serde_derive = "1.0"
 open-ssl = { version="0.10", package = "openssl" }
-rust-tls = { version="0.16", package = "rustls" }
+rust-tls = { version="0.18", package = "rustls" }
+
+[[bench]]
+name = "content-length"
+harness = false
+
+[[bench]]
+name = "status-line"
+harness = false
+
+[[bench]]
+name = "uninit-headers"
+harness = false

actix-http/LICENSE-APACHE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2017-NOW Nikolay Kim
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

actix-http/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

actix-http/LICENSE-MIT

@@ -1,25 +0,0 @@
-Copyright (c) 2017 Nikolay Kim
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

actix-http/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

actix-http/README.md

@@ -8,25 +8,40 @@ Actix http
 * [API Documentation](https://docs.rs/actix-http/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-http](https://crates.io/crates/actix-http)
-* Minimum supported Rust version: 1.31 or later
+* Minimum supported Rust version: 1.40 or later
 
 ## Example
 
 ```rust
 // see examples/framed_hello.rs for complete list of used crates.
-extern crate actix_http;
-use actix_http::{h1, Response, ServiceConfig};
+use std::{env, io};
 
-fn main() {
-    Server::new().bind("framed_hello", "127.0.0.1:8080", || {
-        IntoFramed::new(|| h1::Codec::new(ServiceConfig::default()))	// <- create h1 codec
-            .and_then(TakeItem::new().map_err(|_| ()))	                // <- read one request
-            .and_then(|(_req, _framed): (_, Framed<_, _>)| {	        // <- send response and close conn
-                SendResponse::send(_framed, Response::Ok().body("Hello world!"))
-                    .map_err(|_| ())
-                    .map(|_| ())
-            })
-    }).unwrap().run();
+use actix_http::{HttpService, Response};
+use actix_server::Server;
+use futures::future;
+use http::header::HeaderValue;
+use log::info;
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+    env::set_var("RUST_LOG", "hello_world=info");
+    env_logger::init();
+
+    Server::build()
+        .bind("hello-world", "127.0.0.1:8080", || {
+            HttpService::build()
+                .client_timeout(1000)
+                .client_disconnect(1000)
+                .finish(|_req| {
+                    info!("{:?}", _req);
+                    let mut res = Response::Ok();
+                    res.header("x-head", HeaderValue::from_static("dummy value!"));
+                    future::ok::<_, ()>(res.body("Hello world!"))
+                })
+                .tcp()
+        })?
+        .run()
+        .await
 }
 ```
 

actix-http/benches/content-length.rs

@@ -0,0 +1,291 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+use bytes::BytesMut;
+
+// benchmark sending all requests at the same time
+fn bench_write_content_length(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_content_length");
+
+    let sizes = [
+        0, 1, 11, 83, 101, 653, 1001, 6323, 10001, 56329, 100001, 123456, 98724245,
+        4294967202,
+    ];
+
+    for i in sizes.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_content_length(i, &mut b)
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_content_length(i, &mut b)
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("itoa", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _itoa::write_content_length(i, &mut b)
+            })
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_write_content_length);
+criterion_main!(benches);
+
+mod _itoa {
+    use bytes::{BufMut, BytesMut};
+
+    pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
+        if n == 0 {
+            bytes.put_slice(b"\r\ncontent-length: 0\r\n");
+            return;
+        }
+
+        let mut buf = itoa::Buffer::new();
+
+        bytes.put_slice(b"\r\ncontent-length: ");
+        bytes.put_slice(buf.format(n).as_bytes());
+        bytes.put_slice(b"\r\n");
+    }
+}
+
+mod _new {
+    use bytes::{BufMut, BytesMut};
+
+    const DIGITS_START: u8 = b'0';
+
+    /// NOTE: bytes object has to contain enough space
+    pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
+        if n == 0 {
+            bytes.put_slice(b"\r\ncontent-length: 0\r\n");
+            return;
+        }
+
+        bytes.put_slice(b"\r\ncontent-length: ");
+
+        if n < 10 {
+            bytes.put_u8(DIGITS_START + (n as u8));
+        } else if n < 100 {
+            let n = n as u8;
+
+            let d10 = n / 10;
+            let d1 = n % 10;
+
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 1000 {
+            let n = n as u16;
+
+            let d100 = (n / 100) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 10_000 {
+            let n = n as u16;
+
+            let d1000 = (n / 1000) as u8;
+            let d100 = ((n / 100) % 10) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d1000);
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 100_000 {
+            let n = n as u32;
+
+            let d10000 = (n / 10000) as u8;
+            let d1000 = ((n / 1000) % 10) as u8;
+            let d100 = ((n / 100) % 10) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d10000);
+            bytes.put_u8(DIGITS_START + d1000);
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else if n < 1_000_000 {
+            let n = n as u32;
+
+            let d100000 = (n / 100000) as u8;
+            let d10000 = ((n / 10000) % 10) as u8;
+            let d1000 = ((n / 1000) % 10) as u8;
+            let d100 = ((n / 100) % 10) as u8;
+            let d10 = ((n / 10) % 10) as u8;
+            let d1 = (n % 10) as u8;
+
+            bytes.put_u8(DIGITS_START + d100000);
+            bytes.put_u8(DIGITS_START + d10000);
+            bytes.put_u8(DIGITS_START + d1000);
+            bytes.put_u8(DIGITS_START + d100);
+            bytes.put_u8(DIGITS_START + d10);
+            bytes.put_u8(DIGITS_START + d1);
+        } else {
+            write_usize(n, bytes);
+        }
+
+        bytes.put_slice(b"\r\n");
+    }
+
+    fn write_usize(n: usize, bytes: &mut BytesMut) {
+        let mut n = n;
+
+        // 20 chars is max length of a usize (2^64)
+        // digits will be added to the buffer from lsd to msd
+        let mut buf = BytesMut::with_capacity(20);
+
+        while n > 9 {
+            // "pop" the least-significant digit
+            let lsd = (n % 10) as u8;
+
+            // remove the lsd from n
+            n = n / 10;
+
+            buf.put_u8(DIGITS_START + lsd);
+        }
+
+        // put msd to result buffer
+        bytes.put_u8(DIGITS_START + (n as u8));
+
+        // put, in reverse (msd to lsd), remaining digits to buffer
+        for i in (0..buf.len()).rev() {
+            bytes.put_u8(buf[i]);
+        }
+    }
+}
+
+mod _original {
+    use std::{mem, ptr, slice};
+
+    use bytes::{BufMut, BytesMut};
+
+    const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
+          2021222324252627282930313233343536373839\
+          4041424344454647484950515253545556575859\
+          6061626364656667686970717273747576777879\
+          8081828384858687888990919293949596979899";
+
+    /// NOTE: bytes object has to contain enough space
+    pub fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
+        if n < 10 {
+            let mut buf: [u8; 21] = [
+                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
+                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'\r', b'\n',
+            ];
+            buf[18] = (n as u8) + b'0';
+            bytes.put_slice(&buf);
+        } else if n < 100 {
+            let mut buf: [u8; 22] = [
+                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
+                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'\r', b'\n',
+            ];
+            let d1 = n << 1;
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    DEC_DIGITS_LUT.as_ptr().add(d1),
+                    buf.as_mut_ptr().offset(18),
+                    2,
+                );
+            }
+            bytes.put_slice(&buf);
+        } else if n < 1000 {
+            let mut buf: [u8; 23] = [
+                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
+                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'0', b'\r',
+                b'\n',
+            ];
+            // decode 2 more chars, if > 2 chars
+            let d1 = (n % 100) << 1;
+            n /= 100;
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    DEC_DIGITS_LUT.as_ptr().add(d1),
+                    buf.as_mut_ptr().offset(19),
+                    2,
+                )
+            };
+
+            // decode last 1
+            buf[18] = (n as u8) + b'0';
+
+            bytes.put_slice(&buf);
+        } else {
+            bytes.put_slice(b"\r\ncontent-length: ");
+            convert_usize(n, bytes);
+        }
+    }
+
+    pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
+        let mut curr: isize = 39;
+        let mut buf: [u8; 41] = unsafe { mem::MaybeUninit::uninit().assume_init() };
+        buf[39] = b'\r';
+        buf[40] = b'\n';
+        let buf_ptr = buf.as_mut_ptr();
+        let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+
+        // eagerly decode 4 characters at a time
+        while n >= 10_000 {
+            let rem = (n % 10_000) as isize;
+            n /= 10_000;
+
+            let d1 = (rem / 100) << 1;
+            let d2 = (rem % 100) << 1;
+            curr -= 4;
+            unsafe {
+                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+                ptr::copy_nonoverlapping(
+                    lut_ptr.offset(d2),
+                    buf_ptr.offset(curr + 2),
+                    2,
+                );
+            }
+        }
+
+        // if we reach here numbers are <= 9999, so at most 4 chars long
+        let mut n = n as isize; // possibly reduce 64bit math
+
+        // decode 2 more chars, if > 2 chars
+        if n >= 100 {
+            let d1 = (n % 100) << 1;
+            n /= 100;
+            curr -= 2;
+            unsafe {
+                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+            }
+        }
+
+        // decode last 1 or 2 chars
+        if n < 10 {
+            curr -= 1;
+            unsafe {
+                *buf_ptr.offset(curr) = (n as u8) + b'0';
+            }
+        } else {
+            let d1 = n << 1;
+            curr -= 2;
+            unsafe {
+                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+            }
+        }
+
+        unsafe {
+            bytes.extend_from_slice(slice::from_raw_parts(
+                buf_ptr.offset(curr),
+                41 - curr as usize,
+            ));
+        }
+    }
+}

actix-http/benches/status-line.rs

@@ -0,0 +1,222 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+
+use bytes::BytesMut;
+use http::Version;
+
+const CODES: &[u16] = &[201, 303, 404, 515];
+
+fn bench_write_status_line_11(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_status_line v1.1");
+
+    let version = Version::HTTP_11;
+
+    for i in CODES.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _naive::write_status_line(version, i, &mut b);
+            })
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_write_status_line_10(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_status_line v1.0");
+
+    let version = Version::HTTP_10;
+
+    for i in CODES.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _naive::write_status_line(version, i, &mut b);
+            })
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_write_status_line_09(c: &mut Criterion) {
+    let mut group = c.benchmark_group("write_status_line v0.9");
+
+    let version = Version::HTTP_09;
+
+    for i in CODES.iter() {
+        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _original::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _new::write_status_line(version, i, &mut b);
+            })
+        });
+
+        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
+            b.iter(|| {
+                let mut b = BytesMut::with_capacity(35);
+                _naive::write_status_line(version, i, &mut b);
+            })
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_write_status_line_11,
+    bench_write_status_line_10,
+    bench_write_status_line_09
+);
+criterion_main!(benches);
+
+mod _naive {
+    use bytes::{BufMut, BytesMut};
+    use http::Version;
+
+    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
+        match version {
+            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
+            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
+            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
+            _ => {
+                // other HTTP version handlers do not use this method
+            }
+        }
+
+        bytes.put_slice(n.to_string().as_bytes());
+    }
+}
+
+mod _new {
+    use bytes::{BufMut, BytesMut};
+    use http::Version;
+
+    const DIGITS_START: u8 = b'0';
+
+    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
+        match version {
+            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
+            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
+            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
+            _ => {
+                // other HTTP version handlers do not use this method
+            }
+        }
+
+        let d100 = (n / 100) as u8;
+        let d10 = ((n / 10) % 10) as u8;
+        let d1 = (n % 10) as u8;
+
+        bytes.put_u8(DIGITS_START + d100);
+        bytes.put_u8(DIGITS_START + d10);
+        bytes.put_u8(DIGITS_START + d1);
+
+        bytes.put_u8(b' ');
+    }
+}
+
+mod _original {
+    use std::ptr;
+
+    use bytes::{BufMut, BytesMut};
+    use http::Version;
+
+    const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
+        2021222324252627282930313233343536373839\
+        4041424344454647484950515253545556575859\
+        6061626364656667686970717273747576777879\
+        8081828384858687888990919293949596979899";
+
+    pub(crate) const STATUS_LINE_BUF_SIZE: usize = 13;
+
+    pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
+        let mut buf: [u8; STATUS_LINE_BUF_SIZE] = *b"HTTP/1.1     ";
+
+        match version {
+            Version::HTTP_2 => buf[5] = b'2',
+            Version::HTTP_10 => buf[7] = b'0',
+            Version::HTTP_09 => {
+                buf[5] = b'0';
+                buf[7] = b'9';
+            }
+            _ => (),
+        }
+
+        let mut curr: isize = 12;
+        let buf_ptr = buf.as_mut_ptr();
+        let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+        let four = n > 999;
+
+        // decode 2 more chars, if > 2 chars
+        let d1 = (n % 100) << 1;
+        n /= 100;
+        curr -= 2;
+        unsafe {
+            ptr::copy_nonoverlapping(
+                lut_ptr.offset(d1 as isize),
+                buf_ptr.offset(curr),
+                2,
+            );
+        }
+
+        // decode last 1 or 2 chars
+        if n < 10 {
+            curr -= 1;
+            unsafe {
+                *buf_ptr.offset(curr) = (n as u8) + b'0';
+            }
+        } else {
+            let d1 = n << 1;
+            curr -= 2;
+            unsafe {
+                ptr::copy_nonoverlapping(
+                    lut_ptr.offset(d1 as isize),
+                    buf_ptr.offset(curr),
+                    2,
+                );
+            }
+        }
+
+        bytes.put_slice(&buf);
+        if four {
+            bytes.put_u8(b' ');
+        }
+    }
+}

actix-http/benches/uninit-headers.rs

@@ -0,0 +1,137 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+use bytes::BytesMut;
+
+// A Miri run detects UB, seen on this playground:
+// https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=f5d9aa166aa48df8dca05fce2b6c3915
+
+fn bench_header_parsing(c: &mut Criterion) {
+    c.bench_function("Original (Unsound) [short]", |b| {
+        b.iter(|| {
+            let mut buf = BytesMut::from(REQ_SHORT);
+            _original::parse_headers(&mut buf);
+        })
+    });
+
+    c.bench_function("New (safe) [short]", |b| {
+        b.iter(|| {
+            let mut buf = BytesMut::from(REQ_SHORT);
+            _new::parse_headers(&mut buf);
+        })
+    });
+
+    c.bench_function("Original (Unsound) [realistic]", |b| {
+        b.iter(|| {
+            let mut buf = BytesMut::from(REQ);
+            _original::parse_headers(&mut buf);
+        })
+    });
+
+    c.bench_function("New (safe) [realistic]", |b| {
+        b.iter(|| {
+            let mut buf = BytesMut::from(REQ);
+            _new::parse_headers(&mut buf);
+        })
+    });
+}
+
+criterion_group!(benches, bench_header_parsing);
+criterion_main!(benches);
+
+const MAX_HEADERS: usize = 96;
+
+const EMPTY_HEADER_ARRAY: [httparse::Header<'static>; MAX_HEADERS] =
+    [httparse::EMPTY_HEADER; MAX_HEADERS];
+
+#[derive(Clone, Copy)]
+struct HeaderIndex {
+    name: (usize, usize),
+    value: (usize, usize),
+}
+
+const EMPTY_HEADER_INDEX: HeaderIndex = HeaderIndex {
+    name: (0, 0),
+    value: (0, 0),
+};
+
+const EMPTY_HEADER_INDEX_ARRAY: [HeaderIndex; MAX_HEADERS] =
+    [EMPTY_HEADER_INDEX; MAX_HEADERS];
+
+impl HeaderIndex {
+    fn record(
+        bytes: &[u8],
+        headers: &[httparse::Header<'_>],
+        indices: &mut [HeaderIndex],
+    ) {
+        let bytes_ptr = bytes.as_ptr() as usize;
+        for (header, indices) in headers.iter().zip(indices.iter_mut()) {
+            let name_start = header.name.as_ptr() as usize - bytes_ptr;
+            let name_end = name_start + header.name.len();
+            indices.name = (name_start, name_end);
+            let value_start = header.value.as_ptr() as usize - bytes_ptr;
+            let value_end = value_start + header.value.len();
+            indices.value = (value_start, value_end);
+        }
+    }
+}
+
+// test cases taken from:
+// https://github.com/seanmonstar/httparse/blob/master/benches/parse.rs
+
+const REQ_SHORT: &'static [u8] = b"\
+GET / HTTP/1.0\r\n\
+Host: example.com\r\n\
+Cookie: session=60; user_id=1\r\n\r\n";
+
+const REQ: &'static [u8] = b"\
+GET /wp-content/uploads/2010/03/hello-kitty-darth-vader-pink.jpg HTTP/1.1\r\n\
+Host: www.kittyhell.com\r\n\
+User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; ja-JP-mac; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3 Pathtraq/0.9\r\n\
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n\
+Accept-Language: ja,en-us;q=0.7,en;q=0.3\r\n\
+Accept-Encoding: gzip,deflate\r\n\
+Accept-Charset: Shift_JIS,utf-8;q=0.7,*;q=0.7\r\n\
+Keep-Alive: 115\r\n\
+Connection: keep-alive\r\n\
+Cookie: wp_ozh_wsa_visits=2; wp_ozh_wsa_visit_lasttime=xxxxxxxxxx; __utma=xxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.xxxxxxxxxx.x; __utmz=xxxxxxxxx.xxxxxxxxxx.x.x.utmccn=(referral)|utmcsr=reader.livedoor.com|utmcct=/reader/|utmcmd=referral|padding=under256\r\n\r\n";
+
+mod _new {
+    use super::*;
+
+    pub fn parse_headers(src: &mut BytesMut) -> usize {
+        let mut headers: [HeaderIndex; MAX_HEADERS] = EMPTY_HEADER_INDEX_ARRAY;
+        let mut parsed: [httparse::Header<'_>; MAX_HEADERS] = EMPTY_HEADER_ARRAY;
+
+        let mut req = httparse::Request::new(&mut parsed);
+        match req.parse(src).unwrap() {
+            httparse::Status::Complete(_len) => {
+                HeaderIndex::record(src, req.headers, &mut headers);
+                req.headers.len()
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+mod _original {
+    use super::*;
+
+    use std::mem::MaybeUninit;
+
+    pub fn parse_headers(src: &mut BytesMut) -> usize {
+        let mut headers: [HeaderIndex; MAX_HEADERS] =
+            unsafe { MaybeUninit::uninit().assume_init() };
+
+        let mut parsed: [httparse::Header<'_>; MAX_HEADERS] =
+            unsafe { MaybeUninit::uninit().assume_init() };
+
+        let mut req = httparse::Request::new(&mut parsed);
+        match req.parse(src).unwrap() {
+            httparse::Status::Complete(_len) => {
+                HeaderIndex::record(src, req.headers, &mut headers);
+                req.headers.len()
+            }
+            _ => unreachable!(),
+        }
+    }
+}

actix-http/examples/echo.rs

@@ -3,11 +3,12 @@ use std::{env, io};
 use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures::StreamExt;
+use futures_util::StreamExt;
 use http::header::HeaderValue;
 use log::info;
 
-fn main() -> io::Result<()> {
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
     env::set_var("RUST_LOG", "echo=info");
     env_logger::init();
 
@@ -16,25 +17,21 @@ fn main() -> io::Result<()> {
             HttpService::build()
                 .client_timeout(1000)
                 .client_disconnect(1000)
-                .finish(|mut req: Request| {
-                    async move {
-                        let mut body = BytesMut::new();
-                        while let Some(item) = req.payload().next().await {
-                            body.extend_from_slice(&item?);
-                        }
-
-                        info!("request body: {:?}", body);
-                        Ok::<_, Error>(
-                            Response::Ok()
-                                .header(
-                                    "x-head",
-                                    HeaderValue::from_static("dummy value!"),
-                                )
-                                .body(body),
-                        )
+                .finish(|mut req: Request| async move {
+                    let mut body = BytesMut::new();
+                    while let Some(item) = req.payload().next().await {
+                        body.extend_from_slice(&item?);
                     }
+
+                    info!("request body: {:?}", body);
+                    Ok::<_, Error>(
+                        Response::Ok()
+                            .header("x-head", HeaderValue::from_static("dummy value!"))
+                            .body(body),
+                    )
                 })
                 .tcp()
         })?
         .run()
+        .await
 }

actix-http/examples/echo2.rs

@@ -4,7 +4,7 @@ use actix_http::http::HeaderValue;
 use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures::StreamExt;
+use futures_util::StreamExt;
 use log::info;
 
 async fn handle_request(mut req: Request) -> Result<Response, Error> {
@@ -19,7 +19,8 @@ async fn handle_request(mut req: Request) -> Result<Response, Error> {
         .body(body))
 }
 
-fn main() -> io::Result<()> {
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
     env::set_var("RUST_LOG", "echo=info");
     env_logger::init();
 
@@ -28,4 +29,5 @@ fn main() -> io::Result<()> {
             HttpService::build().finish(handle_request).tcp()
         })?
         .run()
+        .await
 }

actix-http/examples/hello-world.rs

@@ -2,11 +2,12 @@ use std::{env, io};
 
 use actix_http::{HttpService, Response};
 use actix_server::Server;
-use futures::future;
+use futures_util::future;
 use http::header::HeaderValue;
 use log::info;
 
-fn main() -> io::Result<()> {
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
     env::set_var("RUST_LOG", "hello_world=info");
     env_logger::init();
 
@@ -24,4 +25,5 @@ fn main() -> io::Result<()> {
                 .tcp()
         })?
         .run()
+        .await
 }

actix-http/src/body.rs

@@ -5,7 +5,8 @@ use std::{fmt, mem};
 
 use bytes::{Bytes, BytesMut};
 use futures_core::Stream;
-use pin_project::{pin_project, project};
+use futures_util::ready;
+use pin_project::pin_project;
 
 use crate::error::Error;
 
@@ -14,20 +15,13 @@ use crate::error::Error;
 pub enum BodySize {
     None,
     Empty,
-    Sized(usize),
-    Sized64(u64),
+    Sized(u64),
     Stream,
 }
 
 impl BodySize {
     pub fn is_eof(&self) -> bool {
-        match self {
-            BodySize::None
-            | BodySize::Empty
-            | BodySize::Sized(0)
-            | BodySize::Sized64(0) => true,
-            _ => false,
-        }
+        matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
     }
 }
 
@@ -35,33 +29,46 @@ impl BodySize {
 pub trait MessageBody {
     fn size(&self) -> BodySize;
 
-    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>>;
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>>;
+
+    downcast_get_type_id!();
 }
 
+downcast!(MessageBody);
+
 impl MessageBody for () {
     fn size(&self) -> BodySize {
         BodySize::Empty
     }
 
-    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         Poll::Ready(None)
     }
 }
 
-impl<T: MessageBody> MessageBody for Box<T> {
+impl<T: MessageBody + Unpin> MessageBody for Box<T> {
     fn size(&self) -> BodySize {
         self.as_ref().size()
     }
 
-    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
-        self.as_mut().poll_next(cx)
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        Pin::new(self.get_mut().as_mut()).poll_next(cx)
     }
 }
 
-#[pin_project]
+#[pin_project(project = ResponseBodyProj)]
 pub enum ResponseBody<B> {
-    Body(B),
-    Other(Body),
+    Body(#[pin] B),
+    Other(#[pin] Body),
 }
 
 impl ResponseBody<Body> {
@@ -97,10 +104,13 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
         }
     }
 
-    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
-        match self {
-            ResponseBody::Body(ref mut body) => body.poll_next(cx),
-            ResponseBody::Other(ref mut body) => body.poll_next(cx),
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        match self.project() {
+            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            ResponseBodyProj::Other(body) => body.poll_next(cx),
         }
     }
 }
@@ -108,19 +118,18 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
 impl<B: MessageBody> Stream for ResponseBody<B> {
     type Item = Result<Bytes, Error>;
 
-    #[project]
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        #[project]
         match self.project() {
-            ResponseBody::Body(ref mut body) => body.poll_next(cx),
-            ResponseBody::Other(ref mut body) => body.poll_next(cx),
+            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            ResponseBodyProj::Other(body) => body.poll_next(cx),
         }
     }
 }
 
+#[pin_project(project = BodyProj)]
 /// Represents various types of http message body.
 pub enum Body {
     /// Empty response. `Content-Length` header is not set.
@@ -130,7 +139,7 @@ pub enum Body {
     /// Specific response body.
     Bytes(Bytes),
     /// Generic message body.
-    Message(Box<dyn MessageBody>),
+    Message(Box<dyn MessageBody + Unpin>),
 }
 
 impl Body {
@@ -140,7 +149,7 @@ impl Body {
     }
 
     /// Create body from generic message body.
-    pub fn from_message<B: MessageBody + 'static>(body: B) -> Body {
+    pub fn from_message<B: MessageBody + Unpin + 'static>(body: B) -> Body {
         Body::Message(Box::new(body))
     }
 }
@@ -150,24 +159,27 @@ impl MessageBody for Body {
         match self {
             Body::None => BodySize::None,
             Body::Empty => BodySize::Empty,
-            Body::Bytes(ref bin) => BodySize::Sized(bin.len()),
+            Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
             Body::Message(ref body) => body.size(),
         }
     }
 
-    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
-        match self {
-            Body::None => Poll::Ready(None),
-            Body::Empty => Poll::Ready(None),
-            Body::Bytes(ref mut bin) => {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        match self.project() {
+            BodyProj::None => Poll::Ready(None),
+            BodyProj::Empty => Poll::Ready(None),
+            BodyProj::Bytes(ref mut bin) => {
                 let len = bin.len();
                 if len == 0 {
                     Poll::Ready(None)
                 } else {
-                    Poll::Ready(Some(Ok(mem::replace(bin, Bytes::new()))))
+                    Poll::Ready(Some(Ok(mem::take(bin))))
                 }
             }
-            Body::Message(ref mut body) => body.poll_next(cx),
+            BodyProj::Message(ref mut body) => Pin::new(body.as_mut()).poll_next(cx),
         }
     }
 }
@@ -175,14 +187,8 @@ impl MessageBody for Body {
 impl PartialEq for Body {
     fn eq(&self, other: &Body) -> bool {
         match *self {
-            Body::None => match *other {
-                Body::None => true,
-                _ => false,
-            },
-            Body::Empty => match *other {
-                Body::Empty => true,
-                _ => false,
-            },
+            Body::None => matches!(*other, Body::None),
+            Body::Empty => matches!(*other, Body::Empty),
             Body::Bytes(ref b) => match *other {
                 Body::Bytes(ref b2) => b == b2,
                 _ => false,
@@ -253,7 +259,7 @@ impl From<serde_json::Value> for Body {
 
 impl<S> From<SizedStream<S>> for Body
 where
-    S: Stream<Item = Result<Bytes, Error>> + 'static,
+    S: Stream<Item = Result<Bytes, Error>> + Unpin + 'static,
 {
     fn from(s: SizedStream<S>) -> Body {
         Body::from_message(s)
@@ -262,7 +268,7 @@ where
 
 impl<S, E> From<BodyStream<S, E>> for Body
 where
-    S: Stream<Item = Result<Bytes, E>> + 'static,
+    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
     E: Into<Error> + 'static,
 {
     fn from(s: BodyStream<S, E>) -> Body {
@@ -272,87 +278,88 @@ where
 
 impl MessageBody for Bytes {
     fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
+        BodySize::Sized(self.len() as u64)
     }
 
-    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
-            Poll::Ready(Some(Ok(mem::replace(self, Bytes::new()))))
+            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
         }
     }
 }
 
 impl MessageBody for BytesMut {
     fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
+        BodySize::Sized(self.len() as u64)
     }
 
-    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
-            Poll::Ready(Some(Ok(mem::replace(self, BytesMut::new()).freeze())))
+            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
         }
     }
 }
 
 impl MessageBody for &'static str {
     fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
+        BodySize::Sized(self.len() as u64)
     }
 
-    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
             Poll::Ready(Some(Ok(Bytes::from_static(
-                mem::replace(self, "").as_ref(),
+                mem::take(self.get_mut()).as_ref(),
             ))))
         }
     }
 }
 
-impl MessageBody for &'static [u8] {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
-    }
-
-    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
-        if self.is_empty() {
-            Poll::Ready(None)
-        } else {
-            Poll::Ready(Some(Ok(Bytes::from_static(mem::replace(self, b"")))))
-        }
-    }
-}
-
 impl MessageBody for Vec<u8> {
     fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
+        BodySize::Sized(self.len() as u64)
     }
 
-    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
-            Poll::Ready(Some(Ok(Bytes::from(mem::replace(self, Vec::new())))))
+            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
         }
     }
 }
 
 impl MessageBody for String {
     fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
+        BodySize::Sized(self.len() as u64)
     }
 
-    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
             Poll::Ready(Some(Ok(Bytes::from(
-                mem::replace(self, String::new()).into_bytes(),
+                mem::take(self.get_mut()).into_bytes(),
             ))))
         }
     }
@@ -361,7 +368,7 @@ impl MessageBody for String {
 /// Type represent streaming body.
 /// Response does not contain `content-length` header and appropriate transfer encoding is used.
 #[pin_project]
-pub struct BodyStream<S, E> {
+pub struct BodyStream<S: Unpin, E> {
     #[pin]
     stream: S,
     _t: PhantomData<E>,
@@ -369,7 +376,7 @@ pub struct BodyStream<S, E> {
 
 impl<S, E> BodyStream<S, E>
 where
-    S: Stream<Item = Result<Bytes, E>>,
+    S: Stream<Item = Result<Bytes, E>> + Unpin,
     E: Into<Error>,
 {
     pub fn new(stream: S) -> Self {
@@ -382,26 +389,37 @@ where
 
 impl<S, E> MessageBody for BodyStream<S, E>
 where
-    S: Stream<Item = Result<Bytes, E>>,
+    S: Stream<Item = Result<Bytes, E>> + Unpin,
     E: Into<Error>,
 {
     fn size(&self) -> BodySize {
         BodySize::Stream
     }
 
-    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
-        unsafe { Pin::new_unchecked(self) }
-            .project()
-            .stream
-            .poll_next(cx)
-            .map(|res| res.map(|res| res.map_err(std::convert::Into::into)))
+    /// Attempts to pull out the next value of the underlying [`Stream`].
+    ///
+    /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
+    /// ended on a zero-length chunk, but rather proceed until the underlying
+    /// [`Stream`] ends.
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        let mut stream = self.project().stream;
+        loop {
+            let stream = stream.as_mut();
+            return Poll::Ready(match ready!(stream.poll_next(cx)) {
+                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+                opt => opt.map(|res| res.map_err(Into::into)),
+            });
+        }
     }
 }
 
 /// Type represent streaming body. This body implementation should be used
 /// if total size of stream is known. Data get sent as is without using transfer encoding.
 #[pin_project]
-pub struct SizedStream<S> {
+pub struct SizedStream<S: Unpin> {
     size: u64,
     #[pin]
     stream: S,
@@ -409,7 +427,7 @@ pub struct SizedStream<S> {
 
 impl<S> SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>>,
+    S: Stream<Item = Result<Bytes, Error>> + Unpin,
 {
     pub fn new(size: u64, stream: S) -> Self {
         SizedStream { size, stream }
@@ -418,17 +436,29 @@ where
 
 impl<S> MessageBody for SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>>,
+    S: Stream<Item = Result<Bytes, Error>> + Unpin,
 {
     fn size(&self) -> BodySize {
-        BodySize::Sized64(self.size)
+        BodySize::Sized(self.size as u64)
     }
 
-    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
-        unsafe { Pin::new_unchecked(self) }
-            .project()
-            .stream
-            .poll_next(cx)
+    /// Attempts to pull out the next value of the underlying [`Stream`].
+    ///
+    /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
+    /// ended on a zero-length chunk, but rather proceed until the underlying
+    /// [`Stream`] ends.
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        let mut stream: Pin<&mut S> = self.project().stream;
+        loop {
+            let stream = stream.as_mut();
+            return Poll::Ready(match ready!(stream.poll_next(cx)) {
+                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+                val => val,
+            });
+        }
     }
 }
 
@@ -436,6 +466,8 @@ where
 mod tests {
     use super::*;
     use futures_util::future::poll_fn;
+    use futures_util::pin_mut;
+    use futures_util::stream;
 
     impl Body {
         pub(crate) fn get_ref(&self) -> &[u8] {
@@ -463,7 +495,10 @@ mod tests {
 
         assert_eq!("test".size(), BodySize::Sized(4));
         assert_eq!(
-            poll_fn(|cx| "test".poll_next(cx)).await.unwrap().ok(),
+            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
             Some(Bytes::from("test"))
         );
     }
@@ -477,13 +512,12 @@ mod tests {
             BodySize::Sized(4)
         );
         assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
+        let sb = Bytes::from(&b"test"[..]);
+        pin_mut!(sb);
 
-        assert_eq!((&b"test"[..]).size(), BodySize::Sized(4));
+        assert_eq!(sb.size(), BodySize::Sized(4));
         assert_eq!(
-            poll_fn(|cx| (&b"test"[..]).poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
+            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
             Some(Bytes::from("test"))
         );
     }
@@ -492,10 +526,12 @@ mod tests {
     async fn test_vec() {
         assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
         assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
+        let test_vec = Vec::from("test");
+        pin_mut!(test_vec);
 
-        assert_eq!(Vec::from("test").size(), BodySize::Sized(4));
+        assert_eq!(test_vec.size(), BodySize::Sized(4));
         assert_eq!(
-            poll_fn(|cx| Vec::from("test").poll_next(cx))
+            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
                 .await
                 .unwrap()
                 .ok(),
@@ -505,41 +541,44 @@ mod tests {
 
     #[actix_rt::test]
     async fn test_bytes() {
-        let mut b = Bytes::from("test");
+        let b = Bytes::from("test");
         assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
         assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        pin_mut!(b);
 
         assert_eq!(b.size(), BodySize::Sized(4));
         assert_eq!(
-            poll_fn(|cx| b.poll_next(cx)).await.unwrap().ok(),
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
             Some(Bytes::from("test"))
         );
     }
 
     #[actix_rt::test]
     async fn test_bytes_mut() {
-        let mut b = BytesMut::from("test");
+        let b = BytesMut::from("test");
         assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
         assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+        pin_mut!(b);
 
         assert_eq!(b.size(), BodySize::Sized(4));
         assert_eq!(
-            poll_fn(|cx| b.poll_next(cx)).await.unwrap().ok(),
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
             Some(Bytes::from("test"))
         );
     }
 
     #[actix_rt::test]
     async fn test_string() {
-        let mut b = "test".to_owned();
+        let b = "test".to_owned();
         assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
         assert_eq!(Body::from(b.clone()).get_ref(), b"test");
         assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
         assert_eq!(Body::from(&b).get_ref(), b"test");
+        pin_mut!(b);
 
         assert_eq!(b.size(), BodySize::Sized(4));
         assert_eq!(
-            poll_fn(|cx| b.poll_next(cx)).await.unwrap().ok(),
+            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
             Some(Bytes::from("test"))
         );
     }
@@ -547,22 +586,21 @@ mod tests {
     #[actix_rt::test]
     async fn test_unit() {
         assert_eq!(().size(), BodySize::Empty);
-        assert!(poll_fn(|cx| ().poll_next(cx)).await.is_none());
+        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
+            .await
+            .is_none());
     }
 
     #[actix_rt::test]
     async fn test_box() {
-        let mut val = Box::new(());
+        let val = Box::new(());
+        pin_mut!(val);
         assert_eq!(val.size(), BodySize::Empty);
-        assert!(poll_fn(|cx| val.poll_next(cx)).await.is_none());
+        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
     }
 
     #[actix_rt::test]
     async fn test_body_eq() {
-        assert!(Body::None == Body::None);
-        assert!(Body::None != Body::Empty);
-        assert!(Body::Empty == Body::Empty);
-        assert!(Body::Empty != Body::None);
         assert!(
             Body::Bytes(Bytes::from_static(b"1"))
                 == Body::Bytes(Bytes::from_static(b"1"))
@@ -574,7 +612,7 @@ mod tests {
     async fn test_body_debug() {
         assert!(format!("{:?}", Body::None).contains("Body::None"));
         assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
-        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains("1"));
+        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains('1'));
     }
 
     #[actix_rt::test]
@@ -589,4 +627,97 @@ mod tests {
             BodySize::Sized(25)
         );
     }
+
+    mod body_stream {
+        use super::*;
+        //use futures::task::noop_waker;
+        //use futures::stream::once;
+
+        #[actix_rt::test]
+        async fn skips_empty_chunks() {
+            let body = BodyStream::new(stream::iter(
+                ["1", "", "2"]
+                    .iter()
+                    .map(|&v| Ok(Bytes::from(v)) as Result<Bytes, ()>),
+            ));
+            pin_mut!(body);
+
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("1")),
+            );
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("2")),
+            );
+        }
+
+        /* Now it does not compile as it should
+        #[actix_rt::test]
+        async fn move_pinned_pointer() {
+            let (sender, receiver) = futures::channel::oneshot::channel();
+            let mut body_stream = Ok(BodyStream::new(once(async {
+                let x = Box::new(0i32);
+                let y = &x;
+                receiver.await.unwrap();
+                let _z = **y;
+                Ok::<_, ()>(Bytes::new())
+            })));
+
+            let waker = noop_waker();
+            let mut context = Context::from_waker(&waker);
+            pin_mut!(body_stream);
+
+            let _ = body_stream.as_mut().unwrap().poll_next(&mut context);
+            sender.send(()).unwrap();
+            let _ = std::mem::replace(&mut body_stream, Err([0; 32])).unwrap().poll_next(&mut context);
+        }*/
+    }
+
+    mod sized_stream {
+        use super::*;
+
+        #[actix_rt::test]
+        async fn skips_empty_chunks() {
+            let body = SizedStream::new(
+                2,
+                stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
+            );
+            pin_mut!(body);
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("1")),
+            );
+            assert_eq!(
+                poll_fn(|cx| body.as_mut().poll_next(cx))
+                    .await
+                    .unwrap()
+                    .ok(),
+                Some(Bytes::from("2")),
+            );
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_body_casting() {
+        let mut body = String::from("hello cast");
+        let resp_body: &mut dyn MessageBody = &mut body;
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast");
+        let body = &mut resp_body.downcast_mut::<String>().unwrap();
+        body.push('!');
+        let body = resp_body.downcast_ref::<String>().unwrap();
+        assert_eq!(body, "hello cast!");
+        let not_body = resp_body.downcast_ref::<()>();
+        assert!(not_body.is_none());
+    }
 }

actix-http/src/client/config.rs

@@ -0,0 +1,39 @@
+use std::time::Duration;
+
+// These values are taken from hyper/src/proto/h2/client.rs
+const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2mb
+const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024; // 1mb
+
+/// Connector configuration
+#[derive(Clone)]
+pub(crate) struct ConnectorConfig {
+    pub(crate) timeout: Duration,
+    pub(crate) conn_lifetime: Duration,
+    pub(crate) conn_keep_alive: Duration,
+    pub(crate) disconnect_timeout: Option<Duration>,
+    pub(crate) limit: usize,
+    pub(crate) conn_window_size: u32,
+    pub(crate) stream_window_size: u32,
+}
+
+impl Default for ConnectorConfig {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_secs(1),
+            conn_lifetime: Duration::from_secs(75),
+            conn_keep_alive: Duration::from_secs(15),
+            disconnect_timeout: Some(Duration::from_millis(3000)),
+            limit: 100,
+            conn_window_size: DEFAULT_H2_CONN_WINDOW,
+            stream_window_size: DEFAULT_H2_STREAM_WINDOW,
+        }
+    }
+}
+
+impl ConnectorConfig {
+    pub(crate) fn no_disconnect_timeout(&self) -> Self {
+        let mut res = self.clone();
+        res.disconnect_timeout = None;
+        res
+    }
+}

actix-http/src/client/connection.rs

@@ -1,12 +1,13 @@
+use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, io, mem, time};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::{Buf, Bytes};
-use futures_util::future::{err, Either, Future, FutureExt, LocalBoxFuture, Ready};
+use futures_util::future::{err, Either, FutureExt, LocalBoxFuture, Ready};
 use h2::client::SendRequest;
-use pin_project::{pin_project, project};
+use pin_project::pin_project;
 
 use crate::body::MessageBody;
 use crate::h1::ClientCodec;
@@ -45,10 +46,10 @@ pub trait Connection {
 
 pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
     /// Close connection
-    fn close(&mut self);
+    fn close(self: Pin<&mut Self>);
 
     /// Release connection to the connection pool
-    fn release(&mut self);
+    fn release(self: Pin<&mut Self>);
 }
 
 #[doc(hidden)]
@@ -194,17 +195,21 @@ where
         match self {
             EitherConnection::A(con) => con
                 .open_tunnel(head)
-                .map(|res| res.map(|(head, framed)| (head, framed.map_io(EitherIo::A))))
+                .map(|res| {
+                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::A)))
+                })
                 .boxed_local(),
             EitherConnection::B(con) => con
                 .open_tunnel(head)
-                .map(|res| res.map(|(head, framed)| (head, framed.map_io(EitherIo::B))))
+                .map(|res| {
+                    res.map(|(head, framed)| (head, framed.into_map_io(EitherIo::B)))
+                })
                 .boxed_local(),
         }
     }
 }
 
-#[pin_project]
+#[pin_project(project = EitherIoProj)]
 pub enum EitherIo<A, B> {
     A(#[pin] A),
     B(#[pin] B),
@@ -215,16 +220,14 @@ where
     A: AsyncRead,
     B: AsyncRead,
 {
-    #[project]
     fn poll_read(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
-        #[project]
         match self.project() {
-            EitherIo::A(val) => val.poll_read(cx, buf),
-            EitherIo::B(val) => val.poll_read(cx, buf),
+            EitherIoProj::A(val) => val.poll_read(cx, buf),
+            EitherIoProj::B(val) => val.poll_read(cx, buf),
         }
     }
 
@@ -244,41 +247,34 @@ where
     A: AsyncWrite,
     B: AsyncWrite,
 {
-    #[project]
     fn poll_write(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
-        #[project]
         match self.project() {
-            EitherIo::A(val) => val.poll_write(cx, buf),
-            EitherIo::B(val) => val.poll_write(cx, buf),
+            EitherIoProj::A(val) => val.poll_write(cx, buf),
+            EitherIoProj::B(val) => val.poll_write(cx, buf),
         }
     }
 
-    #[project]
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        #[project]
         match self.project() {
-            EitherIo::A(val) => val.poll_flush(cx),
-            EitherIo::B(val) => val.poll_flush(cx),
+            EitherIoProj::A(val) => val.poll_flush(cx),
+            EitherIoProj::B(val) => val.poll_flush(cx),
         }
     }
 
-    #[project]
     fn poll_shutdown(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<io::Result<()>> {
-        #[project]
         match self.project() {
-            EitherIo::A(val) => val.poll_shutdown(cx),
-            EitherIo::B(val) => val.poll_shutdown(cx),
+            EitherIoProj::A(val) => val.poll_shutdown(cx),
+            EitherIoProj::B(val) => val.poll_shutdown(cx),
         }
     }
 
-    #[project]
     fn poll_write_buf<U: Buf>(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -287,10 +283,9 @@ where
     where
         Self: Sized,
     {
-        #[project]
         match self.project() {
-            EitherIo::A(val) => val.poll_write_buf(cx, buf),
-            EitherIo::B(val) => val.poll_write_buf(cx, buf),
+            EitherIoProj::A(val) => val.poll_write_buf(cx, buf),
+            EitherIoProj::B(val) => val.poll_write_buf(cx, buf),
         }
     }
 }

actix-http/src/client/connector.rs

@@ -11,6 +11,7 @@ use actix_service::{apply_fn, Service};
 use actix_utils::timeout::{TimeoutError, TimeoutService};
 use http::Uri;
 
+use super::config::ConnectorConfig;
 use super::connection::Connection;
 use super::error::ConnectError;
 use super::pool::{ConnectionPool, Protocol};
@@ -48,11 +49,7 @@ type SslConnector = ();
 /// ```
 pub struct Connector<T, U> {
     connector: T,
-    timeout: Duration,
-    conn_lifetime: Duration,
-    conn_keep_alive: Duration,
-    disconnect_timeout: Duration,
-    limit: usize,
+    config: ConnectorConfig,
     #[allow(dead_code)]
     ssl: SslConnector,
     _t: PhantomData<U>,
@@ -71,42 +68,47 @@ impl Connector<(), ()> {
             > + Clone,
         TcpStream,
     > {
-        let ssl = {
-            #[cfg(feature = "openssl")]
-            {
-                use actix_connect::ssl::openssl::SslMethod;
-
-                let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
-                let _ = ssl
-                    .set_alpn_protos(b"\x02h2\x08http/1.1")
-                    .map_err(|e| error!("Can not set alpn protocol: {:?}", e));
-                SslConnector::Openssl(ssl.build())
-            }
-            #[cfg(all(not(feature = "openssl"), feature = "rustls"))]
-            {
-                let protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
-                let mut config = ClientConfig::new();
-                config.set_protocols(&protos);
-                config
-                    .root_store
-                    .add_server_trust_anchors(&actix_tls::rustls::TLS_SERVER_ROOTS);
-                SslConnector::Rustls(Arc::new(config))
-            }
-            #[cfg(not(any(feature = "openssl", feature = "rustls")))]
-            {}
-        };
-
         Connector {
-            ssl,
+            ssl: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
             connector: default_connector(),
-            timeout: Duration::from_secs(1),
-            conn_lifetime: Duration::from_secs(75),
-            conn_keep_alive: Duration::from_secs(15),
-            disconnect_timeout: Duration::from_millis(3000),
-            limit: 100,
+            config: ConnectorConfig::default(),
             _t: PhantomData,
         }
     }
+
+    // Build Ssl connector with openssl, based on supplied alpn protocols
+    #[cfg(feature = "openssl")]
+    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
+        use actix_connect::ssl::openssl::SslMethod;
+        use bytes::{BufMut, BytesMut};
+
+        let mut alpn = BytesMut::with_capacity(20);
+        for proto in protocols.iter() {
+            alpn.put_u8(proto.len() as u8);
+            alpn.put(proto.as_slice());
+        }
+
+        let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
+        let _ = ssl
+            .set_alpn_protos(&alpn)
+            .map_err(|e| error!("Can not set alpn protocol: {:?}", e));
+        SslConnector::Openssl(ssl.build())
+    }
+
+    // Build Ssl connector with rustls, based on supplied alpn protocols
+    #[cfg(all(not(feature = "openssl"), feature = "rustls"))]
+    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
+        let mut config = ClientConfig::new();
+        config.set_protocols(&protocols);
+        config
+            .root_store
+            .add_server_trust_anchors(&actix_tls::rustls::TLS_SERVER_ROOTS);
+        SslConnector::Rustls(Arc::new(config))
+    }
+
+    // ssl turned off, provides empty ssl connector
+    #[cfg(not(any(feature = "openssl", feature = "rustls")))]
+    fn build_ssl(_: Vec<Vec<u8>>) -> SslConnector {}
 }
 
 impl<T, U> Connector<T, U> {
@@ -122,11 +124,7 @@ impl<T, U> Connector<T, U> {
     {
         Connector {
             connector,
-            timeout: self.timeout,
-            conn_lifetime: self.conn_lifetime,
-            conn_keep_alive: self.conn_keep_alive,
-            disconnect_timeout: self.disconnect_timeout,
-            limit: self.limit,
+            config: self.config,
             ssl: self.ssl,
             _t: PhantomData,
         }
@@ -146,7 +144,7 @@ where
     /// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
     /// Set to 1 second by default.
     pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = timeout;
+        self.config.timeout = timeout;
         self
     }
 
@@ -163,12 +161,44 @@ where
         self
     }
 
+    /// Maximum supported http major version
+    /// Supported versions http/1.1, http/2
+    pub fn max_http_version(mut self, val: http::Version) -> Self {
+        let versions = match val {
+            http::Version::HTTP_11 => vec![b"http/1.1".to_vec()],
+            http::Version::HTTP_2 => vec![b"h2".to_vec(), b"http/1.1".to_vec()],
+            _ => {
+                unimplemented!("actix-http:client: supported versions http/1.1, http/2")
+            }
+        };
+        self.ssl = Connector::build_ssl(versions);
+        self
+    }
+
+    /// Indicates the initial window size (in octets) for
+    /// HTTP2 stream-level flow control for received data.
+    ///
+    /// The default value is 65,535 and is good for APIs, but not for big objects.
+    pub fn initial_window_size(mut self, size: u32) -> Self {
+        self.config.stream_window_size = size;
+        self
+    }
+
+    /// Indicates the initial window size (in octets) for
+    /// HTTP2 connection-level flow control for received data.
+    ///
+    /// The default value is 65,535 and is good for APIs, but not for big objects.
+    pub fn initial_connection_window_size(mut self, size: u32) -> Self {
+        self.config.conn_window_size = size;
+        self
+    }
+
     /// Set total number of simultaneous connections per type of scheme.
     ///
     /// If limit is 0, the connector has no limit.
     /// The default limit size is 100.
     pub fn limit(mut self, limit: usize) -> Self {
-        self.limit = limit;
+        self.config.limit = limit;
         self
     }
 
@@ -179,7 +209,7 @@ where
     /// exceeds this period, the connection is closed.
     /// Default keep-alive period is 15 seconds.
     pub fn conn_keep_alive(mut self, dur: Duration) -> Self {
-        self.conn_keep_alive = dur;
+        self.config.conn_keep_alive = dur;
         self
     }
 
@@ -189,7 +219,7 @@ where
     /// until it is closed regardless of keep-alive period.
     /// Default lifetime period is 75 seconds.
     pub fn conn_lifetime(mut self, dur: Duration) -> Self {
-        self.conn_lifetime = dur;
+        self.config.conn_lifetime = dur;
         self
     }
 
@@ -202,7 +232,7 @@ where
     ///
     /// By default disconnect timeout is set to 3000 milliseconds.
     pub fn disconnect_timeout(mut self, dur: Duration) -> Self {
-        self.disconnect_timeout = dur;
+        self.config.disconnect_timeout = Some(dur);
         self
     }
 
@@ -216,7 +246,7 @@ where
         #[cfg(not(any(feature = "openssl", feature = "rustls")))]
         {
             let connector = TimeoutService::new(
-                self.timeout,
+                self.config.timeout,
                 apply_fn(self.connector, |msg: Connect, srv| {
                     srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
                 })
@@ -231,10 +261,7 @@ where
             connect_impl::InnerConnector {
                 tcp_pool: ConnectionPool::new(
                     connector,
-                    self.conn_lifetime,
-                    self.conn_keep_alive,
-                    None,
-                    self.limit,
+                    self.config.no_disconnect_timeout(),
                 ),
             }
         }
@@ -248,7 +275,7 @@ where
             use actix_service::{boxed::service, pipeline};
 
             let ssl_service = TimeoutService::new(
-                self.timeout,
+                self.config.timeout,
                 pipeline(
                     apply_fn(self.connector.clone(), |msg: Connect, srv| {
                         srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
@@ -301,7 +328,7 @@ where
             });
 
             let tcp_service = TimeoutService::new(
-                self.timeout,
+                self.config.timeout,
                 apply_fn(self.connector, |msg: Connect, srv| {
                     srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
                 })
@@ -316,18 +343,9 @@ where
             connect_impl::InnerConnector {
                 tcp_pool: ConnectionPool::new(
                     tcp_service,
-                    self.conn_lifetime,
-                    self.conn_keep_alive,
-                    None,
-                    self.limit,
-                ),
-                ssl_pool: ConnectionPool::new(
-                    ssl_service,
-                    self.conn_lifetime,
-                    self.conn_keep_alive,
-                    Some(self.disconnect_timeout),
-                    self.limit,
+                    self.config.no_disconnect_timeout(),
                 ),
+                ssl_pool: ConnectionPool::new(ssl_service, self.config),
             }
         }
     }

actix-http/src/client/error.rs

@@ -39,7 +39,7 @@ pub enum ConnectError {
     H2(h2::Error),
 
     /// Connecting took too long
-    #[display(fmt = "Timeout out while establishing connection")]
+    #[display(fmt = "Timeout while establishing connection")]
     Timeout,
 
     /// Connector has been disconnected
@@ -48,20 +48,22 @@ pub enum ConnectError {
 
     /// Unresolved host name
     #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolverd,
+    Unresolved,
 
     /// Connection io error
     #[display(fmt = "{}", _0)]
     Io(io::Error),
 }
 
+impl std::error::Error for ConnectError {}
+
 impl From<actix_connect::ConnectError> for ConnectError {
     fn from(err: actix_connect::ConnectError) -> ConnectError {
         match err {
             actix_connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
             actix_connect::ConnectError::NoRecords => ConnectError::NoRecords,
             actix_connect::ConnectError::InvalidInput => panic!(),
-            actix_connect::ConnectError::Unresolverd => ConnectError::Unresolverd,
+            actix_connect::ConnectError::Unresolved => ConnectError::Unresolved,
             actix_connect::ConnectError::Io(e) => ConnectError::Io(e),
         }
     }
@@ -86,6 +88,8 @@ pub enum InvalidUrl {
     HttpError(http::Error),
 }
 
+impl std::error::Error for InvalidUrl {}
+
 /// A set of errors that can occur during request sending and response reading
 #[derive(Debug, Display, From)]
 pub enum SendRequestError {
@@ -106,7 +110,7 @@ pub enum SendRequestError {
     #[display(fmt = "{}", _0)]
     H2(h2::Error),
     /// Response took too long
-    #[display(fmt = "Timeout out while waiting for response")]
+    #[display(fmt = "Timeout while waiting for response")]
     Timeout,
     /// Tunnels are not supported for http2 connection
     #[display(fmt = "Tunnels are not supported for http2 connection")]
@@ -115,6 +119,8 @@ pub enum SendRequestError {
     Body(Error),
 }
 
+impl std::error::Error for SendRequestError {}
+
 /// Convert `SendRequestError` to a server `Response`
 impl ResponseError for SendRequestError {
     fn status_code(&self) -> StatusCode {
@@ -139,6 +145,8 @@ pub enum FreezeRequestError {
     Http(HttpError),
 }
 
+impl std::error::Error for FreezeRequestError {}
+
 impl From<FreezeRequestError> for SendRequestError {
     fn from(e: FreezeRequestError) -> Self {
         match e {

actix-http/src/client/h1proto.rs

@@ -8,7 +8,7 @@ use bytes::buf::BufMutExt;
 use bytes::{Bytes, BytesMut};
 use futures_core::Stream;
 use futures_util::future::poll_fn;
-use futures_util::{SinkExt, StreamExt};
+use futures_util::{pin_mut, SinkExt, StreamExt};
 
 use crate::error::PayloadError;
 use crate::h1;
@@ -67,17 +67,17 @@ where
     };
 
     // create Framed and send request
-    let mut framed = Framed::new(io, h1::ClientCodec::default());
-    framed.send((head, body.size()).into()).await?;
+    let mut framed_inner = Framed::new(io, h1::ClientCodec::default());
+    framed_inner.send((head, body.size()).into()).await?;
 
     // send request body
     match body.size() {
         BodySize::None | BodySize::Empty | BodySize::Sized(0) => (),
-        _ => send_body(body, &mut framed).await?,
+        _ => send_body(body, Pin::new(&mut framed_inner)).await?,
     };
 
     // read response and init read body
-    let res = framed.into_future().await;
+    let res = Pin::new(&mut framed_inner).into_future().await;
     let (head, framed) = if let (Some(result), framed) = res {
         let item = result.map_err(SendRequestError::from)?;
         (item, framed)
@@ -85,14 +85,14 @@ where
         return Err(SendRequestError::from(ConnectError::Disconnected));
     };
 
-    match framed.get_codec().message_type() {
+    match framed.codec_ref().message_type() {
         h1::MessageType::None => {
-            let force_close = !framed.get_codec().keepalive();
+            let force_close = !framed.codec_ref().keepalive();
             release_connection(framed, force_close);
             Ok((head, Payload::None))
         }
         _ => {
-            let pl: PayloadStream = PlStream::new(framed).boxed_local();
+            let pl: PayloadStream = PlStream::new(framed_inner).boxed_local();
             Ok((head, pl.into()))
         }
     }
@@ -119,34 +119,36 @@ where
 }
 
 /// send request body to the peer
-pub(crate) async fn send_body<I, B>(
-    mut body: B,
-    framed: &mut Framed<I, h1::ClientCodec>,
+pub(crate) async fn send_body<T, B>(
+    body: B,
+    mut framed: Pin<&mut Framed<T, h1::ClientCodec>>,
 ) -> Result<(), SendRequestError>
 where
-    I: ConnectionLifetime,
+    T: ConnectionLifetime + Unpin,
     B: MessageBody,
 {
+    pin_mut!(body);
+
     let mut eof = false;
     while !eof {
-        while !eof && !framed.is_write_buf_full() {
-            match poll_fn(|cx| body.poll_next(cx)).await {
+        while !eof && !framed.as_ref().is_write_buf_full() {
+            match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
                 Some(result) => {
-                    framed.write(h1::Message::Chunk(Some(result?)))?;
+                    framed.as_mut().write(h1::Message::Chunk(Some(result?)))?;
                 }
                 None => {
                     eof = true;
-                    framed.write(h1::Message::Chunk(None))?;
+                    framed.as_mut().write(h1::Message::Chunk(None))?;
                 }
             }
         }
 
-        if !framed.is_write_buf_empty() {
-            poll_fn(|cx| match framed.flush(cx) {
+        if !framed.as_ref().is_write_buf_empty() {
+            poll_fn(|cx| match framed.as_mut().flush(cx) {
                 Poll::Ready(Ok(_)) => Poll::Ready(Ok(())),
                 Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
                 Poll::Pending => {
-                    if !framed.is_write_buf_full() {
+                    if !framed.as_ref().is_write_buf_full() {
                         Poll::Ready(Ok(()))
                     } else {
                         Poll::Pending
@@ -157,13 +159,14 @@ where
         }
     }
 
-    SinkExt::flush(framed).await?;
+    SinkExt::flush(Pin::into_inner(framed)).await?;
     Ok(())
 }
 
 #[doc(hidden)]
 /// HTTP client connection
 pub struct H1Connection<T> {
+    /// T should be `Unpin`
     io: Option<T>,
     created: time::Instant,
     pool: Option<Acquired<T>>,
@@ -174,7 +177,7 @@ where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
 {
     /// Close connection
-    fn close(&mut self) {
+    fn close(mut self: Pin<&mut Self>) {
         if let Some(mut pool) = self.pool.take() {
             if let Some(io) = self.io.take() {
                 pool.close(IoConnection::new(
@@ -187,7 +190,7 @@ where
     }
 
     /// Release this connection to the connection pool
-    fn release(&mut self) {
+    fn release(mut self: Pin<&mut Self>) {
         if let Some(mut pool) = self.pool.take() {
             if let Some(io) = self.io.take() {
                 pool.release(IoConnection::new(
@@ -241,14 +244,18 @@ impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncWrite for H1Connection<T>
     }
 }
 
+#[pin_project::pin_project]
 pub(crate) struct PlStream<Io> {
+    #[pin]
     framed: Option<Framed<Io, h1::ClientPayloadCodec>>,
 }
 
 impl<Io: ConnectionLifetime> PlStream<Io> {
     fn new(framed: Framed<Io, h1::ClientCodec>) -> Self {
+        let framed = framed.into_map_codec(|codec| codec.into_payload_codec());
+
         PlStream {
-            framed: Some(framed.map_codec(|codec| codec.into_payload_codec())),
+            framed: Some(framed),
         }
     }
 }
@@ -260,16 +267,16 @@ impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
+        let mut this = self.project();
 
-        match this.framed.as_mut().unwrap().next_item(cx)? {
+        match this.framed.as_mut().as_pin_mut().unwrap().next_item(cx)? {
             Poll::Pending => Poll::Pending,
             Poll::Ready(Some(chunk)) => {
                 if let Some(chunk) = chunk {
                     Poll::Ready(Some(Ok(chunk)))
                 } else {
-                    let framed = this.framed.take().unwrap();
-                    let force_close = !framed.get_codec().keepalive();
+                    let framed = this.framed.as_mut().as_pin_mut().unwrap();
+                    let force_close = !framed.codec_ref().keepalive();
                     release_connection(framed, force_close);
                     Poll::Ready(None)
                 }
@@ -279,14 +286,13 @@ impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
     }
 }
 
-fn release_connection<T, U>(framed: Framed<T, U>, force_close: bool)
+fn release_connection<T, U>(framed: Pin<&mut Framed<T, U>>, force_close: bool)
 where
     T: ConnectionLifetime,
 {
-    let mut parts = framed.into_parts();
-    if !force_close && parts.read_buf.is_empty() && parts.write_buf.is_empty() {
-        parts.io.release()
+    if !force_close && framed.is_read_buf_empty() && framed.is_write_buf_empty() {
+        framed.io_pin().release()
     } else {
-        parts.io.close()
+        framed.io_pin().close()
     }
 }

actix-http/src/client/h2proto.rs

@@ -1,10 +1,15 @@
 use std::convert::TryFrom;
+use std::future::Future;
 use std::time;
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use bytes::Bytes;
 use futures_util::future::poll_fn;
-use h2::{client::SendRequest, SendStream};
+use futures_util::pin_mut;
+use h2::{
+    client::{Builder, Connection, SendRequest},
+    SendStream,
+};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};
 
@@ -13,6 +18,7 @@ use crate::header::HeaderMap;
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
 
+use super::config::ConnectorConfig;
 use super::connection::{ConnectionType, IoConnection};
 use super::error::SendRequestError;
 use super::pool::Acquired;
@@ -31,10 +37,10 @@ where
     trace!("Sending client request: {:?} {:?}", head, body.size());
     let head_req = head.as_ref().method == Method::HEAD;
     let length = body.size();
-    let eof = match length {
-        BodySize::None | BodySize::Empty | BodySize::Sized(0) => true,
-        _ => false,
-    };
+    let eof = matches!(
+        length,
+        BodySize::None | BodySize::Empty | BodySize::Sized(0)
+    );
 
     let mut req = Request::new(());
     *req.uri_mut() = head.as_ref().uri.clone();
@@ -58,10 +64,6 @@ where
             CONTENT_LENGTH,
             HeaderValue::try_from(format!("{}", len)).unwrap(),
         ),
-        BodySize::Sized64(len) => req.headers_mut().insert(
-            CONTENT_LENGTH,
-            HeaderValue::try_from(format!("{}", len)).unwrap(),
-        ),
     };
 
     // Extracting extra headers from RequestHeadType. HeaderMap::new() does not allocate.
@@ -123,13 +125,14 @@ where
 }
 
 async fn send_body<B: MessageBody>(
-    mut body: B,
+    body: B,
     mut send: SendStream<Bytes>,
 ) -> Result<(), SendRequestError> {
     let mut buf = None;
+    pin_mut!(body);
     loop {
         if buf.is_none() {
-            match poll_fn(|cx| body.poll_next(cx)).await {
+            match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
                 Some(Ok(b)) => {
                     send.reserve_capacity(b.len());
                     buf = Some(b);
@@ -183,3 +186,18 @@ fn release<T: AsyncRead + AsyncWrite + Unpin + 'static>(
         }
     }
 }
+
+pub(crate) fn handshake<Io>(
+    io: Io,
+    config: &ConnectorConfig,
+) -> impl Future<Output = Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>>
+where
+    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+{
+    let mut builder = Builder::new();
+    builder
+        .initial_window_size(config.stream_window_size)
+        .initial_connection_window_size(config.conn_window_size)
+        .enable_push(false);
+    builder.handshake(io)
+}

actix-http/src/client/mod.rs

@@ -1,6 +1,7 @@
 //! Http client api
 use http::Uri;
 
+mod config;
 mod connection;
 mod connector;
 mod error;

actix-http/src/client/pool.rs

@@ -13,13 +13,16 @@ use actix_utils::{oneshot, task::LocalWaker};
 use bytes::Bytes;
 use futures_util::future::{poll_fn, FutureExt, LocalBoxFuture};
 use fxhash::FxHashMap;
-use h2::client::{handshake, Connection, SendRequest};
+use h2::client::{Connection, SendRequest};
 use http::uri::Authority;
 use indexmap::IndexSet;
+use pin_project::pin_project;
 use slab::Slab;
 
+use super::config::ConnectorConfig;
 use super::connection::{ConnectionType, IoConnection};
 use super::error::ConnectError;
+use super::h2proto::handshake;
 use super::Connect;
 
 #[derive(Clone, Copy, PartialEq)]
@@ -49,27 +52,24 @@ where
     T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
         + 'static,
 {
-    pub(crate) fn new(
-        connector: T,
-        conn_lifetime: Duration,
-        conn_keep_alive: Duration,
-        disconnect_timeout: Option<Duration>,
-        limit: usize,
-    ) -> Self {
-        ConnectionPool(
-            Rc::new(RefCell::new(connector)),
-            Rc::new(RefCell::new(Inner {
-                conn_lifetime,
-                conn_keep_alive,
-                disconnect_timeout,
-                limit,
-                acquired: 0,
-                waiters: Slab::new(),
-                waiters_queue: IndexSet::new(),
-                available: FxHashMap::default(),
-                waker: LocalWaker::new(),
-            })),
-        )
+    pub(crate) fn new(connector: T, config: ConnectorConfig) -> Self {
+        let connector_rc = Rc::new(RefCell::new(connector));
+        let inner_rc = Rc::new(RefCell::new(Inner {
+            config,
+            acquired: 0,
+            waiters: Slab::new(),
+            waiters_queue: IndexSet::new(),
+            available: FxHashMap::default(),
+            waker: LocalWaker::new(),
+        }));
+
+        // start support future
+        actix_rt::spawn(ConnectorPoolSupport {
+            connector: Rc::clone(&connector_rc),
+            inner: Rc::clone(&inner_rc),
+        });
+
+        ConnectionPool(connector_rc, inner_rc)
     }
 }
 
@@ -82,6 +82,13 @@ where
     }
 }
 
+impl<T, Io> Drop for ConnectionPool<T, Io> {
+    fn drop(&mut self) {
+        // wake up the ConnectorPoolSupport when dropping so it can exit properly.
+        self.1.borrow().waker.wake();
+    }
+}
+
 impl<T, Io> Service for ConnectionPool<T, Io>
 where
     Io: AsyncRead + AsyncWrite + Unpin + 'static,
@@ -98,12 +105,6 @@ where
     }
 
     fn call(&mut self, req: Connect) -> Self::Future {
-        // start support future
-        actix_rt::spawn(ConnectorPoolSupport {
-            connector: self.0.clone(),
-            inner: self.1.clone(),
-        });
-
         let mut connector = self.0.clone();
         let inner = self.1.clone();
 
@@ -111,23 +112,25 @@ where
             let key = if let Some(authority) = req.uri.authority() {
                 authority.clone().into()
             } else {
-                return Err(ConnectError::Unresolverd);
+                return Err(ConnectError::Unresolved);
             };
 
             // acquire connection
             match poll_fn(|cx| Poll::Ready(inner.borrow_mut().acquire(&key, cx))).await {
                 Acquire::Acquired(io, created) => {
                     // use existing connection
-                    return Ok(IoConnection::new(
+                    Ok(IoConnection::new(
                         io,
                         created,
                         Some(Acquired(key, Some(inner))),
-                    ));
+                    ))
                 }
                 Acquire::Available => {
                     // open tcp connection
                     let (io, proto) = connector.call(req).await?;
 
+                    let config = inner.borrow().config.clone();
+
                     let guard = OpenGuard::new(key, inner);
 
                     if proto == Protocol::Http1 {
@@ -137,7 +140,7 @@ where
                             Some(guard.consume()),
                         ))
                     } else {
-                        let (snd, connection) = handshake(io).await?;
+                        let (snd, connection) = handshake(io, &config).await?;
                         actix_rt::spawn(connection.map(|_| ()));
                         Ok(IoConnection::new(
                             ConnectionType::H2(snd),
@@ -199,7 +202,7 @@ where
         if let Some(i) = self.inner.take() {
             let mut inner = i.as_ref().borrow_mut();
             inner.release_waiter(&self.key, self.token);
-            inner.check_availibility();
+            inner.check_availability();
         }
     }
 }
@@ -236,7 +239,7 @@ where
         if let Some(i) = self.inner.take() {
             let mut inner = i.as_ref().borrow_mut();
             inner.release();
-            inner.check_availibility();
+            inner.check_availability();
         }
     }
 }
@@ -254,10 +257,7 @@ struct AvailableConnection<Io> {
 }
 
 pub(crate) struct Inner<Io> {
-    conn_lifetime: Duration,
-    conn_keep_alive: Duration,
-    disconnect_timeout: Option<Duration>,
-    limit: usize,
+    config: ConnectorConfig,
     acquired: usize,
     available: FxHashMap<Key, VecDeque<AvailableConnection<Io>>>,
     waiters: Slab<
@@ -310,7 +310,7 @@ where
 
     fn acquire(&mut self, key: &Key, cx: &mut Context<'_>) -> Acquire<Io> {
         // check limits
-        if self.limit > 0 && self.acquired >= self.limit {
+        if self.config.limit > 0 && self.acquired >= self.config.limit {
             return Acquire::NotAvailable;
         }
 
@@ -322,10 +322,10 @@ where
             let now = Instant::now();
             while let Some(conn) = connections.pop_back() {
                 // check if it still usable
-                if (now - conn.used) > self.conn_keep_alive
-                    || (now - conn.created) > self.conn_lifetime
+                if (now - conn.used) > self.config.conn_keep_alive
+                    || (now - conn.created) > self.config.conn_lifetime
                 {
-                    if let Some(timeout) = self.disconnect_timeout {
+                    if let Some(timeout) = self.config.disconnect_timeout {
                         if let ConnectionType::H1(io) = conn.io {
                             actix_rt::spawn(CloseConnection::new(io, timeout))
                         }
@@ -337,7 +337,7 @@ where
                         match Pin::new(s).poll_read(cx, &mut buf) {
                             Poll::Pending => (),
                             Poll::Ready(Ok(n)) if n > 0 => {
-                                if let Some(timeout) = self.disconnect_timeout {
+                                if let Some(timeout) = self.config.disconnect_timeout {
                                     if let ConnectionType::H1(io) = io {
                                         actix_rt::spawn(CloseConnection::new(
                                             io, timeout,
@@ -366,21 +366,21 @@ where
                 created,
                 used: Instant::now(),
             });
-        self.check_availibility();
+        self.check_availability();
     }
 
     fn release_close(&mut self, io: ConnectionType<Io>) {
         self.acquired -= 1;
-        if let Some(timeout) = self.disconnect_timeout {
+        if let Some(timeout) = self.config.disconnect_timeout {
             if let ConnectionType::H1(io) = io {
                 actix_rt::spawn(CloseConnection::new(io, timeout))
             }
         }
-        self.check_availibility();
+        self.check_availability();
     }
 
-    fn check_availibility(&self) {
-        if !self.waiters_queue.is_empty() && self.acquired < self.limit {
+    fn check_availability(&self) {
+        if !self.waiters_queue.is_empty() && self.acquired < self.config.limit {
             self.waker.wake();
         }
     }
@@ -422,6 +422,7 @@ where
     }
 }
 
+#[pin_project]
 struct ConnectorPoolSupport<T, Io>
 where
     Io: AsyncRead + AsyncWrite + Unpin + 'static,
@@ -439,9 +440,15 @@ where
     type Output = ();
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = unsafe { self.get_unchecked_mut() };
+        let this = self.project();
 
-        let mut inner = this.inner.as_ref().borrow_mut();
+        if Rc::strong_count(this.inner) == 1 {
+            // If we are last copy of Inner<Io> it means the ConnectionPool is already gone
+            // and we are safe to exit.
+            return Poll::Ready(());
+        }
+
+        let mut inner = this.inner.borrow_mut();
         inner.waker.register(cx.waker());
 
         // check waiters
@@ -478,6 +485,7 @@ where
                         tx,
                         this.inner.clone(),
                         this.connector.call(connect),
+                        inner.config.clone(),
                     );
                 }
             }
@@ -488,10 +496,12 @@ where
     }
 }
 
+#[pin_project::pin_project(PinnedDrop)]
 struct OpenWaitingConnection<F, Io>
 where
     Io: AsyncRead + AsyncWrite + Unpin + 'static,
 {
+    #[pin]
     fut: F,
     key: Key,
     h2: Option<
@@ -502,6 +512,7 @@ where
     >,
     rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
     inner: Option<Rc<RefCell<Inner<Io>>>>,
+    config: ConnectorConfig,
 }
 
 impl<F, Io> OpenWaitingConnection<F, Io>
@@ -514,6 +525,7 @@ where
         rx: oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
         inner: Rc<RefCell<Inner<Io>>>,
         fut: F,
+        config: ConnectorConfig,
     ) {
         actix_rt::spawn(OpenWaitingConnection {
             key,
@@ -521,19 +533,21 @@ where
             h2: None,
             rx: Some(rx),
             inner: Some(inner),
+            config,
         })
     }
 }
 
-impl<F, Io> Drop for OpenWaitingConnection<F, Io>
+#[pin_project::pinned_drop]
+impl<F, Io> PinnedDrop for OpenWaitingConnection<F, Io>
 where
     Io: AsyncRead + AsyncWrite + Unpin + 'static,
 {
-    fn drop(&mut self) {
-        if let Some(inner) = self.inner.take() {
+    fn drop(self: Pin<&mut Self>) {
+        if let Some(inner) = self.project().inner.take() {
             let mut inner = inner.as_ref().borrow_mut();
             inner.release();
-            inner.check_availibility();
+            inner.check_availability();
         }
     }
 }
@@ -545,8 +559,8 @@ where
 {
     type Output = ();
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = unsafe { self.get_unchecked_mut() };
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.as_mut().project();
 
         if let Some(ref mut h2) = this.h2 {
             return match Pin::new(h2).poll(cx) {
@@ -571,7 +585,7 @@ where
             };
         }
 
-        match unsafe { Pin::new_unchecked(&mut this.fut) }.poll(cx) {
+        match this.fut.poll(cx) {
             Poll::Ready(Err(err)) => {
                 let _ = this.inner.take();
                 if let Some(rx) = this.rx.take() {
@@ -589,8 +603,8 @@ where
                     )));
                     Poll::Ready(())
                 } else {
-                    this.h2 = Some(handshake(io).boxed_local());
-                    unsafe { Pin::new_unchecked(this) }.poll(cx)
+                    *this.h2 = Some(handshake(io, this.config).boxed_local());
+                    self.poll(cx)
                 }
             }
             Poll::Pending => Poll::Pending,

actix-http/src/cloneable.rs

@@ -1,4 +1,4 @@
-use std::cell::UnsafeCell;
+use std::cell::RefCell;
 use std::rc::Rc;
 use std::task::{Context, Poll};
 
@@ -6,37 +6,35 @@ use actix_service::Service;
 
 #[doc(hidden)]
 /// Service that allows to turn non-clone service to a service with `Clone` impl
-pub(crate) struct CloneableService<T>(Rc<UnsafeCell<T>>);
+///
+/// # Panics
+/// CloneableService might panic with some creative use of thread local storage.
+/// See https://github.com/actix/actix-web/issues/1295 for example
+pub(crate) struct CloneableService<T: Service>(Rc<RefCell<T>>);
 
-impl<T> CloneableService<T> {
-    pub(crate) fn new(service: T) -> Self
-    where
-        T: Service,
-    {
-        Self(Rc::new(UnsafeCell::new(service)))
+impl<T: Service> CloneableService<T> {
+    pub(crate) fn new(service: T) -> Self {
+        Self(Rc::new(RefCell::new(service)))
     }
 }
 
-impl<T> Clone for CloneableService<T> {
+impl<T: Service> Clone for CloneableService<T> {
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }
 }
 
-impl<T> Service for CloneableService<T>
-where
-    T: Service,
-{
+impl<T: Service> Service for CloneableService<T> {
     type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type Future = T::Future;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        unsafe { &mut *self.0.as_ref().get() }.poll_ready(cx)
+        self.0.borrow_mut().poll_ready(cx)
     }
 
     fn call(&mut self, req: T::Request) -> Self::Future {
-        unsafe { &mut *self.0.as_ref().get() }.call(req)
+        self.0.borrow_mut().call(req)
     }
 }

actix-http/src/config.rs

@@ -1,4 +1,4 @@
-use std::cell::UnsafeCell;
+use std::cell::Cell;
 use std::fmt::Write;
 use std::rc::Rc;
 use std::time::Duration;
@@ -7,7 +7,7 @@ use std::{fmt, net};
 use actix_rt::time::{delay_for, delay_until, Delay, Instant};
 use bytes::BytesMut;
 use futures_util::{future, FutureExt};
-use time;
+use time::OffsetDateTime;
 
 // "Sun, 06 Nov 1994 08:49:37 GMT".len()
 const DATE_VALUE_LENGTH: usize = 29;
@@ -17,7 +17,7 @@ const DATE_VALUE_LENGTH: usize = 29;
 pub enum KeepAlive {
     /// Keep alive in seconds
     Timeout(usize),
-    /// Relay on OS to shutdown tcp connection
+    /// Rely on OS to shutdown tcp connection
     Os,
     /// Disabled
     Disabled,
@@ -114,7 +114,7 @@ impl ServiceConfig {
     }
 
     #[inline]
-    /// Return state of connection keep-alive funcitonality
+    /// Return state of connection keep-alive functionality
     pub fn keep_alive_enabled(&self) -> bool {
         self.0.ka_enabled
     }
@@ -209,9 +209,15 @@ impl Date {
         date.update();
         date
     }
+
     fn update(&mut self) {
         self.pos = 0;
-        write!(self, "{}", time::at_utc(time::get_time()).rfc822()).unwrap();
+        write!(
+            self,
+            "{}",
+            OffsetDateTime::now_utc().format("%a, %d %b %Y %H:%M:%S GMT")
+        )
+        .unwrap();
     }
 }
 
@@ -228,24 +234,24 @@ impl fmt::Write for Date {
 struct DateService(Rc<DateServiceInner>);
 
 struct DateServiceInner {
-    current: UnsafeCell<Option<(Date, Instant)>>,
+    current: Cell<Option<(Date, Instant)>>,
 }
 
 impl DateServiceInner {
     fn new() -> Self {
         DateServiceInner {
-            current: UnsafeCell::new(None),
+            current: Cell::new(None),
         }
     }
 
     fn reset(&self) {
-        unsafe { (&mut *self.current.get()).take() };
+        self.current.take();
     }
 
     fn update(&self) {
         let now = Instant::now();
         let date = Date::new();
-        *(unsafe { &mut *self.current.get() }) = Some((date, now));
+        self.current.set(Some((date, now)));
     }
 }
 
@@ -255,7 +261,7 @@ impl DateService {
     }
 
     fn check_date(&self) {
-        if unsafe { (&*self.0.current.get()).is_none() } {
+        if self.0.current.get().is_none() {
             self.0.update();
 
             // periodic date update
@@ -269,12 +275,12 @@ impl DateService {
 
     fn now(&self) -> Instant {
         self.check_date();
-        unsafe { (&*self.0.current.get()).as_ref().unwrap().1 }
+        self.0.current.get().unwrap().1
     }
 
     fn set_date<F: FnMut(&Date)>(&self, mut f: F) {
         self.check_date();
-        f(&unsafe { (&*self.0.current.get()).as_ref().unwrap().0 })
+        f(&self.0.current.get().unwrap().0);
     }
 }
 
@@ -282,6 +288,16 @@ impl DateService {
 mod tests {
     use super::*;
 
+    // Test modifying the date from within the closure
+    // passed to `set_date`
+    #[test]
+    fn test_evil_date() {
+        let service = DateService::new();
+        // Make sure that `check_date` doesn't try to spawn a task
+        service.0.update();
+        service.set_date(|_| service.0.reset());
+    }
+
     #[test]
     fn test_date_len() {
         assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());

actix-http/src/cookie/builder.rs

@@ -1,250 +0,0 @@
-use std::borrow::Cow;
-
-use chrono::Duration;
-use time::Tm;
-
-use super::{Cookie, SameSite};
-
-/// Structure that follows the builder pattern for building `Cookie` structs.
-///
-/// To construct a cookie:
-///
-///   1. Call [`Cookie::build`](struct.Cookie.html#method.build) to start building.
-///   2. Use any of the builder methods to set fields in the cookie.
-///   3. Call [finish](#method.finish) to retrieve the built cookie.
-///
-/// # Example
-///
-/// ```rust
-/// use actix_http::cookie::Cookie;
-///
-/// let cookie: Cookie = Cookie::build("name", "value")
-///     .domain("www.rust-lang.org")
-///     .path("/")
-///     .secure(true)
-///     .http_only(true)
-///     .max_age(84600)
-///     .finish();
-/// ```
-#[derive(Debug, Clone)]
-pub struct CookieBuilder {
-    /// The cookie being built.
-    cookie: Cookie<'static>,
-}
-
-impl CookieBuilder {
-    /// Creates a new `CookieBuilder` instance from the given name and value.
-    ///
-    /// This method is typically called indirectly via
-    /// [Cookie::build](struct.Cookie.html#method.build).
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar").finish();
-    /// assert_eq!(c.name_value(), ("foo", "bar"));
-    /// ```
-    pub fn new<N, V>(name: N, value: V) -> CookieBuilder
-    where
-        N: Into<Cow<'static, str>>,
-        V: Into<Cow<'static, str>>,
-    {
-        CookieBuilder {
-            cookie: Cookie::new(name, value),
-        }
-    }
-
-    /// Sets the `expires` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .expires(time::now())
-    ///     .finish();
-    ///
-    /// assert!(c.expires().is_some());
-    /// ```
-    #[inline]
-    pub fn expires(mut self, when: Tm) -> CookieBuilder {
-        self.cookie.set_expires(when);
-        self
-    }
-
-    /// Sets the `max_age` field in seconds in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .max_age(1800)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
-    /// ```
-    #[inline]
-    pub fn max_age(self, seconds: i64) -> CookieBuilder {
-        self.max_age_time(Duration::seconds(seconds))
-    }
-
-    /// Sets the `max_age` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .max_age_time(time::Duration::minutes(30))
-    ///     .finish();
-    ///
-    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
-    /// ```
-    #[inline]
-    pub fn max_age_time(mut self, value: Duration) -> CookieBuilder {
-        self.cookie.set_max_age(value);
-        self
-    }
-
-    /// Sets the `domain` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .domain("www.rust-lang.org")
-    ///     .finish();
-    ///
-    /// assert_eq!(c.domain(), Some("www.rust-lang.org"));
-    /// ```
-    pub fn domain<D: Into<Cow<'static, str>>>(mut self, value: D) -> CookieBuilder {
-        self.cookie.set_domain(value);
-        self
-    }
-
-    /// Sets the `path` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .path("/")
-    ///     .finish();
-    ///
-    /// assert_eq!(c.path(), Some("/"));
-    /// ```
-    pub fn path<P: Into<Cow<'static, str>>>(mut self, path: P) -> CookieBuilder {
-        self.cookie.set_path(path);
-        self
-    }
-
-    /// Sets the `secure` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .secure(true)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.secure(), Some(true));
-    /// ```
-    #[inline]
-    pub fn secure(mut self, value: bool) -> CookieBuilder {
-        self.cookie.set_secure(value);
-        self
-    }
-
-    /// Sets the `http_only` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .http_only(true)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.http_only(), Some(true));
-    /// ```
-    #[inline]
-    pub fn http_only(mut self, value: bool) -> CookieBuilder {
-        self.cookie.set_http_only(value);
-        self
-    }
-
-    /// Sets the `same_site` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{Cookie, SameSite};
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .same_site(SameSite::Strict)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.same_site(), Some(SameSite::Strict));
-    /// ```
-    #[inline]
-    pub fn same_site(mut self, value: SameSite) -> CookieBuilder {
-        self.cookie.set_same_site(value);
-        self
-    }
-
-    /// Makes the cookie being built 'permanent' by extending its expiration and
-    /// max age 20 years into the future.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    /// use chrono::Duration;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .permanent()
-    ///     .finish();
-    ///
-    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
-    /// # assert!(c.expires().is_some());
-    /// ```
-    #[inline]
-    pub fn permanent(mut self) -> CookieBuilder {
-        self.cookie.make_permanent();
-        self
-    }
-
-    /// Finishes building and returns the built `Cookie`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .domain("crates.io")
-    ///     .path("/")
-    ///     .finish();
-    ///
-    /// assert_eq!(c.name_value(), ("foo", "bar"));
-    /// assert_eq!(c.domain(), Some("crates.io"));
-    /// assert_eq!(c.path(), Some("/"));
-    /// ```
-    #[inline]
-    pub fn finish(self) -> Cookie<'static> {
-        self.cookie
-    }
-}

actix-http/src/cookie/delta.rs

@@ -1,71 +0,0 @@
-use std::borrow::Borrow;
-use std::hash::{Hash, Hasher};
-use std::ops::{Deref, DerefMut};
-
-use super::Cookie;
-
-/// A `DeltaCookie` is a helper structure used in a cookie jar. It wraps a
-/// `Cookie` so that it can be hashed and compared purely by name. It further
-/// records whether the wrapped cookie is a "removal" cookie, that is, a cookie
-/// that when sent to the client removes the named cookie on the client's
-/// machine.
-#[derive(Clone, Debug)]
-pub struct DeltaCookie {
-    pub cookie: Cookie<'static>,
-    pub removed: bool,
-}
-
-impl DeltaCookie {
-    /// Create a new `DeltaCookie` that is being added to a jar.
-    #[inline]
-    pub fn added(cookie: Cookie<'static>) -> DeltaCookie {
-        DeltaCookie {
-            cookie,
-            removed: false,
-        }
-    }
-
-    /// Create a new `DeltaCookie` that is being removed from a jar. The
-    /// `cookie` should be a "removal" cookie.
-    #[inline]
-    pub fn removed(cookie: Cookie<'static>) -> DeltaCookie {
-        DeltaCookie {
-            cookie,
-            removed: true,
-        }
-    }
-}
-
-impl Deref for DeltaCookie {
-    type Target = Cookie<'static>;
-
-    fn deref(&self) -> &Cookie<'static> {
-        &self.cookie
-    }
-}
-
-impl DerefMut for DeltaCookie {
-    fn deref_mut(&mut self) -> &mut Cookie<'static> {
-        &mut self.cookie
-    }
-}
-
-impl PartialEq for DeltaCookie {
-    fn eq(&self, other: &DeltaCookie) -> bool {
-        self.name() == other.name()
-    }
-}
-
-impl Eq for DeltaCookie {}
-
-impl Hash for DeltaCookie {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.name().hash(state);
-    }
-}
-
-impl Borrow<str> for DeltaCookie {
-    fn borrow(&self) -> &str {
-        self.name()
-    }
-}

actix-http/src/cookie/draft.rs

@@ -1,98 +0,0 @@
-//! This module contains types that represent cookie properties that are not yet
-//! standardized. That is, _draft_ features.
-
-use std::fmt;
-
-/// The `SameSite` cookie attribute.
-///
-/// A cookie with a `SameSite` attribute is imposed restrictions on when it is
-/// sent to the origin server in a cross-site request. If the `SameSite`
-/// attribute is "Strict", then the cookie is never sent in cross-site requests.
-/// If the `SameSite` attribute is "Lax", the cookie is only sent in cross-site
-/// requests with "safe" HTTP methods, i.e, `GET`, `HEAD`, `OPTIONS`, `TRACE`.
-/// If the `SameSite` attribute is not present (made explicit via the
-/// `SameSite::None` variant), then the cookie will be sent as normal.
-///
-/// **Note:** This cookie attribute is an HTTP draft! Its meaning and definition
-/// are subject to change.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum SameSite {
-    /// The "Strict" `SameSite` attribute.
-    Strict,
-    /// The "Lax" `SameSite` attribute.
-    Lax,
-    /// No `SameSite` attribute.
-    None,
-}
-
-impl SameSite {
-    /// Returns `true` if `self` is `SameSite::Strict` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::SameSite;
-    ///
-    /// let strict = SameSite::Strict;
-    /// assert!(strict.is_strict());
-    /// assert!(!strict.is_lax());
-    /// assert!(!strict.is_none());
-    /// ```
-    #[inline]
-    pub fn is_strict(self) -> bool {
-        match self {
-            SameSite::Strict => true,
-            SameSite::Lax | SameSite::None => false,
-        }
-    }
-
-    /// Returns `true` if `self` is `SameSite::Lax` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::SameSite;
-    ///
-    /// let lax = SameSite::Lax;
-    /// assert!(lax.is_lax());
-    /// assert!(!lax.is_strict());
-    /// assert!(!lax.is_none());
-    /// ```
-    #[inline]
-    pub fn is_lax(self) -> bool {
-        match self {
-            SameSite::Lax => true,
-            SameSite::Strict | SameSite::None => false,
-        }
-    }
-
-    /// Returns `true` if `self` is `SameSite::None` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::SameSite;
-    ///
-    /// let none = SameSite::None;
-    /// assert!(none.is_none());
-    /// assert!(!none.is_lax());
-    /// assert!(!none.is_strict());
-    /// ```
-    #[inline]
-    pub fn is_none(self) -> bool {
-        match self {
-            SameSite::None => true,
-            SameSite::Lax | SameSite::Strict => false,
-        }
-    }
-}
-
-impl fmt::Display for SameSite {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            SameSite::Strict => write!(f, "Strict"),
-            SameSite::Lax => write!(f, "Lax"),
-            SameSite::None => Ok(()),
-        }
-    }
-}

actix-http/src/cookie/jar.rs

@@ -1,651 +0,0 @@
-use std::collections::HashSet;
-use std::mem::replace;
-
-use chrono::Duration;
-
-use super::delta::DeltaCookie;
-use super::Cookie;
-
-#[cfg(feature = "secure-cookies")]
-use super::secure::{Key, PrivateJar, SignedJar};
-
-/// A collection of cookies that tracks its modifications.
-///
-/// A `CookieJar` provides storage for any number of cookies. Any changes made
-/// to the jar are tracked; the changes can be retrieved via the
-/// [delta](#method.delta) method which returns an interator over the changes.
-///
-/// # Usage
-///
-/// A jar's life begins via [new](#method.new) and calls to
-/// [`add_original`](#method.add_original):
-///
-/// ```rust
-/// use actix_http::cookie::{Cookie, CookieJar};
-///
-/// let mut jar = CookieJar::new();
-/// jar.add_original(Cookie::new("name", "value"));
-/// jar.add_original(Cookie::new("second", "another"));
-/// ```
-///
-/// Cookies can be added via [add](#method.add) and removed via
-/// [remove](#method.remove). Finally, cookies can be looked up via
-/// [get](#method.get):
-///
-/// ```rust
-/// # use actix_http::cookie::{Cookie, CookieJar};
-/// let mut jar = CookieJar::new();
-/// jar.add(Cookie::new("a", "one"));
-/// jar.add(Cookie::new("b", "two"));
-///
-/// assert_eq!(jar.get("a").map(|c| c.value()), Some("one"));
-/// assert_eq!(jar.get("b").map(|c| c.value()), Some("two"));
-///
-/// jar.remove(Cookie::named("b"));
-/// assert!(jar.get("b").is_none());
-/// ```
-///
-/// # Deltas
-///
-/// A jar keeps track of any modifications made to it over time. The
-/// modifications are recorded as cookies. The modifications can be retrieved
-/// via [delta](#method.delta). Any new `Cookie` added to a jar via `add`
-/// results in the same `Cookie` appearing in the `delta`; cookies added via
-/// `add_original` do not count towards the delta. Any _original_ cookie that is
-/// removed from a jar results in a "removal" cookie appearing in the delta. A
-/// "removal" cookie is a cookie that a server sends so that the cookie is
-/// removed from the client's machine.
-///
-/// Deltas are typically used to create `Set-Cookie` headers corresponding to
-/// the changes made to a cookie jar over a period of time.
-///
-/// ```rust
-/// # use actix_http::cookie::{Cookie, CookieJar};
-/// let mut jar = CookieJar::new();
-///
-/// // original cookies don't affect the delta
-/// jar.add_original(Cookie::new("original", "value"));
-/// assert_eq!(jar.delta().count(), 0);
-///
-/// // new cookies result in an equivalent `Cookie` in the delta
-/// jar.add(Cookie::new("a", "one"));
-/// jar.add(Cookie::new("b", "two"));
-/// assert_eq!(jar.delta().count(), 2);
-///
-/// // removing an original cookie adds a "removal" cookie to the delta
-/// jar.remove(Cookie::named("original"));
-/// assert_eq!(jar.delta().count(), 3);
-///
-/// // removing a new cookie that was added removes that `Cookie` from the delta
-/// jar.remove(Cookie::named("a"));
-/// assert_eq!(jar.delta().count(), 2);
-/// ```
-#[derive(Default, Debug, Clone)]
-pub struct CookieJar {
-    original_cookies: HashSet<DeltaCookie>,
-    delta_cookies: HashSet<DeltaCookie>,
-}
-
-impl CookieJar {
-    /// Creates an empty cookie jar.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::CookieJar;
-    ///
-    /// let jar = CookieJar::new();
-    /// assert_eq!(jar.iter().count(), 0);
-    /// ```
-    pub fn new() -> CookieJar {
-        CookieJar::default()
-    }
-
-    /// Returns a reference to the `Cookie` inside this jar with the name
-    /// `name`. If no such cookie exists, returns `None`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// assert!(jar.get("name").is_none());
-    ///
-    /// jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
-    /// ```
-    pub fn get(&self, name: &str) -> Option<&Cookie<'static>> {
-        self.delta_cookies
-            .get(name)
-            .or_else(|| self.original_cookies.get(name))
-            .and_then(|c| if !c.removed { Some(&c.cookie) } else { None })
-    }
-
-    /// Adds an "original" `cookie` to this jar. If an original cookie with the
-    /// same name already exists, it is replaced with `cookie`. Cookies added
-    /// with `add` take precedence and are not replaced by this method.
-    ///
-    /// Adding an original cookie does not affect the [delta](#method.delta)
-    /// computation. This method is intended to be used to seed the cookie jar
-    /// with cookies received from a client's HTTP message.
-    ///
-    /// For accurate `delta` computations, this method should not be called
-    /// after calling `remove`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add_original(Cookie::new("second", "two"));
-    ///
-    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
-    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
-    /// assert_eq!(jar.iter().count(), 2);
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn add_original(&mut self, cookie: Cookie<'static>) {
-        self.original_cookies.replace(DeltaCookie::added(cookie));
-    }
-
-    /// Adds `cookie` to this jar. If a cookie with the same name already
-    /// exists, it is replaced with `cookie`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add(Cookie::new("name", "value"));
-    /// jar.add(Cookie::new("second", "two"));
-    ///
-    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
-    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
-    /// assert_eq!(jar.iter().count(), 2);
-    /// assert_eq!(jar.delta().count(), 2);
-    /// ```
-    pub fn add(&mut self, cookie: Cookie<'static>) {
-        self.delta_cookies.replace(DeltaCookie::added(cookie));
-    }
-
-    /// Removes `cookie` from this jar. If an _original_ cookie with the same
-    /// name as `cookie` is present in the jar, a _removal_ cookie will be
-    /// present in the `delta` computation. To properly generate the removal
-    /// cookie, `cookie` must contain the same `path` and `domain` as the cookie
-    /// that was initially set.
-    ///
-    /// A "removal" cookie is a cookie that has the same name as the original
-    /// cookie but has an empty value, a max-age of 0, and an expiration date
-    /// far in the past.
-    ///
-    /// # Example
-    ///
-    /// Removing an _original_ cookie results in a _removal_ cookie:
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use chrono::Duration;
-    ///
-    /// let mut jar = CookieJar::new();
-    ///
-    /// // Assume this cookie originally had a path of "/" and domain of "a.b".
-    /// jar.add_original(Cookie::new("name", "value"));
-    ///
-    /// // If the path and domain were set, they must be provided to `remove`.
-    /// jar.remove(Cookie::build("name", "").path("/").domain("a.b").finish());
-    ///
-    /// // The delta will contain the removal cookie.
-    /// let delta: Vec<_> = jar.delta().collect();
-    /// assert_eq!(delta.len(), 1);
-    /// assert_eq!(delta[0].name(), "name");
-    /// assert_eq!(delta[0].max_age(), Some(Duration::seconds(0)));
-    /// ```
-    ///
-    /// Removing a new cookie does not result in a _removal_ cookie:
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(jar.delta().count(), 1);
-    ///
-    /// jar.remove(Cookie::named("name"));
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn remove(&mut self, mut cookie: Cookie<'static>) {
-        if self.original_cookies.contains(cookie.name()) {
-            cookie.set_value("");
-            cookie.set_max_age(Duration::seconds(0));
-            cookie.set_expires(time::now() - Duration::days(365));
-            self.delta_cookies.replace(DeltaCookie::removed(cookie));
-        } else {
-            self.delta_cookies.remove(cookie.name());
-        }
-    }
-
-    /// Removes `cookie` from this jar completely. This method differs from
-    /// `remove` in that no delta cookie is created under any condition. Neither
-    /// the `delta` nor `iter` methods will return a cookie that is removed
-    /// using this method.
-    ///
-    /// # Example
-    ///
-    /// Removing an _original_ cookie; no _removal_ cookie is generated:
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use chrono::Duration;
-    ///
-    /// let mut jar = CookieJar::new();
-    ///
-    /// // Add an original cookie and a new cookie.
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add(Cookie::new("key", "value"));
-    /// assert_eq!(jar.delta().count(), 1);
-    /// assert_eq!(jar.iter().count(), 2);
-    ///
-    /// // Now force remove the original cookie.
-    /// jar.force_remove(Cookie::new("name", "value"));
-    /// assert_eq!(jar.delta().count(), 1);
-    /// assert_eq!(jar.iter().count(), 1);
-    ///
-    /// // Now force remove the new cookie.
-    /// jar.force_remove(Cookie::new("key", "value"));
-    /// assert_eq!(jar.delta().count(), 0);
-    /// assert_eq!(jar.iter().count(), 0);
-    /// ```
-    pub fn force_remove<'a>(&mut self, cookie: Cookie<'a>) {
-        self.original_cookies.remove(cookie.name());
-        self.delta_cookies.remove(cookie.name());
-    }
-
-    /// Removes all cookies from this cookie jar.
-    #[deprecated(
-        since = "0.7.0",
-        note = "calling this method may not remove \
-                all cookies since the path and domain are not specified; use \
-                `remove` instead"
-    )]
-    pub fn clear(&mut self) {
-        self.delta_cookies.clear();
-        for delta in replace(&mut self.original_cookies, HashSet::new()) {
-            self.remove(delta.cookie);
-        }
-    }
-
-    /// Returns an iterator over cookies that represent the changes to this jar
-    /// over time. These cookies can be rendered directly as `Set-Cookie` header
-    /// values to affect the changes made to this jar on the client.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add_original(Cookie::new("second", "two"));
-    ///
-    /// // Add new cookies.
-    /// jar.add(Cookie::new("new", "third"));
-    /// jar.add(Cookie::new("another", "fourth"));
-    /// jar.add(Cookie::new("yac", "fifth"));
-    ///
-    /// // Remove some cookies.
-    /// jar.remove(Cookie::named("name"));
-    /// jar.remove(Cookie::named("another"));
-    ///
-    /// // Delta contains two new cookies ("new", "yac") and a removal ("name").
-    /// assert_eq!(jar.delta().count(), 3);
-    /// ```
-    pub fn delta(&self) -> Delta<'_> {
-        Delta {
-            iter: self.delta_cookies.iter(),
-        }
-    }
-
-    /// Returns an iterator over all of the cookies present in this jar.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    ///
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add_original(Cookie::new("second", "two"));
-    ///
-    /// jar.add(Cookie::new("new", "third"));
-    /// jar.add(Cookie::new("another", "fourth"));
-    /// jar.add(Cookie::new("yac", "fifth"));
-    ///
-    /// jar.remove(Cookie::named("name"));
-    /// jar.remove(Cookie::named("another"));
-    ///
-    /// // There are three cookies in the jar: "second", "new", and "yac".
-    /// # assert_eq!(jar.iter().count(), 3);
-    /// for cookie in jar.iter() {
-    ///     match cookie.name() {
-    ///         "second" => assert_eq!(cookie.value(), "two"),
-    ///         "new" => assert_eq!(cookie.value(), "third"),
-    ///         "yac" => assert_eq!(cookie.value(), "fifth"),
-    ///         _ => unreachable!("there are only three cookies in the jar")
-    ///     }
-    /// }
-    /// ```
-    pub fn iter(&self) -> Iter<'_> {
-        Iter {
-            delta_cookies: self
-                .delta_cookies
-                .iter()
-                .chain(self.original_cookies.difference(&self.delta_cookies)),
-        }
-    }
-
-    /// Returns a `PrivateJar` with `self` as its parent jar using the key `key`
-    /// to sign/encrypt and verify/decrypt cookies added/retrieved from the
-    /// child jar.
-    ///
-    /// Any modifications to the child jar will be reflected on the parent jar,
-    /// and any retrievals from the child jar will be made from the parent jar.
-    ///
-    /// This method is only available when the `secure` feature is enabled.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{Cookie, CookieJar, Key};
-    ///
-    /// // Generate a secure key.
-    /// let key = Key::generate();
-    ///
-    /// // Add a private (signed + encrypted) cookie.
-    /// let mut jar = CookieJar::new();
-    /// jar.private(&key).add(Cookie::new("private", "text"));
-    ///
-    /// // The cookie's contents are encrypted.
-    /// assert_ne!(jar.get("private").unwrap().value(), "text");
-    ///
-    /// // They can be decrypted and verified through the child jar.
-    /// assert_eq!(jar.private(&key).get("private").unwrap().value(), "text");
-    ///
-    /// // A tampered with cookie does not validate but still exists.
-    /// let mut cookie = jar.get("private").unwrap().clone();
-    /// jar.add(Cookie::new("private", cookie.value().to_string() + "!"));
-    /// assert!(jar.private(&key).get("private").is_none());
-    /// assert!(jar.get("private").is_some());
-    /// ```
-    #[cfg(feature = "secure-cookies")]
-    pub fn private(&mut self, key: &Key) -> PrivateJar<'_> {
-        PrivateJar::new(self, key)
-    }
-
-    /// Returns a `SignedJar` with `self` as its parent jar using the key `key`
-    /// to sign/verify cookies added/retrieved from the child jar.
-    ///
-    /// Any modifications to the child jar will be reflected on the parent jar,
-    /// and any retrievals from the child jar will be made from the parent jar.
-    ///
-    /// This method is only available when the `secure` feature is enabled.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{Cookie, CookieJar, Key};
-    ///
-    /// // Generate a secure key.
-    /// let key = Key::generate();
-    ///
-    /// // Add a signed cookie.
-    /// let mut jar = CookieJar::new();
-    /// jar.signed(&key).add(Cookie::new("signed", "text"));
-    ///
-    /// // The cookie's contents are signed but still in plaintext.
-    /// assert_ne!(jar.get("signed").unwrap().value(), "text");
-    /// assert!(jar.get("signed").unwrap().value().contains("text"));
-    ///
-    /// // They can be verified through the child jar.
-    /// assert_eq!(jar.signed(&key).get("signed").unwrap().value(), "text");
-    ///
-    /// // A tampered with cookie does not validate but still exists.
-    /// let mut cookie = jar.get("signed").unwrap().clone();
-    /// jar.add(Cookie::new("signed", cookie.value().to_string() + "!"));
-    /// assert!(jar.signed(&key).get("signed").is_none());
-    /// assert!(jar.get("signed").is_some());
-    /// ```
-    #[cfg(feature = "secure-cookies")]
-    pub fn signed(&mut self, key: &Key) -> SignedJar<'_> {
-        SignedJar::new(self, key)
-    }
-}
-
-use std::collections::hash_set::Iter as HashSetIter;
-
-/// Iterator over the changes to a cookie jar.
-pub struct Delta<'a> {
-    iter: HashSetIter<'a, DeltaCookie>,
-}
-
-impl<'a> Iterator for Delta<'a> {
-    type Item = &'a Cookie<'static>;
-
-    fn next(&mut self) -> Option<&'a Cookie<'static>> {
-        self.iter.next().map(|c| &c.cookie)
-    }
-}
-
-use std::collections::hash_map::RandomState;
-use std::collections::hash_set::Difference;
-use std::iter::Chain;
-
-/// Iterator over all of the cookies in a jar.
-pub struct Iter<'a> {
-    delta_cookies:
-        Chain<HashSetIter<'a, DeltaCookie>, Difference<'a, DeltaCookie, RandomState>>,
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = &'a Cookie<'static>;
-
-    fn next(&mut self) -> Option<&'a Cookie<'static>> {
-        for cookie in self.delta_cookies.by_ref() {
-            if !cookie.removed {
-                return Some(&*cookie);
-            }
-        }
-
-        None
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #[cfg(feature = "secure-cookies")]
-    use super::Key;
-    use super::{Cookie, CookieJar};
-
-    #[test]
-    #[allow(deprecated)]
-    fn simple() {
-        let mut c = CookieJar::new();
-
-        c.add(Cookie::new("test", ""));
-        c.add(Cookie::new("test2", ""));
-        c.remove(Cookie::named("test"));
-
-        assert!(c.get("test").is_none());
-        assert!(c.get("test2").is_some());
-
-        c.add(Cookie::new("test3", ""));
-        c.clear();
-
-        assert!(c.get("test").is_none());
-        assert!(c.get("test2").is_none());
-        assert!(c.get("test3").is_none());
-    }
-
-    #[test]
-    fn jar_is_send() {
-        fn is_send<T: Send>(_: T) -> bool {
-            true
-        }
-
-        assert!(is_send(CookieJar::new()))
-    }
-
-    #[test]
-    #[cfg(feature = "secure-cookies")]
-    fn iter() {
-        let key = Key::generate();
-        let mut c = CookieJar::new();
-
-        c.add_original(Cookie::new("original", "original"));
-
-        c.add(Cookie::new("test", "test"));
-        c.add(Cookie::new("test2", "test2"));
-        c.add(Cookie::new("test3", "test3"));
-        assert_eq!(c.iter().count(), 4);
-
-        c.signed(&key).add(Cookie::new("signed", "signed"));
-        c.private(&key).add(Cookie::new("encrypted", "encrypted"));
-        assert_eq!(c.iter().count(), 6);
-
-        c.remove(Cookie::named("test"));
-        assert_eq!(c.iter().count(), 5);
-
-        c.remove(Cookie::named("signed"));
-        c.remove(Cookie::named("test2"));
-        assert_eq!(c.iter().count(), 3);
-
-        c.add(Cookie::new("test2", "test2"));
-        assert_eq!(c.iter().count(), 4);
-
-        c.remove(Cookie::named("test2"));
-        assert_eq!(c.iter().count(), 3);
-    }
-
-    #[test]
-    #[cfg(feature = "secure-cookies")]
-    fn delta() {
-        use chrono::Duration;
-        use std::collections::HashMap;
-
-        let mut c = CookieJar::new();
-
-        c.add_original(Cookie::new("original", "original"));
-        c.add_original(Cookie::new("original1", "original1"));
-
-        c.add(Cookie::new("test", "test"));
-        c.add(Cookie::new("test2", "test2"));
-        c.add(Cookie::new("test3", "test3"));
-        c.add(Cookie::new("test4", "test4"));
-
-        c.remove(Cookie::named("test"));
-        c.remove(Cookie::named("original"));
-
-        assert_eq!(c.delta().count(), 4);
-
-        let names: HashMap<_, _> = c.delta().map(|c| (c.name(), c.max_age())).collect();
-
-        assert!(names.get("test2").unwrap().is_none());
-        assert!(names.get("test3").unwrap().is_none());
-        assert!(names.get("test4").unwrap().is_none());
-        assert_eq!(names.get("original").unwrap(), &Some(Duration::seconds(0)));
-    }
-
-    #[test]
-    fn replace_original() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::new("original_a", "a"));
-        jar.add_original(Cookie::new("original_b", "b"));
-        assert_eq!(jar.get("original_a").unwrap().value(), "a");
-
-        jar.add(Cookie::new("original_a", "av2"));
-        assert_eq!(jar.get("original_a").unwrap().value(), "av2");
-    }
-
-    #[test]
-    fn empty_delta() {
-        let mut jar = CookieJar::new();
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().count(), 1);
-    }
-
-    #[test]
-    fn add_remove_add() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        // The cookie's been deleted. Another original doesn't change that.
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-    }
-
-    #[test]
-    fn replace_remove() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 1);
-        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-    }
-
-    #[test]
-    fn remove_with_path() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::build("name", "val").finish());
-        assert_eq!(jar.iter().count(), 1);
-        assert_eq!(jar.delta().count(), 0);
-        assert_eq!(jar.iter().filter(|c| c.path().is_none()).count(), 1);
-
-        jar.remove(Cookie::build("name", "").path("/").finish());
-        assert_eq!(jar.iter().count(), 0);
-        assert_eq!(jar.delta().count(), 1);
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().filter(|c| c.path() == Some("/")).count(), 1);
-    }
-}

actix-http/src/cookie/parse.rs

@@ -1,421 +0,0 @@
-use std::borrow::Cow;
-use std::cmp;
-use std::convert::From;
-use std::error::Error;
-use std::fmt;
-use std::str::Utf8Error;
-
-use chrono::Duration;
-use percent_encoding::percent_decode;
-
-use super::{Cookie, CookieStr, SameSite};
-
-/// Enum corresponding to a parsing error.
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum ParseError {
-    /// The cookie did not contain a name/value pair.
-    MissingPair,
-    /// The cookie's name was empty.
-    EmptyName,
-    /// Decoding the cookie's name or value resulted in invalid UTF-8.
-    Utf8Error(Utf8Error),
-    /// It is discouraged to exhaustively match on this enum as its variants may
-    /// grow without a breaking-change bump in version numbers.
-    #[doc(hidden)]
-    __Nonexhasutive,
-}
-
-impl ParseError {
-    /// Returns a description of this error as a string
-    pub fn as_str(&self) -> &'static str {
-        match *self {
-            ParseError::MissingPair => "the cookie is missing a name/value pair",
-            ParseError::EmptyName => "the cookie's name is empty",
-            ParseError::Utf8Error(_) => {
-                "decoding the cookie's name or value resulted in invalid UTF-8"
-            }
-            ParseError::__Nonexhasutive => unreachable!("__Nonexhasutive ParseError"),
-        }
-    }
-}
-
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-impl From<Utf8Error> for ParseError {
-    fn from(error: Utf8Error) -> ParseError {
-        ParseError::Utf8Error(error)
-    }
-}
-
-impl Error for ParseError {}
-
-fn indexes_of(needle: &str, haystack: &str) -> Option<(usize, usize)> {
-    let haystack_start = haystack.as_ptr() as usize;
-    let needle_start = needle.as_ptr() as usize;
-
-    if needle_start < haystack_start {
-        return None;
-    }
-
-    if (needle_start + needle.len()) > (haystack_start + haystack.len()) {
-        return None;
-    }
-
-    let start = needle_start - haystack_start;
-    let end = start + needle.len();
-    Some((start, end))
-}
-
-fn name_val_decoded(
-    name: &str,
-    val: &str,
-) -> Result<(CookieStr, CookieStr), ParseError> {
-    let decoded_name = percent_decode(name.as_bytes()).decode_utf8()?;
-    let decoded_value = percent_decode(val.as_bytes()).decode_utf8()?;
-    let name = CookieStr::Concrete(Cow::Owned(decoded_name.into_owned()));
-    let val = CookieStr::Concrete(Cow::Owned(decoded_value.into_owned()));
-
-    Ok((name, val))
-}
-
-// This function does the real parsing but _does not_ set the `cookie_string` in
-// the returned cookie object. This only exists so that the borrow to `s` is
-// returned at the end of the call, allowing the `cookie_string` field to be
-// set in the outer `parse` function.
-fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
-    let mut attributes = s.split(';');
-    let key_value = match attributes.next() {
-        Some(s) => s,
-        _ => panic!(),
-    };
-
-    // Determine the name = val.
-    let (name, value) = match key_value.find('=') {
-        Some(i) => (key_value[..i].trim(), key_value[(i + 1)..].trim()),
-        None => return Err(ParseError::MissingPair),
-    };
-
-    if name.is_empty() {
-        return Err(ParseError::EmptyName);
-    }
-
-    // Create a cookie with all of the defaults. We'll fill things in while we
-    // iterate through the parameters below.
-    let (name, value) = if decode {
-        name_val_decoded(name, value)?
-    } else {
-        let name_indexes = indexes_of(name, s).expect("name sub");
-        let value_indexes = indexes_of(value, s).expect("value sub");
-        let name = CookieStr::Indexed(name_indexes.0, name_indexes.1);
-        let value = CookieStr::Indexed(value_indexes.0, value_indexes.1);
-
-        (name, value)
-    };
-
-    let mut cookie = Cookie {
-        name,
-        value,
-        cookie_string: None,
-        expires: None,
-        max_age: None,
-        domain: None,
-        path: None,
-        secure: None,
-        http_only: None,
-        same_site: None,
-    };
-
-    for attr in attributes {
-        let (key, value) = match attr.find('=') {
-            Some(i) => (attr[..i].trim(), Some(attr[(i + 1)..].trim())),
-            None => (attr.trim(), None),
-        };
-
-        match (&*key.to_ascii_lowercase(), value) {
-            ("secure", _) => cookie.secure = Some(true),
-            ("httponly", _) => cookie.http_only = Some(true),
-            ("max-age", Some(v)) => {
-                // See RFC 6265 Section 5.2.2, negative values indicate that the
-                // earliest possible expiration time should be used, so set the
-                // max age as 0 seconds.
-                cookie.max_age = match v.parse() {
-                    Ok(val) if val <= 0 => Some(Duration::zero()),
-                    Ok(val) => {
-                        // Don't panic if the max age seconds is greater than what's supported by
-                        // `Duration`.
-                        let val = cmp::min(val, Duration::max_value().num_seconds());
-                        Some(Duration::seconds(val))
-                    }
-                    Err(_) => continue,
-                };
-            }
-            ("domain", Some(mut domain)) if !domain.is_empty() => {
-                if domain.starts_with('.') {
-                    domain = &domain[1..];
-                }
-
-                let (i, j) = indexes_of(domain, s).expect("domain sub");
-                cookie.domain = Some(CookieStr::Indexed(i, j));
-            }
-            ("path", Some(v)) => {
-                let (i, j) = indexes_of(v, s).expect("path sub");
-                cookie.path = Some(CookieStr::Indexed(i, j));
-            }
-            ("samesite", Some(v)) => {
-                if v.eq_ignore_ascii_case("strict") {
-                    cookie.same_site = Some(SameSite::Strict);
-                } else if v.eq_ignore_ascii_case("lax") {
-                    cookie.same_site = Some(SameSite::Lax);
-                } else {
-                    // We do nothing here, for now. When/if the `SameSite`
-                    // attribute becomes standard, the spec says that we should
-                    // ignore this cookie, i.e, fail to parse it, when an
-                    // invalid value is passed in. The draft is at
-                    // http://httpwg.org/http-extensions/draft-ietf-httpbis-cookie-same-site.html.
-                }
-            }
-            ("expires", Some(v)) => {
-                // Try strptime with three date formats according to
-                // http://tools.ietf.org/html/rfc2616#section-3.3.1. Try
-                // additional ones as encountered in the real world.
-                let tm = time::strptime(v, "%a, %d %b %Y %H:%M:%S %Z")
-                    .or_else(|_| time::strptime(v, "%A, %d-%b-%y %H:%M:%S %Z"))
-                    .or_else(|_| time::strptime(v, "%a, %d-%b-%Y %H:%M:%S %Z"))
-                    .or_else(|_| time::strptime(v, "%a %b %d %H:%M:%S %Y"));
-
-                if let Ok(time) = tm {
-                    cookie.expires = Some(time)
-                }
-            }
-            _ => {
-                // We're going to be permissive here. If we have no idea what
-                // this is, then it's something nonstandard. We're not going to
-                // store it (because it's not compliant), but we're also not
-                // going to emit an error.
-            }
-        }
-    }
-
-    Ok(cookie)
-}
-
-pub fn parse_cookie<'c, S>(cow: S, decode: bool) -> Result<Cookie<'c>, ParseError>
-where
-    S: Into<Cow<'c, str>>,
-{
-    let s = cow.into();
-    let mut cookie = parse_inner(&s, decode)?;
-    cookie.cookie_string = Some(s);
-    Ok(cookie)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Cookie, SameSite};
-    use chrono::Duration;
-    use time::strptime;
-
-    macro_rules! assert_eq_parse {
-        ($string:expr, $expected:expr) => {
-            let cookie = match Cookie::parse($string) {
-                Ok(cookie) => cookie,
-                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
-            };
-
-            assert_eq!(cookie, $expected);
-        };
-    }
-
-    macro_rules! assert_ne_parse {
-        ($string:expr, $expected:expr) => {
-            let cookie = match Cookie::parse($string) {
-                Ok(cookie) => cookie,
-                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
-            };
-
-            assert_ne!(cookie, $expected);
-        };
-    }
-
-    #[test]
-    fn parse_same_site() {
-        let expected = Cookie::build("foo", "bar")
-            .same_site(SameSite::Lax)
-            .finish();
-
-        assert_eq_parse!("foo=bar; SameSite=Lax", expected);
-        assert_eq_parse!("foo=bar; SameSite=lax", expected);
-        assert_eq_parse!("foo=bar; SameSite=LAX", expected);
-        assert_eq_parse!("foo=bar; samesite=Lax", expected);
-        assert_eq_parse!("foo=bar; SAMESITE=Lax", expected);
-
-        let expected = Cookie::build("foo", "bar")
-            .same_site(SameSite::Strict)
-            .finish();
-
-        assert_eq_parse!("foo=bar; SameSite=Strict", expected);
-        assert_eq_parse!("foo=bar; SameSITE=Strict", expected);
-        assert_eq_parse!("foo=bar; SameSite=strict", expected);
-        assert_eq_parse!("foo=bar; SameSite=STrICT", expected);
-        assert_eq_parse!("foo=bar; SameSite=STRICT", expected);
-    }
-
-    #[test]
-    fn parse() {
-        assert!(Cookie::parse("bar").is_err());
-        assert!(Cookie::parse("=bar").is_err());
-        assert!(Cookie::parse(" =bar").is_err());
-        assert!(Cookie::parse("foo=").is_ok());
-
-        let expected = Cookie::build("foo", "bar=baz").finish();
-        assert_eq_parse!("foo=bar=baz", expected);
-
-        let mut expected = Cookie::build("foo", "bar").finish();
-        assert_eq_parse!("foo=bar", expected);
-        assert_eq_parse!("foo = bar", expected);
-        assert_eq_parse!(" foo=bar ", expected);
-        assert_eq_parse!(" foo=bar ;Domain=", expected);
-        assert_eq_parse!(" foo=bar ;Domain= ", expected);
-        assert_eq_parse!(" foo=bar ;Ignored", expected);
-
-        let mut unexpected = Cookie::build("foo", "bar").http_only(false).finish();
-        assert_ne_parse!(" foo=bar ;HttpOnly", unexpected);
-        assert_ne_parse!(" foo=bar; httponly", unexpected);
-
-        expected.set_http_only(true);
-        assert_eq_parse!(" foo=bar ;HttpOnly", expected);
-        assert_eq_parse!(" foo=bar ;httponly", expected);
-        assert_eq_parse!(" foo=bar ;HTTPONLY=whatever", expected);
-        assert_eq_parse!(" foo=bar ; sekure; HTTPONLY", expected);
-
-        expected.set_secure(true);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure=aaaa", expected);
-
-        unexpected.set_http_only(true);
-        unexpected.set_secure(true);
-        assert_ne_parse!(" foo=bar ;HttpOnly; skeure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; =secure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly;", unexpected);
-
-        unexpected.set_secure(false);
-        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
-
-        expected.set_max_age(Duration::zero());
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=0", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0 ", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=-1", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", expected);
-
-        expected.set_max_age(Duration::minutes(1));
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=60", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age =   60 ", expected);
-
-        expected.set_max_age(Duration::seconds(4));
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 4 ", expected);
-
-        unexpected.set_secure(true);
-        unexpected.set_max_age(Duration::minutes(1));
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=122", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 38 ", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=51", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0", unexpected);
-
-        expected.set_path("/");
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/", expected);
-
-        expected.set_path("/foo");
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/foo", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path=/foo", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path = /foo", expected);
-
-        unexpected.set_max_age(Duration::seconds(4));
-        unexpected.set_path("/bar");
-        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", unexpected);
-        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/baz", unexpected);
-
-        expected.set_domain("www.foo.com");
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=www.foo.com",
-            expected
-        );
-
-        expected.set_domain("foo.com");
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com",
-            expected
-        );
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=FOO.COM",
-            expected
-        );
-
-        unexpected.set_path("/foo");
-        unexpected.set_domain("bar.com");
-        assert_ne_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com",
-            unexpected
-        );
-        assert_ne_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=FOO.COM",
-            unexpected
-        );
-
-        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
-        let expires = strptime(time_str, "%a, %d %b %Y %H:%M:%S %Z").unwrap();
-        expected.set_expires(expires);
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
-            expected
-        );
-
-        unexpected.set_domain("foo.com");
-        let bad_expires = strptime(time_str, "%a, %d %b %Y %H:%S:%M %Z").unwrap();
-        expected.set_expires(bad_expires);
-        assert_ne_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
-            unexpected
-        );
-    }
-
-    #[test]
-    fn odd_characters() {
-        let expected = Cookie::new("foo", "b%2Fr");
-        assert_eq_parse!("foo=b%2Fr", expected);
-    }
-
-    #[test]
-    fn odd_characters_encoded() {
-        let expected = Cookie::new("foo", "b/r");
-        let cookie = match Cookie::parse_encoded("foo=b%2Fr") {
-            Ok(cookie) => cookie,
-            Err(e) => panic!("Failed to parse: {:?}", e),
-        };
-
-        assert_eq!(cookie, expected);
-    }
-
-    #[test]
-    fn do_not_panic_on_large_max_ages() {
-        let max_seconds = Duration::max_value().num_seconds();
-        let expected = Cookie::build("foo", "bar").max_age(max_seconds).finish();
-        assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", max_seconds + 1), expected);
-    }
-}

actix-http/src/cookie/secure/key.rs

@@ -1,190 +0,0 @@
-use ring::hkdf::{Algorithm, KeyType, Prk, HKDF_SHA256};
-use ring::rand::{SecureRandom, SystemRandom};
-
-use super::private::KEY_LEN as PRIVATE_KEY_LEN;
-use super::signed::KEY_LEN as SIGNED_KEY_LEN;
-
-static HKDF_DIGEST: Algorithm = HKDF_SHA256;
-const KEYS_INFO: &[&[u8]] = &[b"COOKIE;SIGNED:HMAC-SHA256;PRIVATE:AEAD-AES-256-GCM"];
-
-/// A cryptographic master key for use with `Signed` and/or `Private` jars.
-///
-/// This structure encapsulates secure, cryptographic keys for use with both
-/// [PrivateJar](struct.PrivateJar.html) and [SignedJar](struct.SignedJar.html).
-/// It can be derived from a single master key via
-/// [from_master](#method.from_master) or generated from a secure random source
-/// via [generate](#method.generate). A single instance of `Key` can be used for
-/// both a `PrivateJar` and a `SignedJar`.
-///
-/// This type is only available when the `secure` feature is enabled.
-#[derive(Clone)]
-pub struct Key {
-    signing_key: [u8; SIGNED_KEY_LEN],
-    encryption_key: [u8; PRIVATE_KEY_LEN],
-}
-
-impl KeyType for &Key {
-    #[inline]
-    fn len(&self) -> usize {
-        SIGNED_KEY_LEN + PRIVATE_KEY_LEN
-    }
-}
-
-impl Key {
-    /// Derives new signing/encryption keys from a master key.
-    ///
-    /// The master key must be at least 256-bits (32 bytes). For security, the
-    /// master key _must_ be cryptographically random. The keys are derived
-    /// deterministically from the master key.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `key` is less than 32 bytes in length.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// # /*
-    /// let master_key = { /* a cryptographically random key >= 32 bytes */ };
-    /// # */
-    /// # let master_key: &Vec<u8> = &(0..32).collect();
-    ///
-    /// let key = Key::from_master(master_key);
-    /// ```
-    pub fn from_master(key: &[u8]) -> Key {
-        if key.len() < 32 {
-            panic!(
-                "bad master key length: expected at least 32 bytes, found {}",
-                key.len()
-            );
-        }
-
-        // An empty `Key` structure; will be filled in with HKDF derived keys.
-        let mut output_key = Key {
-            signing_key: [0; SIGNED_KEY_LEN],
-            encryption_key: [0; PRIVATE_KEY_LEN],
-        };
-
-        // Expand the master key into two HKDF generated keys.
-        let mut both_keys = [0; SIGNED_KEY_LEN + PRIVATE_KEY_LEN];
-        let prk = Prk::new_less_safe(HKDF_DIGEST, key);
-        let okm = prk.expand(KEYS_INFO, &output_key).expect("okm expand");
-        okm.fill(&mut both_keys).expect("fill keys");
-
-        // Copy the key parts into their respective fields.
-        output_key
-            .signing_key
-            .copy_from_slice(&both_keys[..SIGNED_KEY_LEN]);
-        output_key
-            .encryption_key
-            .copy_from_slice(&both_keys[SIGNED_KEY_LEN..]);
-        output_key
-    }
-
-    /// Generates signing/encryption keys from a secure, random source. Keys are
-    /// generated nondeterministically.
-    ///
-    /// # Panics
-    ///
-    /// Panics if randomness cannot be retrieved from the operating system. See
-    /// [try_generate](#method.try_generate) for a non-panicking version.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::generate();
-    /// ```
-    pub fn generate() -> Key {
-        Self::try_generate().expect("failed to generate `Key` from randomness")
-    }
-
-    /// Attempts to generate signing/encryption keys from a secure, random
-    /// source. Keys are generated nondeterministically. If randomness cannot be
-    /// retrieved from the underlying operating system, returns `None`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::try_generate();
-    /// ```
-    pub fn try_generate() -> Option<Key> {
-        let mut sign_key = [0; SIGNED_KEY_LEN];
-        let mut enc_key = [0; PRIVATE_KEY_LEN];
-
-        let rng = SystemRandom::new();
-        if rng.fill(&mut sign_key).is_err() || rng.fill(&mut enc_key).is_err() {
-            return None;
-        }
-
-        Some(Key {
-            signing_key: sign_key,
-            encryption_key: enc_key,
-        })
-    }
-
-    /// Returns the raw bytes of a key suitable for signing cookies.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::generate();
-    /// let signing_key = key.signing();
-    /// ```
-    pub fn signing(&self) -> &[u8] {
-        &self.signing_key[..]
-    }
-
-    /// Returns the raw bytes of a key suitable for encrypting cookies.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::generate();
-    /// let encryption_key = key.encryption();
-    /// ```
-    pub fn encryption(&self) -> &[u8] {
-        &self.encryption_key[..]
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Key;
-
-    #[test]
-    fn deterministic_from_master() {
-        let master_key: Vec<u8> = (0..32).collect();
-
-        let key_a = Key::from_master(&master_key);
-        let key_b = Key::from_master(&master_key);
-
-        assert_eq!(key_a.signing(), key_b.signing());
-        assert_eq!(key_a.encryption(), key_b.encryption());
-        assert_ne!(key_a.encryption(), key_a.signing());
-
-        let master_key_2: Vec<u8> = (32..64).collect();
-        let key_2 = Key::from_master(&master_key_2);
-
-        assert_ne!(key_2.signing(), key_a.signing());
-        assert_ne!(key_2.encryption(), key_a.encryption());
-    }
-
-    #[test]
-    fn non_deterministic_generate() {
-        let key_a = Key::generate();
-        let key_b = Key::generate();
-
-        assert_ne!(key_a.signing(), key_b.signing());
-        assert_ne!(key_a.encryption(), key_b.encryption());
-    }
-}

actix-http/src/cookie/secure/macros.rs

@@ -1,40 +0,0 @@
-#[cfg(test)]
-macro_rules! assert_simple_behaviour {
-    ($clear:expr, $secure:expr) => {{
-        assert_eq!($clear.iter().count(), 0);
-
-        $secure.add(Cookie::new("name", "val"));
-        assert_eq!($clear.iter().count(), 1);
-        assert_eq!($secure.get("name").unwrap().value(), "val");
-        assert_ne!($clear.get("name").unwrap().value(), "val");
-
-        $secure.add(Cookie::new("another", "two"));
-        assert_eq!($clear.iter().count(), 2);
-
-        $clear.remove(Cookie::named("another"));
-        assert_eq!($clear.iter().count(), 1);
-
-        $secure.remove(Cookie::named("name"));
-        assert_eq!($clear.iter().count(), 0);
-    }};
-}
-
-#[cfg(test)]
-macro_rules! assert_secure_behaviour {
-    ($clear:expr, $secure:expr) => {{
-        $secure.add(Cookie::new("secure", "secure"));
-        assert!($clear.get("secure").unwrap().value() != "secure");
-        assert!($secure.get("secure").unwrap().value() == "secure");
-
-        let mut cookie = $clear.get("secure").unwrap().clone();
-        let new_val = format!("{}l", cookie.value());
-        cookie.set_value(new_val);
-        $clear.add(cookie);
-        assert!($secure.get("secure").is_none());
-
-        let mut cookie = $clear.get("secure").unwrap().clone();
-        cookie.set_value("foobar");
-        $clear.add(cookie);
-        assert!($secure.get("secure").is_none());
-    }};
-}

actix-http/src/cookie/secure/mod.rs

@@ -1,10 +0,0 @@
-//! Fork of https://github.com/alexcrichton/cookie-rs
-#[macro_use]
-mod macros;
-mod key;
-mod private;
-mod signed;
-
-pub use self::key::*;
-pub use self::private::*;
-pub use self::signed::*;

actix-http/src/cookie/secure/private.rs

@@ -1,275 +0,0 @@
-use std::str;
-
-use log::warn;
-use ring::aead::{Aad, Algorithm, Nonce, AES_256_GCM};
-use ring::aead::{LessSafeKey, UnboundKey};
-use ring::rand::{SecureRandom, SystemRandom};
-
-use super::Key;
-use crate::cookie::{Cookie, CookieJar};
-
-// Keep these in sync, and keep the key len synced with the `private` docs as
-// well as the `KEYS_INFO` const in secure::Key.
-static ALGO: &Algorithm = &AES_256_GCM;
-const NONCE_LEN: usize = 12;
-pub const KEY_LEN: usize = 32;
-
-/// A child cookie jar that provides authenticated encryption for its cookies.
-///
-/// A _private_ child jar signs and encrypts all the cookies added to it and
-/// verifies and decrypts cookies retrieved from it. Any cookies stored in a
-/// `PrivateJar` are simultaneously assured confidentiality, integrity, and
-/// authenticity. In other words, clients cannot discover nor tamper with the
-/// contents of a cookie, nor can they fabricate cookie data.
-///
-/// This type is only available when the `secure` feature is enabled.
-pub struct PrivateJar<'a> {
-    parent: &'a mut CookieJar,
-    key: [u8; KEY_LEN],
-}
-
-impl<'a> PrivateJar<'a> {
-    /// Creates a new child `PrivateJar` with parent `parent` and key `key`.
-    /// This method is typically called indirectly via the `signed` method of
-    /// `CookieJar`.
-    #[doc(hidden)]
-    pub fn new(parent: &'a mut CookieJar, key: &Key) -> PrivateJar<'a> {
-        let mut key_array = [0u8; KEY_LEN];
-        key_array.copy_from_slice(key.encryption());
-        PrivateJar {
-            parent,
-            key: key_array,
-        }
-    }
-
-    /// Given a sealed value `str` and a key name `name`, where the nonce is
-    /// prepended to the original value and then both are Base64 encoded,
-    /// verifies and decrypts the sealed value and returns it. If there's a
-    /// problem, returns an `Err` with a string describing the issue.
-    fn unseal(&self, name: &str, value: &str) -> Result<String, &'static str> {
-        let mut data = base64::decode(value).map_err(|_| "bad base64 value")?;
-        if data.len() <= NONCE_LEN {
-            return Err("length of decoded data is <= NONCE_LEN");
-        }
-
-        let ad = Aad::from(name.as_bytes());
-        let key = LessSafeKey::new(
-            UnboundKey::new(&ALGO, &self.key).expect("matching key length"),
-        );
-        let (nonce, mut sealed) = data.split_at_mut(NONCE_LEN);
-        let nonce =
-            Nonce::try_assume_unique_for_key(nonce).expect("invalid length of `nonce`");
-        let unsealed = key
-            .open_in_place(nonce, ad, &mut sealed)
-            .map_err(|_| "invalid key/nonce/value: bad seal")?;
-
-        if let Ok(unsealed_utf8) = str::from_utf8(unsealed) {
-            Ok(unsealed_utf8.to_string())
-        } else {
-            warn!(
-                "Private cookie does not have utf8 content!
-It is likely the secret key used to encrypt them has been leaked.
-Please change it as soon as possible."
-            );
-            Err("bad unsealed utf8")
-        }
-    }
-
-    /// Returns a reference to the `Cookie` inside this jar with the name `name`
-    /// and authenticates and decrypts the cookie's value, returning a `Cookie`
-    /// with the decrypted value. If the cookie cannot be found, or the cookie
-    /// fails to authenticate or decrypt, `None` is returned.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut private_jar = jar.private(&key);
-    /// assert!(private_jar.get("name").is_none());
-    ///
-    /// private_jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(private_jar.get("name").unwrap().value(), "value");
-    /// ```
-    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
-        if let Some(cookie_ref) = self.parent.get(name) {
-            let mut cookie = cookie_ref.clone();
-            if let Ok(value) = self.unseal(name, cookie.value()) {
-                cookie.set_value(value);
-                return Some(cookie);
-            }
-        }
-
-        None
-    }
-
-    /// Adds `cookie` to the parent jar. The cookie's value is encrypted with
-    /// authenticated encryption assuring confidentiality, integrity, and
-    /// authenticity.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.private(&key).add(Cookie::new("name", "value"));
-    ///
-    /// assert_ne!(jar.get("name").unwrap().value(), "value");
-    /// assert_eq!(jar.private(&key).get("name").unwrap().value(), "value");
-    /// ```
-    pub fn add(&mut self, mut cookie: Cookie<'static>) {
-        self.encrypt_cookie(&mut cookie);
-
-        // Add the sealed cookie to the parent.
-        self.parent.add(cookie);
-    }
-
-    /// Adds an "original" `cookie` to parent jar. The cookie's value is
-    /// encrypted with authenticated encryption assuring confidentiality,
-    /// integrity, and authenticity. Adding an original cookie does not affect
-    /// the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
-    /// computation. This method is intended to be used to seed the cookie jar
-    /// with cookies received from a client's HTTP message.
-    ///
-    /// For accurate `delta` computations, this method should not be called
-    /// after calling `remove`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.private(&key).add_original(Cookie::new("name", "value"));
-    ///
-    /// assert_eq!(jar.iter().count(), 1);
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
-        self.encrypt_cookie(&mut cookie);
-
-        // Add the sealed cookie to the parent.
-        self.parent.add_original(cookie);
-    }
-
-    /// Encrypts the cookie's value with
-    /// authenticated encryption assuring confidentiality, integrity, and authenticity.
-    fn encrypt_cookie(&self, cookie: &mut Cookie<'_>) {
-        let name = cookie.name().as_bytes();
-        let value = cookie.value().as_bytes();
-        let data = encrypt_name_value(name, value, &self.key);
-
-        // Base64 encode the nonce and encrypted value.
-        let sealed_value = base64::encode(&data);
-        cookie.set_value(sealed_value);
-    }
-
-    /// Removes `cookie` from the parent jar.
-    ///
-    /// For correct removal, the passed in `cookie` must contain the same `path`
-    /// and `domain` as the cookie that was initially set.
-    ///
-    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
-    /// details.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut private_jar = jar.private(&key);
-    ///
-    /// private_jar.add(Cookie::new("name", "value"));
-    /// assert!(private_jar.get("name").is_some());
-    ///
-    /// private_jar.remove(Cookie::named("name"));
-    /// assert!(private_jar.get("name").is_none());
-    /// ```
-    pub fn remove(&mut self, cookie: Cookie<'static>) {
-        self.parent.remove(cookie);
-    }
-}
-
-fn encrypt_name_value(name: &[u8], value: &[u8], key: &[u8]) -> Vec<u8> {
-    // Create the `SealingKey` structure.
-    let unbound = UnboundKey::new(&ALGO, key).expect("matching key length");
-    let key = LessSafeKey::new(unbound);
-
-    // Create a vec to hold the [nonce | cookie value | overhead].
-    let mut data = vec![0; NONCE_LEN + value.len() + ALGO.tag_len()];
-
-    // Randomly generate the nonce, then copy the cookie value as input.
-    let (nonce, in_out) = data.split_at_mut(NONCE_LEN);
-    let (in_out, tag) = in_out.split_at_mut(value.len());
-    in_out.copy_from_slice(value);
-
-    // Randomly generate the nonce into the nonce piece.
-    SystemRandom::new()
-        .fill(nonce)
-        .expect("couldn't random fill nonce");
-    let nonce = Nonce::try_assume_unique_for_key(nonce).expect("invalid `nonce` length");
-
-    // Use cookie's name as associated data to prevent value swapping.
-    let ad = Aad::from(name);
-    let ad_tag = key
-        .seal_in_place_separate_tag(nonce, ad, in_out)
-        .expect("in-place seal");
-
-    // Copy the tag into the tag piece.
-    tag.copy_from_slice(ad_tag.as_ref());
-
-    // Remove the overhead and return the sealed content.
-    data
-}
-
-#[cfg(test)]
-mod test {
-    use super::{encrypt_name_value, Cookie, CookieJar, Key};
-
-    #[test]
-    fn simple() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_simple_behaviour!(jar, jar.private(&key));
-    }
-
-    #[test]
-    fn private() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_secure_behaviour!(jar, jar.private(&key));
-    }
-
-    #[test]
-    fn non_utf8() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-
-        let name = "malicious";
-        let mut assert_non_utf8 = |value: &[u8]| {
-            let sealed = encrypt_name_value(name.as_bytes(), value, &key.encryption());
-            let encoded = base64::encode(&sealed);
-            assert_eq!(
-                jar.private(&key).unseal(name, &encoded),
-                Err("bad unsealed utf8")
-            );
-            jar.add(Cookie::new(name, encoded));
-            assert_eq!(jar.private(&key).get(name), None);
-        };
-
-        assert_non_utf8(&[0x72, 0xfb, 0xdf, 0x74]); // rûst in ISO/IEC 8859-1
-
-        let mut malicious =
-            String::from(r#"{"id":"abc123??%X","admin":true}"#).into_bytes();
-        malicious[8] |= 0b1100_0000;
-        malicious[9] |= 0b1100_0000;
-        assert_non_utf8(&malicious);
-    }
-}

actix-http/src/cookie/secure/signed.rs

@@ -1,184 +0,0 @@
-use ring::hmac::{self, sign, verify};
-
-use super::Key;
-use crate::cookie::{Cookie, CookieJar};
-
-// Keep these in sync, and keep the key len synced with the `signed` docs as
-// well as the `KEYS_INFO` const in secure::Key.
-static HMAC_DIGEST: hmac::Algorithm = hmac::HMAC_SHA256;
-const BASE64_DIGEST_LEN: usize = 44;
-pub const KEY_LEN: usize = 32;
-
-/// A child cookie jar that authenticates its cookies.
-///
-/// A _signed_ child jar signs all the cookies added to it and verifies cookies
-/// retrieved from it. Any cookies stored in a `SignedJar` are assured integrity
-/// and authenticity. In other words, clients cannot tamper with the contents of
-/// a cookie nor can they fabricate cookie values, but the data is visible in
-/// plaintext.
-///
-/// This type is only available when the `secure` feature is enabled.
-pub struct SignedJar<'a> {
-    parent: &'a mut CookieJar,
-    key: hmac::Key,
-}
-
-impl<'a> SignedJar<'a> {
-    /// Creates a new child `SignedJar` with parent `parent` and key `key`. This
-    /// method is typically called indirectly via the `signed` method of
-    /// `CookieJar`.
-    #[doc(hidden)]
-    pub fn new(parent: &'a mut CookieJar, key: &Key) -> SignedJar<'a> {
-        SignedJar {
-            parent,
-            key: hmac::Key::new(HMAC_DIGEST, key.signing()),
-        }
-    }
-
-    /// Given a signed value `str` where the signature is prepended to `value`,
-    /// verifies the signed value and returns it. If there's a problem, returns
-    /// an `Err` with a string describing the issue.
-    fn verify(&self, cookie_value: &str) -> Result<String, &'static str> {
-        if cookie_value.len() < BASE64_DIGEST_LEN {
-            return Err("length of value is <= BASE64_DIGEST_LEN");
-        }
-
-        let (digest_str, value) = cookie_value.split_at(BASE64_DIGEST_LEN);
-        let sig = base64::decode(digest_str).map_err(|_| "bad base64 digest")?;
-
-        verify(&self.key, value.as_bytes(), &sig)
-            .map(|_| value.to_string())
-            .map_err(|_| "value did not verify")
-    }
-
-    /// Returns a reference to the `Cookie` inside this jar with the name `name`
-    /// and verifies the authenticity and integrity of the cookie's value,
-    /// returning a `Cookie` with the authenticated value. If the cookie cannot
-    /// be found, or the cookie fails to verify, `None` is returned.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut signed_jar = jar.signed(&key);
-    /// assert!(signed_jar.get("name").is_none());
-    ///
-    /// signed_jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(signed_jar.get("name").unwrap().value(), "value");
-    /// ```
-    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
-        if let Some(cookie_ref) = self.parent.get(name) {
-            let mut cookie = cookie_ref.clone();
-            if let Ok(value) = self.verify(cookie.value()) {
-                cookie.set_value(value);
-                return Some(cookie);
-            }
-        }
-
-        None
-    }
-
-    /// Adds `cookie` to the parent jar. The cookie's value is signed assuring
-    /// integrity and authenticity.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.signed(&key).add(Cookie::new("name", "value"));
-    ///
-    /// assert_ne!(jar.get("name").unwrap().value(), "value");
-    /// assert!(jar.get("name").unwrap().value().contains("value"));
-    /// assert_eq!(jar.signed(&key).get("name").unwrap().value(), "value");
-    /// ```
-    pub fn add(&mut self, mut cookie: Cookie<'static>) {
-        self.sign_cookie(&mut cookie);
-        self.parent.add(cookie);
-    }
-
-    /// Adds an "original" `cookie` to this jar. The cookie's value is signed
-    /// assuring integrity and authenticity. Adding an original cookie does not
-    /// affect the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
-    /// computation. This method is intended to be used to seed the cookie jar
-    /// with cookies received from a client's HTTP message.
-    ///
-    /// For accurate `delta` computations, this method should not be called
-    /// after calling `remove`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.signed(&key).add_original(Cookie::new("name", "value"));
-    ///
-    /// assert_eq!(jar.iter().count(), 1);
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
-        self.sign_cookie(&mut cookie);
-        self.parent.add_original(cookie);
-    }
-
-    /// Signs the cookie's value assuring integrity and authenticity.
-    fn sign_cookie(&self, cookie: &mut Cookie<'_>) {
-        let digest = sign(&self.key, cookie.value().as_bytes());
-        let mut new_value = base64::encode(digest.as_ref());
-        new_value.push_str(cookie.value());
-        cookie.set_value(new_value);
-    }
-
-    /// Removes `cookie` from the parent jar.
-    ///
-    /// For correct removal, the passed in `cookie` must contain the same `path`
-    /// and `domain` as the cookie that was initially set.
-    ///
-    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
-    /// details.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut signed_jar = jar.signed(&key);
-    ///
-    /// signed_jar.add(Cookie::new("name", "value"));
-    /// assert!(signed_jar.get("name").is_some());
-    ///
-    /// signed_jar.remove(Cookie::named("name"));
-    /// assert!(signed_jar.get("name").is_none());
-    /// ```
-    pub fn remove(&mut self, cookie: Cookie<'static>) {
-        self.parent.remove(cookie);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{Cookie, CookieJar, Key};
-
-    #[test]
-    fn simple() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_simple_behaviour!(jar, jar.signed(&key));
-    }
-
-    #[test]
-    fn private() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_secure_behaviour!(jar, jar.signed(&key));
-    }
-}

actix-http/src/encoding/encoder.rs

@@ -9,6 +9,7 @@ use brotli2::write::BrotliEncoder;
 use bytes::Bytes;
 use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
+use pin_project::pin_project;
 
 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
@@ -19,8 +20,10 @@ use super::Writer;
 
 const INPLACE: usize = 1024;
 
+#[pin_project]
 pub struct Encoder<B> {
     eof: bool,
+    #[pin]
     body: EncoderBody<B>,
     encoder: Option<ContentEncoder>,
     fut: Option<CpuFuture<ContentEncoder, io::Error>>,
@@ -76,67 +79,88 @@ impl<B: MessageBody> Encoder<B> {
     }
 }
 
+#[pin_project(project = EncoderBodyProj)]
 enum EncoderBody<B> {
     Bytes(Bytes),
-    Stream(B),
-    BoxedStream(Box<dyn MessageBody>),
+    Stream(#[pin] B),
+    BoxedStream(Box<dyn MessageBody + Unpin>),
+}
+
+impl<B: MessageBody> MessageBody for EncoderBody<B> {
+    fn size(&self) -> BodySize {
+        match self {
+            EncoderBody::Bytes(ref b) => b.size(),
+            EncoderBody::Stream(ref b) => b.size(),
+            EncoderBody::BoxedStream(ref b) => b.size(),
+        }
+    }
+
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        match self.project() {
+            EncoderBodyProj::Bytes(b) => {
+                if b.is_empty() {
+                    Poll::Ready(None)
+                } else {
+                    Poll::Ready(Some(Ok(std::mem::take(b))))
+                }
+            }
+            EncoderBodyProj::Stream(b) => b.poll_next(cx),
+            EncoderBodyProj::BoxedStream(ref mut b) => {
+                Pin::new(b.as_mut()).poll_next(cx)
+            }
+        }
+    }
 }
 
 impl<B: MessageBody> MessageBody for Encoder<B> {
     fn size(&self) -> BodySize {
         if self.encoder.is_none() {
-            match self.body {
-                EncoderBody::Bytes(ref b) => b.size(),
-                EncoderBody::Stream(ref b) => b.size(),
-                EncoderBody::BoxedStream(ref b) => b.size(),
-            }
+            self.body.size()
         } else {
             BodySize::Stream
         }
     }
 
-    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        let mut this = self.project();
         loop {
-            if self.eof {
+            if *this.eof {
                 return Poll::Ready(None);
             }
 
-            if let Some(ref mut fut) = self.fut {
+            if let Some(ref mut fut) = this.fut {
                 let mut encoder = match ready!(Pin::new(fut).poll(cx)) {
                     Ok(item) => item,
                     Err(e) => return Poll::Ready(Some(Err(e.into()))),
                 };
                 let chunk = encoder.take();
-                self.encoder = Some(encoder);
-                self.fut.take();
+                *this.encoder = Some(encoder);
+                this.fut.take();
                 if !chunk.is_empty() {
                     return Poll::Ready(Some(Ok(chunk)));
                 }
             }
 
-            let result = match self.body {
-                EncoderBody::Bytes(ref mut b) => {
-                    if b.is_empty() {
-                        Poll::Ready(None)
-                    } else {
-                        Poll::Ready(Some(Ok(std::mem::replace(b, Bytes::new()))))
-                    }
-                }
-                EncoderBody::Stream(ref mut b) => b.poll_next(cx),
-                EncoderBody::BoxedStream(ref mut b) => b.poll_next(cx),
-            };
+            let result = this.body.as_mut().poll_next(cx);
+
             match result {
                 Poll::Ready(Some(Ok(chunk))) => {
-                    if let Some(mut encoder) = self.encoder.take() {
+                    if let Some(mut encoder) = this.encoder.take() {
                         if chunk.len() < INPLACE {
                             encoder.write(&chunk)?;
                             let chunk = encoder.take();
-                            self.encoder = Some(encoder);
+                            *this.encoder = Some(encoder);
                             if !chunk.is_empty() {
                                 return Poll::Ready(Some(Ok(chunk)));
                             }
                         } else {
-                            self.fut = Some(run(move || {
+                            *this.fut = Some(run(move || {
                                 encoder.write(&chunk)?;
                                 Ok(encoder)
                             }));
@@ -146,12 +170,12 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                     }
                 }
                 Poll::Ready(None) => {
-                    if let Some(encoder) = self.encoder.take() {
+                    if let Some(encoder) = this.encoder.take() {
                         let chunk = encoder.finish()?;
                         if chunk.is_empty() {
                             return Poll::Ready(None);
                         } else {
-                            self.eof = true;
+                            *this.eof = true;
                             return Poll::Ready(Some(Ok(chunk)));
                         }
                     } else {

actix-http/src/error.rs

@@ -1,5 +1,5 @@
 //! Error and Result module
-use std::any::TypeId;
+
 use std::cell::RefCell;
 use std::io::Write;
 use std::str::Utf8Error;
@@ -8,19 +8,18 @@ use std::{fmt, io, result};
 
 use actix_codec::{Decoder, Encoder};
 pub use actix_threadpool::BlockingError;
-use actix_utils::framed::DispatcherError as FramedDispatcherError;
+use actix_utils::dispatcher::DispatcherError as FramedDispatcherError;
 use actix_utils::timeout::TimeoutError;
 use bytes::BytesMut;
 use derive_more::{Display, From};
 pub use futures_channel::oneshot::Canceled;
 use http::uri::InvalidUri;
 use http::{header, Error as HttpError, StatusCode};
-use httparse;
 use serde::de::value::Error as DeError;
 use serde_json::error::Error as JsonError;
 use serde_urlencoded::ser::Error as FormError;
 
-// re-export for convinience
+// re-export for convenience
 use crate::body::Body;
 pub use crate::cookie::ParseError as CookieParseError;
 use crate::helpers::Writer;
@@ -36,7 +35,7 @@ pub type Result<T, E = Error> = result::Result<T, E>;
 
 /// General purpose actix web error.
 ///
-/// An actix web error is used to carry errors from `failure` or `std::error`
+/// An actix web error is used to carry errors from `std::error`
 /// through actix in a convenient way.  It can be created through
 /// converting errors with `into()`.
 ///
@@ -83,25 +82,10 @@ pub trait ResponseError: fmt::Debug + fmt::Display {
         resp.set_body(Body::from(buf))
     }
 
-    #[doc(hidden)]
-    fn __private_get_type_id__(&self) -> TypeId
-    where
-        Self: 'static,
-    {
-        TypeId::of::<Self>()
-    }
+    downcast_get_type_id!();
 }
 
-impl dyn ResponseError + 'static {
-    /// Downcasts a response error to a specific type.
-    pub fn downcast_ref<T: ResponseError + 'static>(&self) -> Option<&T> {
-        if self.__private_get_type_id__() == TypeId::of::<T>() {
-            unsafe { Some(&*(self as *const dyn ResponseError as *const T)) }
-        } else {
-            None
-        }
-    }
-}
+downcast!(ResponseError);
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -350,6 +334,8 @@ pub enum PayloadError {
     Io(io::Error),
 }
 
+impl std::error::Error for PayloadError {}
+
 impl From<h2::Error> for PayloadError {
     fn from(err: h2::Error) -> Self {
         PayloadError::Http2Payload(err)
@@ -447,7 +433,7 @@ pub enum DispatchError {
     Unknown,
 }
 
-/// A set of error that can occure during parsing content type
+/// A set of error that can occur during parsing content type
 #[derive(PartialEq, Debug, Display)]
 pub enum ContentTypeError {
     /// Can not parse content type
@@ -458,6 +444,8 @@ pub enum ContentTypeError {
     UnknownEncoding,
 }
 
+impl std::error::Error for ContentTypeError {}
+
 /// Return `BadRequest` for `ContentTypeError`
 impl ResponseError for ContentTypeError {
     fn status_code(&self) -> StatusCode {
@@ -465,10 +453,10 @@ impl ResponseError for ContentTypeError {
     }
 }
 
-impl<E, U: Encoder + Decoder> ResponseError for FramedDispatcherError<E, U>
+impl<E, U: Encoder<I> + Decoder, I> ResponseError for FramedDispatcherError<E, U, I>
 where
     E: fmt::Debug + fmt::Display,
-    <U as Encoder>::Error: fmt::Debug,
+    <U as Encoder<I>>::Error: fmt::Debug,
     <U as Decoder>::Error: fmt::Debug,
 {
 }
@@ -963,15 +951,20 @@ where
     InternalError::new(err, StatusCode::NETWORK_AUTHENTICATION_REQUIRED).into()
 }
 
-#[cfg(feature = "failure")]
-/// Compatibility for `failure::Error`
-impl ResponseError for fail_ure::Error {}
+#[cfg(feature = "actors")]
+/// `InternalServerError` for `actix::MailboxError`
+/// This is supported on feature=`actors` only
+impl ResponseError for actix::MailboxError {}
+
+#[cfg(feature = "actors")]
+/// `InternalServerError` for `actix::ResolverError`
+/// This is supported on feature=`actors` only
+impl ResponseError for actix::actors::resolver::ResolverError {}
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use http::{Error as HttpError, StatusCode};
-    use httparse;
     use std::io;
 
     #[test]

actix-http/src/extensions.rs

@@ -6,6 +6,8 @@ use fxhash::FxHashMap;
 #[derive(Default)]
 /// A type map of request extensions.
 pub struct Extensions {
+    /// Use FxHasher with a std HashMap with for faster
+    /// lookups on the small `TypeId` (u64 equivalent) keys.
     map: FxHashMap<TypeId, Box<dyn Any>>,
 }
 
@@ -28,33 +30,30 @@ impl Extensions {
 
     /// Check if container contains entry
     pub fn contains<T: 'static>(&self) -> bool {
-        self.map.get(&TypeId::of::<T>()).is_some()
+        self.map.contains_key(&TypeId::of::<T>())
     }
 
     /// Get a reference to a type previously inserted on this `Extensions`.
     pub fn get<T: 'static>(&self) -> Option<&T> {
         self.map
             .get(&TypeId::of::<T>())
-            .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
+            .and_then(|boxed| boxed.downcast_ref())
     }
 
     /// Get a mutable reference to a type previously inserted on this `Extensions`.
     pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
         self.map
             .get_mut(&TypeId::of::<T>())
-            .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
+            .and_then(|boxed| boxed.downcast_mut())
     }
 
     /// Remove a type from this `Extensions`.
     ///
     /// If a extension of this type existed, it will be returned.
     pub fn remove<T: 'static>(&mut self) -> Option<T> {
-        self.map.remove(&TypeId::of::<T>()).and_then(|boxed| {
-            (boxed as Box<dyn Any + 'static>)
-                .downcast()
-                .ok()
-                .map(|boxed| *boxed)
-        })
+        self.map
+            .remove(&TypeId::of::<T>())
+            .and_then(|boxed| boxed.downcast().ok().map(|boxed| *boxed))
     }
 
     /// Clear the `Extensions` of all inserted extensions.
@@ -70,22 +69,113 @@ impl fmt::Debug for Extensions {
     }
 }
 
-#[test]
-fn test_extensions() {
-    #[derive(Debug, PartialEq)]
-    struct MyType(i32);
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    let mut extensions = Extensions::new();
+    #[test]
+    fn test_remove() {
+        let mut map = Extensions::new();
 
-    extensions.insert(5i32);
-    extensions.insert(MyType(10));
+        map.insert::<i8>(123);
+        assert!(map.get::<i8>().is_some());
 
-    assert_eq!(extensions.get(), Some(&5i32));
-    assert_eq!(extensions.get_mut(), Some(&mut 5i32));
+        map.remove::<i8>();
+        assert!(map.get::<i8>().is_none());
+    }
 
-    assert_eq!(extensions.remove::<i32>(), Some(5i32));
-    assert!(extensions.get::<i32>().is_none());
+    #[test]
+    fn test_clear() {
+        let mut map = Extensions::new();
 
-    assert_eq!(extensions.get::<bool>(), None);
-    assert_eq!(extensions.get(), Some(&MyType(10)));
+        map.insert::<i8>(8);
+        map.insert::<i16>(16);
+        map.insert::<i32>(32);
+
+        assert!(map.contains::<i8>());
+        assert!(map.contains::<i16>());
+        assert!(map.contains::<i32>());
+
+        map.clear();
+
+        assert!(!map.contains::<i8>());
+        assert!(!map.contains::<i16>());
+        assert!(!map.contains::<i32>());
+
+        map.insert::<i8>(10);
+        assert_eq!(*map.get::<i8>().unwrap(), 10);
+    }
+
+    #[test]
+    fn test_integers() {
+        let mut map = Extensions::new();
+
+        map.insert::<i8>(8);
+        map.insert::<i16>(16);
+        map.insert::<i32>(32);
+        map.insert::<i64>(64);
+        map.insert::<i128>(128);
+        map.insert::<u8>(8);
+        map.insert::<u16>(16);
+        map.insert::<u32>(32);
+        map.insert::<u64>(64);
+        map.insert::<u128>(128);
+        assert!(map.get::<i8>().is_some());
+        assert!(map.get::<i16>().is_some());
+        assert!(map.get::<i32>().is_some());
+        assert!(map.get::<i64>().is_some());
+        assert!(map.get::<i128>().is_some());
+        assert!(map.get::<u8>().is_some());
+        assert!(map.get::<u16>().is_some());
+        assert!(map.get::<u32>().is_some());
+        assert!(map.get::<u64>().is_some());
+        assert!(map.get::<u128>().is_some());
+    }
+
+    #[test]
+    fn test_composition() {
+        struct Magi<T>(pub T);
+
+        struct Madoka {
+            pub god: bool,
+        }
+
+        struct Homura {
+            pub attempts: usize,
+        }
+
+        struct Mami {
+            pub guns: usize,
+        }
+
+        let mut map = Extensions::new();
+
+        map.insert(Magi(Madoka { god: false }));
+        map.insert(Magi(Homura { attempts: 0 }));
+        map.insert(Magi(Mami { guns: 999 }));
+
+        assert!(!map.get::<Magi<Madoka>>().unwrap().0.god);
+        assert_eq!(0, map.get::<Magi<Homura>>().unwrap().0.attempts);
+        assert_eq!(999, map.get::<Magi<Mami>>().unwrap().0.guns);
+    }
+
+    #[test]
+    fn test_extensions() {
+        #[derive(Debug, PartialEq)]
+        struct MyType(i32);
+
+        let mut extensions = Extensions::new();
+
+        extensions.insert(5i32);
+        extensions.insert(MyType(10));
+
+        assert_eq!(extensions.get(), Some(&5i32));
+        assert_eq!(extensions.get_mut(), Some(&mut 5i32));
+
+        assert_eq!(extensions.remove::<i32>(), Some(5i32));
+        assert!(extensions.get::<i32>().is_none());
+
+        assert_eq!(extensions.get::<bool>(), None);
+        assert_eq!(extensions.get(), Some(&MyType(10)));
+    }
 }

actix-http/src/h1/client.rs

@@ -173,13 +173,12 @@ impl Decoder for ClientPayloadCodec {
     }
 }
 
-impl Encoder for ClientCodec {
-    type Item = Message<(RequestHeadType, BodySize)>;
+impl Encoder<Message<(RequestHeadType, BodySize)>> for ClientCodec {
     type Error = io::Error;
 
     fn encode(
         &mut self,
-        item: Self::Item,
+        item: Message<(RequestHeadType, BodySize)>,
         dst: &mut BytesMut,
     ) -> Result<(), Self::Error> {
         match item {

actix-http/src/h1/codec.rs

@@ -144,13 +144,12 @@ impl Decoder for Codec {
     }
 }
 
-impl Encoder for Codec {
-    type Item = Message<(Response<()>, BodySize)>;
+impl Encoder<Message<(Response<()>, BodySize)>> for Codec {
     type Error = io::Error;
 
     fn encode(
         &mut self,
-        item: Self::Item,
+        item: Message<(Response<()>, BodySize)>,
         dst: &mut BytesMut,
     ) -> Result<(), Self::Error> {
         match item {

actix-http/src/h1/decoder.rs

@@ -1,14 +1,12 @@
 use std::convert::TryFrom;
 use std::io;
 use std::marker::PhantomData;
-use std::mem::MaybeUninit;
 use std::task::Poll;
 
 use actix_codec::Decoder;
 use bytes::{Buf, Bytes, BytesMut};
 use http::header::{HeaderName, HeaderValue};
 use http::{header, Method, StatusCode, Uri, Version};
-use httparse;
 use log::{debug, error, trace};
 
 use crate::error::ParseError;
@@ -19,7 +17,7 @@ use crate::request::Request;
 const MAX_BUFFER_SIZE: usize = 131_072;
 const MAX_HEADERS: usize = 96;
 
-/// Incoming messagd decoder
+/// Incoming message decoder
 pub(crate) struct MessageDecoder<T: MessageType>(PhantomData<T>);
 
 #[derive(Debug)]
@@ -47,7 +45,7 @@ impl<T: MessageType> Decoder for MessageDecoder<T> {
 
 pub(crate) enum PayloadLength {
     Payload(PayloadType),
-    Upgrade,
+    UpgradeWebSocket,
     None,
 }
 
@@ -66,7 +64,7 @@ pub(crate) trait MessageType: Sized {
         raw_headers: &[HeaderIndex],
     ) -> Result<PayloadLength, ParseError> {
         let mut ka = None;
-        let mut has_upgrade = false;
+        let mut has_upgrade_websocket = false;
         let mut expect = false;
         let mut chunked = false;
         let mut content_length = None;
@@ -78,12 +76,14 @@ pub(crate) trait MessageType: Sized {
                 let name =
                     HeaderName::from_bytes(&slice[idx.name.0..idx.name.1]).unwrap();
 
-                // Unsafe: httparse check header value for valid utf-8
+                // SAFETY: httparse already checks header value is only visible ASCII bytes
+                // from_maybe_shared_unchecked contains debug assertions so they are omitted here
                 let value = unsafe {
                     HeaderValue::from_maybe_shared_unchecked(
                         slice.slice(idx.value.0..idx.value.1),
                     )
                 };
+
                 match name {
                     header::CONTENT_LENGTH => {
                         if let Ok(s) = value.to_str() {
@@ -125,12 +125,9 @@ pub(crate) trait MessageType: Sized {
                         };
                     }
                     header::UPGRADE => {
-                        has_upgrade = true;
-                        // check content-length, some clients (dart)
-                        // sends "content-length: 0" with websocket upgrade
                         if let Ok(val) = value.to_str().map(|val| val.trim()) {
                             if val.eq_ignore_ascii_case("websocket") {
-                                content_length = None;
+                                has_upgrade_websocket = true;
                             }
                         }
                     }
@@ -157,13 +154,13 @@ pub(crate) trait MessageType: Sized {
             Ok(PayloadLength::Payload(PayloadType::Payload(
                 PayloadDecoder::chunked(),
             )))
+        } else if has_upgrade_websocket {
+            Ok(PayloadLength::UpgradeWebSocket)
         } else if let Some(len) = content_length {
             // Content-Length
             Ok(PayloadLength::Payload(PayloadType::Payload(
                 PayloadDecoder::length(len),
             )))
-        } else if has_upgrade {
-            Ok(PayloadLength::Upgrade)
         } else {
             Ok(PayloadLength::None)
         }
@@ -185,16 +182,11 @@ impl MessageType for Request {
         &mut self.head_mut().headers
     }
 
-    #[allow(clippy::uninit_assumed_init)]
     fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, ParseError> {
-        // Unsafe: we read only this data only after httparse parses headers into.
-        // performance bump for pipeline benchmarks.
-        let mut headers: [HeaderIndex; MAX_HEADERS] =
-            unsafe { MaybeUninit::uninit().assume_init() };
+        let mut headers: [HeaderIndex; MAX_HEADERS] = EMPTY_HEADER_INDEX_ARRAY;
 
         let (len, method, uri, ver, h_len) = {
-            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] =
-                unsafe { MaybeUninit::uninit().assume_init() };
+            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] = EMPTY_HEADER_ARRAY;
 
             let mut req = httparse::Request::new(&mut parsed);
             match req.parse(src)? {
@@ -223,7 +215,7 @@ impl MessageType for Request {
         // payload decoder
         let decoder = match length {
             PayloadLength::Payload(pl) => pl,
-            PayloadLength::Upgrade => {
+            PayloadLength::UpgradeWebSocket => {
                 // upgrade(websocket)
                 PayloadType::Stream(PayloadDecoder::eof())
             }
@@ -261,16 +253,11 @@ impl MessageType for ResponseHead {
         &mut self.headers
     }
 
-    #[allow(clippy::uninit_assumed_init)]
     fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, ParseError> {
-        // Unsafe: we read only this data only after httparse parses headers into.
-        // performance bump for pipeline benchmarks.
-        let mut headers: [HeaderIndex; MAX_HEADERS] =
-            unsafe { MaybeUninit::uninit().assume_init() };
+        let mut headers: [HeaderIndex; MAX_HEADERS] = EMPTY_HEADER_INDEX_ARRAY;
 
         let (len, ver, status, h_len) = {
-            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] =
-                unsafe { MaybeUninit::uninit().assume_init() };
+            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] = EMPTY_HEADER_ARRAY;
 
             let mut res = httparse::Response::new(&mut parsed);
             match res.parse(src)? {
@@ -325,6 +312,17 @@ pub(crate) struct HeaderIndex {
     pub(crate) value: (usize, usize),
 }
 
+pub(crate) const EMPTY_HEADER_INDEX: HeaderIndex = HeaderIndex {
+    name: (0, 0),
+    value: (0, 0),
+};
+
+pub(crate) const EMPTY_HEADER_INDEX_ARRAY: [HeaderIndex; MAX_HEADERS] =
+    [EMPTY_HEADER_INDEX; MAX_HEADERS];
+
+pub(crate) const EMPTY_HEADER_ARRAY: [httparse::Header<'static>; MAX_HEADERS] =
+    [httparse::EMPTY_HEADER; MAX_HEADERS];
+
 impl HeaderIndex {
     pub(crate) fn record(
         bytes: &[u8],
@@ -656,10 +654,7 @@ mod tests {
         }
 
         fn is_unhandled(&self) -> bool {
-            match self {
-                PayloadType::Stream(_) => true,
-                _ => false,
-            }
+            matches!(self, PayloadType::Stream(_))
         }
     }
 
@@ -671,10 +666,7 @@ mod tests {
             }
         }
         fn eof(&self) -> bool {
-            match *self {
-                PayloadItem::Eof => true,
-                _ => false,
-            }
+            matches!(*self, PayloadItem::Eof)
         }
     }
 
@@ -980,7 +972,7 @@ mod tests {
             unreachable!("Error");
         }
 
-        // type in chunked
+        // intentional typo in "chunked"
         let mut buf = BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              transfer-encoding: chnked\r\n\r\n",
@@ -1041,7 +1033,7 @@ mod tests {
     }
 
     #[test]
-    fn test_http_request_upgrade() {
+    fn test_http_request_upgrade_websocket() {
         let mut buf = BytesMut::from(
             "GET /test HTTP/1.1\r\n\
              connection: upgrade\r\n\
@@ -1055,6 +1047,26 @@ mod tests {
         assert!(pl.is_unhandled());
     }
 
+    #[test]
+    fn test_http_request_upgrade_h2c() {
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             connection: upgrade, http2-settings\r\n\
+             upgrade: h2c\r\n\
+             http2-settings: dummy\r\n\r\n",
+        );
+        let mut reader = MessageDecoder::<Request>::default();
+        let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();
+        // `connection: upgrade, http2-settings` doesn't work properly..
+        // see MessageType::set_headers().
+        //
+        // The line below should be:
+        // assert_eq!(req.head().connection_type(), ConnectionType::Upgrade);
+        assert_eq!(req.head().connection_type(), ConnectionType::KeepAlive);
+        assert!(req.upgrade());
+        assert!(!pl.is_unhandled());
+    }
+
     #[test]
     fn test_http_request_parser_utf8() {
         let mut buf = BytesMut::from(

actix-http/src/h1/dispatcher.rs

@@ -10,6 +10,7 @@ use actix_service::Service;
 use bitflags::bitflags;
 use bytes::{Buf, BytesMut};
 use log::{error, trace};
+use pin_project::pin_project;
 
 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::cloneable::CloneableService;
@@ -41,6 +42,7 @@ bitflags! {
     }
 }
 
+#[pin_project::pin_project]
 /// Dispatcher for HTTP/1.1 protocol
 pub struct Dispatcher<T, S, B, X, U>
 where
@@ -52,9 +54,11 @@ where
     U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
+    #[pin]
     inner: DispatcherState<T, S, B, X, U>,
 }
 
+#[pin_project(project = DispatcherStateProj)]
 enum DispatcherState<T, S, B, X, U>
 where
     S: Service<Request = Request>,
@@ -65,11 +69,11 @@ where
     U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
-    Normal(InnerDispatcher<T, S, B, X, U>),
-    Upgrade(U::Future),
-    None,
+    Normal(#[pin] InnerDispatcher<T, S, B, X, U>),
+    Upgrade(Pin<Box<U::Future>>),
 }
 
+#[pin_project(project = InnerDispatcherProj)]
 struct InnerDispatcher<T, S, B, X, U>
 where
     S: Service<Request = Request>,
@@ -88,6 +92,7 @@ where
     peer_addr: Option<net::SocketAddr>,
     error: Option<DispatchError>,
 
+    #[pin]
     state: State<S, B, X>,
     payload: Option<PayloadSender>,
     messages: VecDeque<DispatcherMessage>,
@@ -95,7 +100,7 @@ where
     ka_expire: Instant,
     ka_timer: Option<Delay>,
 
-    io: T,
+    io: Option<T>,
     read_buf: BytesMut,
     write_buf: BytesMut,
     codec: Codec,
@@ -107,6 +112,7 @@ enum DispatcherMessage {
     Error(Response<()>),
 }
 
+#[pin_project(project = StateProj)]
 enum State<S, B, X>
 where
     S: Service<Request = Request>,
@@ -114,9 +120,9 @@ where
     B: MessageBody,
 {
     None,
-    ExpectCall(X::Future),
-    ServiceCall(S::Future),
-    SendPayload(ResponseBody<B>),
+    ExpectCall(Pin<Box<X::Future>>),
+    ServiceCall(Pin<Box<S::Future>>),
+    SendPayload(#[pin] ResponseBody<B>),
 }
 
 impl<S, B, X> State<S, B, X>
@@ -126,22 +132,13 @@ where
     B: MessageBody,
 {
     fn is_empty(&self) -> bool {
-        if let State::None = self {
-            true
-        } else {
-            false
-        }
+        matches!(self, State::None)
     }
 
     fn is_call(&self) -> bool {
-        if let State::ServiceCall(_) = self {
-            true
-        } else {
-            false
-        }
+        matches!(self, State::ServiceCall(_))
     }
 }
-
 enum PollResponse {
     Upgrade(Request),
     DoNothing,
@@ -151,14 +148,8 @@ enum PollResponse {
 impl PartialEq for PollResponse {
     fn eq(&self, other: &PollResponse) -> bool {
         match self {
-            PollResponse::DrainWriteBuf => match other {
-                PollResponse::DrainWriteBuf => true,
-                _ => false,
-            },
-            PollResponse::DoNothing => match other {
-                PollResponse::DoNothing => true,
-                _ => false,
-            },
+            PollResponse::DrainWriteBuf => matches!(other, PollResponse::DrainWriteBuf),
+            PollResponse::DoNothing => matches!(other, PollResponse::DoNothing),
             _ => false,
         }
     }
@@ -236,7 +227,7 @@ where
                 state: State::None,
                 error: None,
                 messages: VecDeque::new(),
-                io,
+                io: Some(io),
                 codec,
                 read_buf,
                 service,
@@ -278,29 +269,33 @@ where
     }
 
     // if checked is set to true, delay disconnect until all tasks have finished.
-    fn client_disconnected(&mut self) {
-        self.flags
+    fn client_disconnected(self: Pin<&mut Self>) {
+        let this = self.project();
+        this.flags
             .insert(Flags::READ_DISCONNECT | Flags::WRITE_DISCONNECT);
-        if let Some(mut payload) = self.payload.take() {
+        if let Some(mut payload) = this.payload.take() {
             payload.set_error(PayloadError::Incomplete(None));
         }
     }
 
     /// Flush stream
     ///
-    /// true - got whouldblock
-    /// false - didnt get whouldblock
-    fn poll_flush(&mut self, cx: &mut Context<'_>) -> Result<bool, DispatchError> {
+    /// true - got WouldBlock
+    /// false - didn't get WouldBlock
+    fn poll_flush(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Result<bool, DispatchError> {
         if self.write_buf.is_empty() {
             return Ok(false);
         }
 
         let len = self.write_buf.len();
         let mut written = 0;
+        let InnerDispatcherProj { io, write_buf, .. } = self.project();
+        let mut io = Pin::new(io.as_mut().unwrap());
         while written < len {
-            match unsafe { Pin::new_unchecked(&mut self.io) }
-                .poll_write(cx, &self.write_buf[written..])
-            {
+            match io.as_mut().poll_write(cx, &write_buf[written..]) {
                 Poll::Ready(Ok(0)) => {
                     return Err(DispatchError::Io(io::Error::new(
                         io::ErrorKind::WriteZero,
@@ -312,112 +307,121 @@ where
                 }
                 Poll::Pending => {
                     if written > 0 {
-                        self.write_buf.advance(written);
+                        write_buf.advance(written);
                     }
                     return Ok(true);
                 }
                 Poll::Ready(Err(err)) => return Err(DispatchError::Io(err)),
             }
         }
-        if written == self.write_buf.len() {
-            unsafe { self.write_buf.set_len(0) }
+
+        if written == write_buf.len() {
+            // SAFETY: setting length to 0 is safe
+            // skips one length check vs truncate
+            unsafe { write_buf.set_len(0) }
         } else {
-            self.write_buf.advance(written);
+            write_buf.advance(written);
         }
+
         Ok(false)
     }
 
     fn send_response(
-        &mut self,
+        self: Pin<&mut Self>,
         message: Response<()>,
         body: ResponseBody<B>,
     ) -> Result<State<S, B, X>, DispatchError> {
-        self.codec
-            .encode(Message::Item((message, body.size())), &mut self.write_buf)
+        let mut this = self.project();
+        this.codec
+            .encode(Message::Item((message, body.size())), &mut this.write_buf)
             .map_err(|err| {
-                if let Some(mut payload) = self.payload.take() {
+                if let Some(mut payload) = this.payload.take() {
                     payload.set_error(PayloadError::Incomplete(None));
                 }
                 DispatchError::Io(err)
             })?;
 
-        self.flags.set(Flags::KEEPALIVE, self.codec.keepalive());
+        this.flags.set(Flags::KEEPALIVE, this.codec.keepalive());
         match body.size() {
             BodySize::None | BodySize::Empty => Ok(State::None),
             _ => Ok(State::SendPayload(body)),
         }
     }
 
-    fn send_continue(&mut self) {
-        self.write_buf
+    fn send_continue(self: Pin<&mut Self>) {
+        self.project()
+            .write_buf
             .extend_from_slice(b"HTTP/1.1 100 Continue\r\n\r\n");
     }
 
     fn poll_response(
-        &mut self,
+        mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Result<PollResponse, DispatchError> {
         loop {
-            let state = match self.state {
-                State::None => match self.messages.pop_front() {
+            let mut this = self.as_mut().project();
+            let state = match this.state.project() {
+                StateProj::None => match this.messages.pop_front() {
                     Some(DispatcherMessage::Item(req)) => {
-                        Some(self.handle_request(req, cx)?)
-                    }
-                    Some(DispatcherMessage::Error(res)) => {
-                        Some(self.send_response(res, ResponseBody::Other(Body::Empty))?)
+                        Some(self.as_mut().handle_request(req, cx)?)
                     }
+                    Some(DispatcherMessage::Error(res)) => Some(
+                        self.as_mut()
+                            .send_response(res, ResponseBody::Other(Body::Empty))?,
+                    ),
                     Some(DispatcherMessage::Upgrade(req)) => {
                         return Ok(PollResponse::Upgrade(req));
                     }
                     None => None,
                 },
-                State::ExpectCall(ref mut fut) => {
-                    match unsafe { Pin::new_unchecked(fut) }.poll(cx) {
-                        Poll::Ready(Ok(req)) => {
-                            self.send_continue();
-                            self.state = State::ServiceCall(self.service.call(req));
-                            continue;
-                        }
-                        Poll::Ready(Err(e)) => {
-                            let res: Response = e.into().into();
-                            let (res, body) = res.replace_body(());
-                            Some(self.send_response(res, body.into_body())?)
-                        }
-                        Poll::Pending => None,
+                StateProj::ExpectCall(fut) => match fut.as_mut().poll(cx) {
+                    Poll::Ready(Ok(req)) => {
+                        self.as_mut().send_continue();
+                        this = self.as_mut().project();
+                        this.state
+                            .set(State::ServiceCall(Box::pin(this.service.call(req))));
+                        continue;
                     }
-                }
-                State::ServiceCall(ref mut fut) => {
-                    match unsafe { Pin::new_unchecked(fut) }.poll(cx) {
-                        Poll::Ready(Ok(res)) => {
-                            let (res, body) = res.into().replace_body(());
-                            self.state = self.send_response(res, body)?;
-                            continue;
-                        }
-                        Poll::Ready(Err(e)) => {
-                            let res: Response = e.into().into();
-                            let (res, body) = res.replace_body(());
-                            Some(self.send_response(res, body.into_body())?)
-                        }
-                        Poll::Pending => None,
+                    Poll::Ready(Err(e)) => {
+                        let res: Response = e.into().into();
+                        let (res, body) = res.replace_body(());
+                        Some(self.as_mut().send_response(res, body.into_body())?)
                     }
-                }
-                State::SendPayload(ref mut stream) => {
+                    Poll::Pending => None,
+                },
+                StateProj::ServiceCall(fut) => match fut.as_mut().poll(cx) {
+                    Poll::Ready(Ok(res)) => {
+                        let (res, body) = res.into().replace_body(());
+                        let state = self.as_mut().send_response(res, body)?;
+                        this = self.as_mut().project();
+                        this.state.set(state);
+                        continue;
+                    }
+                    Poll::Ready(Err(e)) => {
+                        let res: Response = e.into().into();
+                        let (res, body) = res.replace_body(());
+                        Some(self.as_mut().send_response(res, body.into_body())?)
+                    }
+                    Poll::Pending => None,
+                },
+                StateProj::SendPayload(mut stream) => {
                     loop {
-                        if self.write_buf.len() < HW_BUFFER_SIZE {
-                            match stream.poll_next(cx) {
+                        if this.write_buf.len() < HW_BUFFER_SIZE {
+                            match stream.as_mut().poll_next(cx) {
                                 Poll::Ready(Some(Ok(item))) => {
-                                    self.codec.encode(
+                                    this.codec.encode(
                                         Message::Chunk(Some(item)),
-                                        &mut self.write_buf,
+                                        &mut this.write_buf,
                                     )?;
                                     continue;
                                 }
                                 Poll::Ready(None) => {
-                                    self.codec.encode(
+                                    this.codec.encode(
                                         Message::Chunk(None),
-                                        &mut self.write_buf,
+                                        &mut this.write_buf,
                                     )?;
-                                    self.state = State::None;
+                                    this = self.as_mut().project();
+                                    this.state.set(State::None);
                                 }
                                 Poll::Ready(Some(Err(_))) => {
                                     return Err(DispatchError::Unknown)
@@ -433,9 +437,11 @@ where
                 }
             };
 
+            this = self.as_mut().project();
+
             // set new state
             if let Some(state) = state {
-                self.state = state;
+                this.state.set(state);
                 if !self.state.is_empty() {
                     continue;
                 }
@@ -443,7 +449,7 @@ where
                 // if read-backpressure is enabled and we consumed some data.
                 // we may read more data and retry
                 if self.state.is_call() {
-                    if self.poll_request(cx)? {
+                    if self.as_mut().poll_request(cx)? {
                         continue;
                     }
                 } else if !self.messages.is_empty() {
@@ -457,16 +463,16 @@ where
     }
 
     fn handle_request(
-        &mut self,
+        mut self: Pin<&mut Self>,
         req: Request,
         cx: &mut Context<'_>,
     ) -> Result<State<S, B, X>, DispatchError> {
         // Handle `EXPECT: 100-Continue` header
         let req = if req.head().expect() {
-            let mut task = self.expect.call(req);
-            match unsafe { Pin::new_unchecked(&mut task) }.poll(cx) {
+            let mut task = Box::pin(self.as_mut().project().expect.call(req));
+            match task.as_mut().poll(cx) {
                 Poll::Ready(Ok(req)) => {
-                    self.send_continue();
+                    self.as_mut().send_continue();
                     req
                 }
                 Poll::Pending => return Ok(State::ExpectCall(task)),
@@ -482,8 +488,8 @@ where
         };
 
         // Call service
-        let mut task = self.service.call(req);
-        match unsafe { Pin::new_unchecked(&mut task) }.poll(cx) {
+        let mut task = Box::pin(self.as_mut().project().service.call(req));
+        match task.as_mut().poll(cx) {
             Poll::Ready(Ok(res)) => {
                 let (res, body) = res.into().replace_body(());
                 self.send_response(res, body)
@@ -499,7 +505,7 @@ where
 
     /// Process one incoming requests
     pub(self) fn poll_request(
-        &mut self,
+        mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Result<bool, DispatchError> {
         // limit a mount of non processed requests
@@ -508,24 +514,25 @@ where
         }
 
         let mut updated = false;
+        let mut this = self.as_mut().project();
         loop {
-            match self.codec.decode(&mut self.read_buf) {
+            match this.codec.decode(&mut this.read_buf) {
                 Ok(Some(msg)) => {
                     updated = true;
-                    self.flags.insert(Flags::STARTED);
+                    this.flags.insert(Flags::STARTED);
 
                     match msg {
                         Message::Item(mut req) => {
-                            let pl = self.codec.message_type();
-                            req.head_mut().peer_addr = self.peer_addr;
+                            let pl = this.codec.message_type();
+                            req.head_mut().peer_addr = *this.peer_addr;
 
                             // set on_connect data
-                            if let Some(ref on_connect) = self.on_connect {
+                            if let Some(ref on_connect) = this.on_connect {
                                 on_connect.set(&mut req.extensions_mut());
                             }
 
-                            if pl == MessageType::Stream && self.upgrade.is_some() {
-                                self.messages.push_back(DispatcherMessage::Upgrade(req));
+                            if pl == MessageType::Stream && this.upgrade.is_some() {
+                                this.messages.push_back(DispatcherMessage::Upgrade(req));
                                 break;
                             }
                             if pl == MessageType::Payload || pl == MessageType::Stream {
@@ -533,41 +540,43 @@ where
                                 let (req1, _) =
                                     req.replace_payload(crate::Payload::H1(pl));
                                 req = req1;
-                                self.payload = Some(ps);
+                                *this.payload = Some(ps);
                             }
 
                             // handle request early
-                            if self.state.is_empty() {
-                                self.state = self.handle_request(req, cx)?;
+                            if this.state.is_empty() {
+                                let state = self.as_mut().handle_request(req, cx)?;
+                                this = self.as_mut().project();
+                                this.state.set(state);
                             } else {
-                                self.messages.push_back(DispatcherMessage::Item(req));
+                                this.messages.push_back(DispatcherMessage::Item(req));
                             }
                         }
                         Message::Chunk(Some(chunk)) => {
-                            if let Some(ref mut payload) = self.payload {
+                            if let Some(ref mut payload) = this.payload {
                                 payload.feed_data(chunk);
                             } else {
                                 error!(
                                     "Internal server error: unexpected payload chunk"
                                 );
-                                self.flags.insert(Flags::READ_DISCONNECT);
-                                self.messages.push_back(DispatcherMessage::Error(
+                                this.flags.insert(Flags::READ_DISCONNECT);
+                                this.messages.push_back(DispatcherMessage::Error(
                                     Response::InternalServerError().finish().drop_body(),
                                 ));
-                                self.error = Some(DispatchError::InternalError);
+                                *this.error = Some(DispatchError::InternalError);
                                 break;
                             }
                         }
                         Message::Chunk(None) => {
-                            if let Some(mut payload) = self.payload.take() {
+                            if let Some(mut payload) = this.payload.take() {
                                 payload.feed_eof();
                             } else {
                                 error!("Internal server error: unexpected eof");
-                                self.flags.insert(Flags::READ_DISCONNECT);
-                                self.messages.push_back(DispatcherMessage::Error(
+                                this.flags.insert(Flags::READ_DISCONNECT);
+                                this.messages.push_back(DispatcherMessage::Error(
                                     Response::InternalServerError().finish().drop_body(),
                                 ));
-                                self.error = Some(DispatchError::InternalError);
+                                *this.error = Some(DispatchError::InternalError);
                                 break;
                             }
                         }
@@ -575,44 +584,49 @@ where
                 }
                 Ok(None) => break,
                 Err(ParseError::Io(e)) => {
-                    self.client_disconnected();
-                    self.error = Some(DispatchError::Io(e));
+                    self.as_mut().client_disconnected();
+                    this = self.as_mut().project();
+                    *this.error = Some(DispatchError::Io(e));
                     break;
                 }
                 Err(e) => {
-                    if let Some(mut payload) = self.payload.take() {
+                    if let Some(mut payload) = this.payload.take() {
                         payload.set_error(PayloadError::EncodingCorrupted);
                     }
 
                     // Malformed requests should be responded with 400
-                    self.messages.push_back(DispatcherMessage::Error(
+                    this.messages.push_back(DispatcherMessage::Error(
                         Response::BadRequest().finish().drop_body(),
                     ));
-                    self.flags.insert(Flags::READ_DISCONNECT);
-                    self.error = Some(e.into());
+                    this.flags.insert(Flags::READ_DISCONNECT);
+                    *this.error = Some(e.into());
                     break;
                 }
             }
         }
 
-        if updated && self.ka_timer.is_some() {
-            if let Some(expire) = self.codec.config().keep_alive_expire() {
-                self.ka_expire = expire;
+        if updated && this.ka_timer.is_some() {
+            if let Some(expire) = this.codec.config().keep_alive_expire() {
+                *this.ka_expire = expire;
             }
         }
         Ok(updated)
     }
 
     /// keep-alive timer
-    fn poll_keepalive(&mut self, cx: &mut Context<'_>) -> Result<(), DispatchError> {
-        if self.ka_timer.is_none() {
+    fn poll_keepalive(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Result<(), DispatchError> {
+        let mut this = self.as_mut().project();
+        if this.ka_timer.is_none() {
             // shutdown timeout
-            if self.flags.contains(Flags::SHUTDOWN) {
-                if let Some(interval) = self.codec.config().client_disconnect_timer() {
-                    self.ka_timer = Some(delay_until(interval));
+            if this.flags.contains(Flags::SHUTDOWN) {
+                if let Some(interval) = this.codec.config().client_disconnect_timer() {
+                    *this.ka_timer = Some(delay_until(interval));
                 } else {
-                    self.flags.insert(Flags::READ_DISCONNECT);
-                    if let Some(mut payload) = self.payload.take() {
+                    this.flags.insert(Flags::READ_DISCONNECT);
+                    if let Some(mut payload) = this.payload.take() {
                         payload.set_error(PayloadError::Incomplete(None));
                     }
                     return Ok(());
@@ -622,55 +636,56 @@ where
             }
         }
 
-        match Pin::new(&mut self.ka_timer.as_mut().unwrap()).poll(cx) {
+        match Pin::new(&mut this.ka_timer.as_mut().unwrap()).poll(cx) {
             Poll::Ready(()) => {
                 // if we get timeout during shutdown, drop connection
-                if self.flags.contains(Flags::SHUTDOWN) {
+                if this.flags.contains(Flags::SHUTDOWN) {
                     return Err(DispatchError::DisconnectTimeout);
-                } else if self.ka_timer.as_mut().unwrap().deadline() >= self.ka_expire {
+                } else if this.ka_timer.as_mut().unwrap().deadline() >= *this.ka_expire {
                     // check for any outstanding tasks
-                    if self.state.is_empty() && self.write_buf.is_empty() {
-                        if self.flags.contains(Flags::STARTED) {
+                    if this.state.is_empty() && this.write_buf.is_empty() {
+                        if this.flags.contains(Flags::STARTED) {
                             trace!("Keep-alive timeout, close connection");
-                            self.flags.insert(Flags::SHUTDOWN);
+                            this.flags.insert(Flags::SHUTDOWN);
 
                             // start shutdown timer
                             if let Some(deadline) =
-                                self.codec.config().client_disconnect_timer()
+                                this.codec.config().client_disconnect_timer()
                             {
-                                if let Some(mut timer) = self.ka_timer.as_mut() {
+                                if let Some(mut timer) = this.ka_timer.as_mut() {
                                     timer.reset(deadline);
                                     let _ = Pin::new(&mut timer).poll(cx);
                                 }
                             } else {
                                 // no shutdown timeout, drop socket
-                                self.flags.insert(Flags::WRITE_DISCONNECT);
+                                this.flags.insert(Flags::WRITE_DISCONNECT);
                                 return Ok(());
                             }
                         } else {
                             // timeout on first request (slow request) return 408
-                            if !self.flags.contains(Flags::STARTED) {
+                            if !this.flags.contains(Flags::STARTED) {
                                 trace!("Slow request timeout");
-                                let _ = self.send_response(
+                                let _ = self.as_mut().send_response(
                                     Response::RequestTimeout().finish().drop_body(),
                                     ResponseBody::Other(Body::Empty),
                                 );
+                                this = self.as_mut().project();
                             } else {
                                 trace!("Keep-alive connection timeout");
                             }
-                            self.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
-                            self.state = State::None;
+                            this.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
+                            this.state.set(State::None);
                         }
                     } else if let Some(deadline) =
-                        self.codec.config().keep_alive_expire()
+                        this.codec.config().keep_alive_expire()
                     {
-                        if let Some(mut timer) = self.ka_timer.as_mut() {
+                        if let Some(mut timer) = this.ka_timer.as_mut() {
                             timer.reset(deadline);
                             let _ = Pin::new(&mut timer).poll(cx);
                         }
                     }
-                } else if let Some(mut timer) = self.ka_timer.as_mut() {
-                    timer.reset(self.ka_expire);
+                } else if let Some(mut timer) = this.ka_timer.as_mut() {
+                    timer.reset(*this.ka_expire);
                     let _ = Pin::new(&mut timer).poll(cx);
                 }
             }
@@ -681,20 +696,6 @@ where
     }
 }
 
-impl<T, S, B, X, U> Unpin for Dispatcher<T, S, B, X, U>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-}
-
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
@@ -711,20 +712,25 @@ where
 
     #[inline]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.as_mut().inner {
-            DispatcherState::Normal(ref mut inner) => {
-                inner.poll_keepalive(cx)?;
+        let this = self.as_mut().project();
+        match this.inner.project() {
+            DispatcherStateProj::Normal(mut inner) => {
+                inner.as_mut().poll_keepalive(cx)?;
 
                 if inner.flags.contains(Flags::SHUTDOWN) {
                     if inner.flags.contains(Flags::WRITE_DISCONNECT) {
                         Poll::Ready(Ok(()))
                     } else {
                         // flush buffer
-                        inner.poll_flush(cx)?;
-                        if !inner.write_buf.is_empty() {
+                        inner.as_mut().poll_flush(cx)?;
+                        if !inner.write_buf.is_empty() || inner.io.is_none() {
                             Poll::Pending
                         } else {
-                            match Pin::new(&mut inner.io).poll_shutdown(cx) {
+                            match Pin::new(inner.project().io)
+                                .as_pin_mut()
+                                .unwrap()
+                                .poll_shutdown(cx)
+                            {
                                 Poll::Ready(res) => {
                                     Poll::Ready(res.map_err(DispatchError::from))
                                 }
@@ -736,53 +742,58 @@ where
                     // read socket into a buf
                     let should_disconnect =
                         if !inner.flags.contains(Flags::READ_DISCONNECT) {
-                            read_available(cx, &mut inner.io, &mut inner.read_buf)?
+                            let mut inner_p = inner.as_mut().project();
+                            read_available(
+                                cx,
+                                inner_p.io.as_mut().unwrap(),
+                                &mut inner_p.read_buf,
+                            )?
                         } else {
                             None
                         };
 
-                    inner.poll_request(cx)?;
+                    inner.as_mut().poll_request(cx)?;
                     if let Some(true) = should_disconnect {
-                        inner.flags.insert(Flags::READ_DISCONNECT);
-                        if let Some(mut payload) = inner.payload.take() {
+                        let inner_p = inner.as_mut().project();
+                        inner_p.flags.insert(Flags::READ_DISCONNECT);
+                        if let Some(mut payload) = inner_p.payload.take() {
                             payload.feed_eof();
                         }
                     };
 
                     loop {
+                        let inner_p = inner.as_mut().project();
                         let remaining =
-                            inner.write_buf.capacity() - inner.write_buf.len();
+                            inner_p.write_buf.capacity() - inner_p.write_buf.len();
                         if remaining < LW_BUFFER_SIZE {
-                            inner.write_buf.reserve(HW_BUFFER_SIZE - remaining);
+                            inner_p.write_buf.reserve(HW_BUFFER_SIZE - remaining);
                         }
-                        let result = inner.poll_response(cx)?;
+                        let result = inner.as_mut().poll_response(cx)?;
                         let drain = result == PollResponse::DrainWriteBuf;
 
                         // switch to upgrade handler
                         if let PollResponse::Upgrade(req) = result {
-                            if let DispatcherState::Normal(inner) =
-                                std::mem::replace(&mut self.inner, DispatcherState::None)
-                            {
-                                let mut parts = FramedParts::with_read_buf(
-                                    inner.io,
-                                    inner.codec,
-                                    inner.read_buf,
-                                );
-                                parts.write_buf = inner.write_buf;
-                                let framed = Framed::from_parts(parts);
-                                self.inner = DispatcherState::Upgrade(
-                                    inner.upgrade.unwrap().call((req, framed)),
-                                );
-                                return self.poll(cx);
-                            } else {
-                                panic!()
-                            }
+                            let inner_p = inner.as_mut().project();
+                            let mut parts = FramedParts::with_read_buf(
+                                inner_p.io.take().unwrap(),
+                                std::mem::take(inner_p.codec),
+                                std::mem::take(inner_p.read_buf),
+                            );
+                            parts.write_buf = std::mem::take(inner_p.write_buf);
+                            let framed = Framed::from_parts(parts);
+                            let upgrade =
+                                inner_p.upgrade.take().unwrap().call((req, framed));
+                            self.as_mut()
+                                .project()
+                                .inner
+                                .set(DispatcherState::Upgrade(Box::pin(upgrade)));
+                            return self.poll(cx);
                         }
 
-                        // we didnt get WouldBlock from write operation,
+                        // we didn't get WouldBlock from write operation,
                         // so data get written to kernel completely (OSX)
                         // and we have to write again otherwise response can get stuck
-                        if inner.poll_flush(cx)? || !drain {
+                        if inner.as_mut().poll_flush(cx)? || !drain {
                             break;
                         }
                     }
@@ -794,25 +805,26 @@ where
 
                     let is_empty = inner.state.is_empty();
 
+                    let inner_p = inner.as_mut().project();
                     // read half is closed and we do not processing any responses
-                    if inner.flags.contains(Flags::READ_DISCONNECT) && is_empty {
-                        inner.flags.insert(Flags::SHUTDOWN);
+                    if inner_p.flags.contains(Flags::READ_DISCONNECT) && is_empty {
+                        inner_p.flags.insert(Flags::SHUTDOWN);
                     }
 
                     // keep-alive and stream errors
-                    if is_empty && inner.write_buf.is_empty() {
-                        if let Some(err) = inner.error.take() {
+                    if is_empty && inner_p.write_buf.is_empty() {
+                        if let Some(err) = inner_p.error.take() {
                             Poll::Ready(Err(err))
                         }
                         // disconnect if keep-alive is not enabled
-                        else if inner.flags.contains(Flags::STARTED)
-                            && !inner.flags.intersects(Flags::KEEPALIVE)
+                        else if inner_p.flags.contains(Flags::STARTED)
+                            && !inner_p.flags.intersects(Flags::KEEPALIVE)
                         {
-                            inner.flags.insert(Flags::SHUTDOWN);
+                            inner_p.flags.insert(Flags::SHUTDOWN);
                             self.poll(cx)
                         }
                         // disconnect if shutdown
-                        else if inner.flags.contains(Flags::SHUTDOWN) {
+                        else if inner_p.flags.contains(Flags::SHUTDOWN) {
                             self.poll(cx)
                         } else {
                             Poll::Pending
@@ -822,13 +834,10 @@ where
                     }
                 }
             }
-            DispatcherState::Upgrade(ref mut fut) => {
-                unsafe { Pin::new_unchecked(fut) }.poll(cx).map_err(|e| {
-                    error!("Upgrade handler error: {}", e);
-                    DispatchError::Upgrade
-                })
-            }
-            DispatcherState::None => panic!(),
+            DispatcherStateProj::Upgrade(fut) => fut.as_mut().poll(cx).map_err(|e| {
+                error!("Upgrade handler error: {}", e);
+                DispatchError::Upgrade
+            }),
         }
     }
 }
@@ -842,7 +851,14 @@ where
     T: AsyncRead + Unpin,
 {
     let mut read_some = false;
+
     loop {
+        // If buf is full return but do not disconnect since
+        // there is more reading to be done
+        if buf.len() >= HW_BUFFER_SIZE {
+            return Ok(Some(false));
+        }
+
         let remaining = buf.capacity() - buf.len();
         if remaining < LW_BUFFER_SIZE {
             buf.reserve(HW_BUFFER_SIZE - remaining);
@@ -918,9 +934,12 @@ mod tests {
                 Poll::Ready(res) => assert!(res.is_err()),
             }
 
-            if let DispatcherState::Normal(ref inner) = h1.inner {
+            if let DispatcherState::Normal(ref mut inner) = h1.inner {
                 assert!(inner.flags.contains(Flags::READ_DISCONNECT));
-                assert_eq!(&inner.io.write_buf[..26], b"HTTP/1.1 400 Bad Request\r\n");
+                assert_eq!(
+                    &inner.io.take().unwrap().write_buf[..26],
+                    b"HTTP/1.1 400 Bad Request\r\n"
+                );
             }
         })
         .await;

actix-http/src/h1/encoder.rs

@@ -4,7 +4,7 @@ use std::ptr::copy_nonoverlapping;
 use std::slice::from_raw_parts_mut;
 use std::{cmp, io};
 
-use bytes::{buf::BufMutExt, BufMut, BytesMut};
+use bytes::{BufMut, BytesMut};
 
 use crate::body::BodySize;
 use crate::config::ServiceConfig;
@@ -95,15 +95,6 @@ pub(crate) trait MessageType: Sized {
                 }
             }
             BodySize::Sized(len) => helpers::write_content_length(len, dst),
-            BodySize::Sized64(len) => {
-                if camel_case {
-                    dst.put_slice(b"\r\nContent-Length: ");
-                } else {
-                    dst.put_slice(b"\r\ncontent-length: ");
-                }
-                #[allow(clippy::write_with_newline)]
-                write!(dst.writer(), "{}\r\n", len)?;
-            }
             BodySize::None => dst.put_slice(b"\r\n"),
         }
 
@@ -138,89 +129,133 @@ pub(crate) trait MessageType: Sized {
             .chain(extra_headers.inner.iter());
 
         // write headers
-        let mut pos = 0;
+
         let mut has_date = false;
-        let mut remaining = dst.capacity() - dst.len();
+
         let mut buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
+        let mut remaining = dst.capacity() - dst.len();
+
+        // tracks bytes written since last buffer resize
+        // since buf is a raw pointer to a bytes container storage but is written to without the
+        // container's knowledge, this is used to sync the containers cursor after data is written
+        let mut pos = 0;
+
         for (key, value) in headers {
             match *key {
                 CONNECTION => continue,
                 TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => continue,
-                DATE => {
-                    has_date = true;
-                }
+                DATE => has_date = true,
                 _ => (),
             }
+
             let k = key.as_str().as_bytes();
+            let k_len = k.len();
+
             match value {
                 map::Value::One(ref val) => {
                     let v = val.as_ref();
                     let v_len = v.len();
-                    let k_len = k.len();
+
+                    // key length + value length + colon + space + \r\n
                     let len = k_len + v_len + 4;
+
                     if len > remaining {
+                        // not enough room in buffer for this header; reserve more space
+
+                        // SAFETY: all the bytes written up to position "pos" are initialized
+                        // the written byte count and pointer advancement are kept in sync
                         unsafe {
                             dst.advance_mut(pos);
                         }
+
                         pos = 0;
                         dst.reserve(len * 2);
                         remaining = dst.capacity() - dst.len();
+
+                        // re-assign buf raw pointer since it's possible that the buffer was
+                        // reallocated and/or resized
                         buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
                     }
-                    // use upper Camel-Case
+
+                    // SAFETY: on each write, it is enough to ensure that the advancement of the
+                    // cursor matches the number of bytes written
                     unsafe {
+                        // use upper Camel-Case
                         if camel_case {
                             write_camel_case(k, from_raw_parts_mut(buf, k_len))
                         } else {
                             write_data(k, buf, k_len)
                         }
+
                         buf = buf.add(k_len);
+
                         write_data(b": ", buf, 2);
                         buf = buf.add(2);
+
                         write_data(v, buf, v_len);
                         buf = buf.add(v_len);
+
                         write_data(b"\r\n", buf, 2);
                         buf = buf.add(2);
-                        pos += len;
-                        remaining -= len;
                     }
+
+                    pos += len;
+                    remaining -= len;
                 }
+
                 map::Value::Multi(ref vec) => {
                     for val in vec {
                         let v = val.as_ref();
                         let v_len = v.len();
-                        let k_len = k.len();
                         let len = k_len + v_len + 4;
+
                         if len > remaining {
+                            // SAFETY: all the bytes written up to position "pos" are initialized
+                            // the written byte count and pointer advancement are kept in sync
                             unsafe {
                                 dst.advance_mut(pos);
                             }
                             pos = 0;
                             dst.reserve(len * 2);
                             remaining = dst.capacity() - dst.len();
+
+                            // re-assign buf raw pointer since it's possible that the buffer was
+                            // reallocated and/or resized
                             buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
                         }
-                        // use upper Camel-Case
+
+                        // SAFETY: on each write, it is enough to ensure that the advancement of
+                        // the cursor matches the number of bytes written
                         unsafe {
                             if camel_case {
                                 write_camel_case(k, from_raw_parts_mut(buf, k_len));
                             } else {
                                 write_data(k, buf, k_len);
                             }
+
                             buf = buf.add(k_len);
+
                             write_data(b": ", buf, 2);
                             buf = buf.add(2);
+
                             write_data(v, buf, v_len);
                             buf = buf.add(v_len);
+
                             write_data(b"\r\n", buf, 2);
                             buf = buf.add(2);
                         };
+
                         pos += len;
                         remaining -= len;
                     }
                 }
             }
         }
+
+        // final cursor synchronization with the bytes container
+        //
+        // SAFETY: all the bytes written up to position "pos" are initialized
+        // the written byte count and pointer advancement are kept in sync
         unsafe {
             dst.advance_mut(pos);
         }
@@ -338,8 +373,7 @@ impl<T: MessageType> MessageEncoder<T> {
         if !head {
             self.te = match length {
                 BodySize::Empty => TransferEncoding::empty(),
-                BodySize::Sized(len) => TransferEncoding::length(len as u64),
-                BodySize::Sized64(len) => TransferEncoding::length(len),
+                BodySize::Sized(len) => TransferEncoding::length(len),
                 BodySize::Stream => {
                     if message.chunked() && !stream {
                         TransferEncoding::chunked()
@@ -487,7 +521,10 @@ impl<'a> io::Write for Writer<'a> {
     }
 }
 
+/// # Safety
+/// Callers must ensure that the given length matches given value length.
 unsafe fn write_data(value: &[u8], buf: *mut u8, len: usize) {
+    debug_assert_eq!(value.len(), len);
     copy_nonoverlapping(value.as_ptr(), buf, len);
 }
 
@@ -582,19 +619,6 @@ mod tests {
         assert!(data.contains("Content-Type: plain/text\r\n"));
         assert!(data.contains("Date: date\r\n"));
 
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Sized64(100),
-            ConnectionType::KeepAlive,
-            &ServiceConfig::default(),
-        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
-        assert!(data.contains("Content-Length: 100\r\n"));
-        assert!(data.contains("Content-Type: plain/text\r\n"));
-        assert!(data.contains("Date: date\r\n"));
-
         let mut head = RequestHead::default();
         head.set_camel_case_headers(false);
         head.headers.insert(DATE, HeaderValue::from_static("date"));

actix-http/src/h1/service.rs

@@ -98,7 +98,7 @@ mod openssl {
     use super::*;
 
     use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::HandshakeError, SslError};
+    use actix_tls::{openssl::HandshakeError, TlsError};
 
     impl<S, B, X, U> H1Service<SslStream<TcpStream>, S, B, X, U>
     where
@@ -126,19 +126,19 @@ mod openssl {
             Config = (),
             Request = TcpStream,
             Response = (),
-            Error = SslError<HandshakeError<TcpStream>, DispatchError>,
+            Error = TlsError<HandshakeError<TcpStream>, DispatchError>,
             InitError = (),
         > {
             pipeline_factory(
                 Acceptor::new(acceptor)
-                    .map_err(SslError::Ssl)
+                    .map_err(TlsError::Tls)
                     .map_init_err(|_| panic!()),
             )
             .and_then(|io: SslStream<TcpStream>| {
                 let peer_addr = io.get_ref().peer_addr().ok();
                 ok((io, peer_addr))
             })
-            .and_then(self.map_err(SslError::Service))
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
@@ -147,7 +147,7 @@ mod openssl {
 mod rustls {
     use super::*;
     use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::SslError;
+    use actix_tls::TlsError;
     use std::{fmt, io};
 
     impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
@@ -176,19 +176,19 @@ mod rustls {
             Config = (),
             Request = TcpStream,
             Response = (),
-            Error = SslError<io::Error, DispatchError>,
+            Error = TlsError<io::Error, DispatchError>,
             InitError = (),
         > {
             pipeline_factory(
                 Acceptor::new(config)
-                    .map_err(SslError::Ssl)
+                    .map_err(TlsError::Tls)
                     .map_init_err(|_| panic!()),
             )
             .and_then(|io: TlsStream<TcpStream>| {
                 let peer_addr = io.get_ref().0.peer_addr().ok();
                 ok((io, peer_addr))
             })
-            .and_then(self.map_err(SslError::Service))
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
@@ -364,7 +364,7 @@ where
 }
 
 /// `Service` implementation for HTTP1 transport
-pub struct H1ServiceHandler<T, S, B, X, U> {
+pub struct H1ServiceHandler<T, S: Service, B, X: Service, U: Service> {
     srv: CloneableService<S>,
     expect: CloneableService<X>,
     upgrade: Option<CloneableService<U>>,
@@ -548,10 +548,12 @@ where
 }
 
 #[doc(hidden)]
+#[pin_project::pin_project]
 pub struct OneRequestServiceResponse<T>
 where
     T: AsyncRead + AsyncWrite + Unpin,
 {
+    #[pin]
     framed: Option<Framed<T, Codec>>,
 }
 
@@ -562,16 +564,18 @@ where
     type Output = Result<(Request, Framed<T, Codec>), ParseError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.framed.as_mut().unwrap().next_item(cx) {
-            Poll::Ready(Some(Ok(req))) => match req {
+        let this = self.as_mut().project();
+
+        match ready!(this.framed.as_pin_mut().unwrap().next_item(cx)) {
+            Some(Ok(req)) => match req {
                 Message::Item(req) => {
-                    Poll::Ready(Ok((req, self.framed.take().unwrap())))
+                    let mut this = self.as_mut().project();
+                    Poll::Ready(Ok((req, this.framed.take().unwrap())))
                 }
                 Message::Chunk(_) => unreachable!("Something is wrong"),
             },
-            Poll::Ready(Some(Err(err))) => Poll::Ready(Err(err)),
-            Poll::Ready(None) => Poll::Ready(Err(ParseError::Incomplete)),
-            Poll::Pending => Poll::Pending,
+            Some(Err(err)) => Poll::Ready(Err(err)),
+            None => Poll::Ready(Err(ParseError::Incomplete)),
         }
     }
 }

actix-http/src/h1/utils.rs

@@ -9,11 +9,13 @@ use crate::error::Error;
 use crate::h1::{Codec, Message};
 use crate::response::Response;
 
-/// Send http/1 response
+/// Send HTTP/1 response
 #[pin_project::pin_project]
 pub struct SendResponse<T, B> {
     res: Option<Message<(Response<()>, BodySize)>>,
+    #[pin]
     body: Option<ResponseBody<B>>,
+    #[pin]
     framed: Option<Framed<T, Codec>>,
 }
 
@@ -34,27 +36,38 @@ where
 
 impl<T, B> Future for SendResponse<T, B>
 where
-    T: AsyncRead + AsyncWrite,
-    B: MessageBody,
+    T: AsyncRead + AsyncWrite + Unpin,
+    B: MessageBody + Unpin,
 {
     type Output = Result<Framed<T, Codec>, Error>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
+    // TODO: rethink if we need loops in polls
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
 
+        let mut body_done = this.body.is_none();
         loop {
-            let mut body_ready = this.body.is_some();
-            let framed = this.framed.as_mut().unwrap();
+            let mut body_ready = !body_done;
 
             // send body
-            if this.res.is_none() && this.body.is_some() {
-                while body_ready && this.body.is_some() && !framed.is_write_buf_full() {
-                    match this.body.as_mut().unwrap().poll_next(cx)? {
+            if this.res.is_none() && body_ready {
+                while body_ready
+                    && !body_done
+                    && !this
+                        .framed
+                        .as_ref()
+                        .as_pin_ref()
+                        .unwrap()
+                        .is_write_buf_full()
+                {
+                    match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx)? {
                         Poll::Ready(item) => {
-                            // body is done
-                            if item.is_none() {
+                            // body is done when item is None
+                            body_done = item.is_none();
+                            if body_done {
                                 let _ = this.body.take();
                             }
+                            let framed = this.framed.as_mut().as_pin_mut().unwrap();
                             framed.write(Message::Chunk(item))?;
                         }
                         Poll::Pending => body_ready = false,
@@ -62,6 +75,8 @@ where
                 }
             }
 
+            let framed = this.framed.as_mut().as_pin_mut().unwrap();
+
             // flush write buffer
             if !framed.is_write_buf_empty() {
                 match framed.flush(cx)? {
@@ -82,7 +97,7 @@ where
                 continue;
             }
 
-            if this.body.is_some() {
+            if !body_done {
                 if body_ready {
                     continue;
                 } else {
@@ -92,6 +107,9 @@ where
                 break;
             }
         }
-        Poll::Ready(Ok(this.framed.take().unwrap()))
+
+        let framed = this.framed.take().unwrap();
+
+        Poll::Ready(Ok(framed))
     }
 }

actix-http/src/h2/dispatcher.rs

@@ -158,15 +158,17 @@ where
 
 #[pin_project::pin_project]
 struct ServiceResponse<F, I, E, B> {
+    #[pin]
     state: ServiceResponseState<F, B>,
     config: ServiceConfig,
     buffer: Option<Bytes>,
     _t: PhantomData<(I, E)>,
 }
 
+#[pin_project::pin_project(project = ServiceResponseStateProj)]
 enum ServiceResponseState<F, B> {
-    ServiceCall(F, Option<SendResponse<Bytes>>),
-    SendPayload(SendStream<Bytes>, ResponseBody<B>),
+    ServiceCall(#[pin] F, Option<SendResponse<Bytes>>),
+    SendPayload(SendStream<Bytes>, #[pin] ResponseBody<B>),
 }
 
 impl<F, I, E, B> ServiceResponse<F, I, E, B>
@@ -208,10 +210,6 @@ where
                 CONTENT_LENGTH,
                 HeaderValue::try_from(format!("{}", len)).unwrap(),
             ),
-            BodySize::Sized64(len) => res.headers_mut().insert(
-                CONTENT_LENGTH,
-                HeaderValue::try_from(format!("{}", len)).unwrap(),
-            ),
         };
 
         // copy headers
@@ -229,9 +227,11 @@ where
         if !has_date {
             let mut bytes = BytesMut::with_capacity(29);
             self.config.set_date_header(&mut bytes);
-            res.headers_mut().insert(DATE, unsafe {
-                HeaderValue::from_maybe_shared_unchecked(bytes.freeze())
-            });
+            res.headers_mut().insert(
+                DATE,
+                // SAFETY: serialized date-times are known ASCII strings
+                unsafe { HeaderValue::from_maybe_shared_unchecked(bytes.freeze()) },
+            );
         }
 
         res
@@ -250,114 +250,114 @@ where
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        match this.state {
-            ServiceResponseState::ServiceCall(ref mut call, ref mut send) => {
-                match unsafe { Pin::new_unchecked(call) }.poll(cx) {
-                    Poll::Ready(Ok(res)) => {
-                        let (res, body) = res.into().replace_body(());
+        match this.state.project() {
+            ServiceResponseStateProj::ServiceCall(call, send) => match call.poll(cx) {
+                Poll::Ready(Ok(res)) => {
+                    let (res, body) = res.into().replace_body(());
 
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res =
-                            self.as_mut().prepare_response(res.head(), &mut size);
-                        this = self.as_mut().project();
+                    let mut send = send.take().unwrap();
+                    let mut size = body.size();
+                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
+                    this = self.as_mut().project();
 
-                        let stream = match send.send_response(h2_res, size.is_eof()) {
-                            Err(e) => {
-                                trace!("Error sending h2 response: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                            Ok(stream) => stream,
-                        };
-
-                        if size.is_eof() {
-                            Poll::Ready(())
-                        } else {
-                            *this.state =
-                                ServiceResponseState::SendPayload(stream, body);
-                            self.poll(cx)
+                    let stream = match send.send_response(h2_res, size.is_eof()) {
+                        Err(e) => {
+                            trace!("Error sending h2 response: {:?}", e);
+                            return Poll::Ready(());
                         }
+                        Ok(stream) => stream,
+                    };
+
+                    if size.is_eof() {
+                        Poll::Ready(())
+                    } else {
+                        this.state
+                            .set(ServiceResponseState::SendPayload(stream, body));
+                        self.poll(cx)
                     }
-                    Poll::Pending => Poll::Pending,
-                    Poll::Ready(Err(e)) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
+                }
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(Err(e)) => {
+                    let res: Response = e.into().into();
+                    let (res, body) = res.replace_body(());
 
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res =
-                            self.as_mut().prepare_response(res.head(), &mut size);
-                        this = self.as_mut().project();
+                    let mut send = send.take().unwrap();
+                    let mut size = body.size();
+                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
+                    this = self.as_mut().project();
 
-                        let stream = match send.send_response(h2_res, size.is_eof()) {
-                            Err(e) => {
-                                trace!("Error sending h2 response: {:?}", e);
-                                return Poll::Ready(());
+                    let stream = match send.send_response(h2_res, size.is_eof()) {
+                        Err(e) => {
+                            trace!("Error sending h2 response: {:?}", e);
+                            return Poll::Ready(());
+                        }
+                        Ok(stream) => stream,
+                    };
+
+                    if size.is_eof() {
+                        Poll::Ready(())
+                    } else {
+                        this.state.set(ServiceResponseState::SendPayload(
+                            stream,
+                            body.into_body(),
+                        ));
+                        self.poll(cx)
+                    }
+                }
+            },
+            ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
+                loop {
+                    loop {
+                        if let Some(ref mut buffer) = this.buffer {
+                            match stream.poll_capacity(cx) {
+                                Poll::Pending => return Poll::Pending,
+                                Poll::Ready(None) => return Poll::Ready(()),
+                                Poll::Ready(Some(Ok(cap))) => {
+                                    let len = buffer.len();
+                                    let bytes = buffer.split_to(std::cmp::min(cap, len));
+
+                                    if let Err(e) = stream.send_data(bytes, false) {
+                                        warn!("{:?}", e);
+                                        return Poll::Ready(());
+                                    } else if !buffer.is_empty() {
+                                        let cap =
+                                            std::cmp::min(buffer.len(), CHUNK_SIZE);
+                                        stream.reserve_capacity(cap);
+                                    } else {
+                                        this.buffer.take();
+                                    }
+                                }
+                                Poll::Ready(Some(Err(e))) => {
+                                    warn!("{:?}", e);
+                                    return Poll::Ready(());
+                                }
                             }
-                            Ok(stream) => stream,
-                        };
-
-                        if size.is_eof() {
-                            Poll::Ready(())
                         } else {
-                            *this.state = ServiceResponseState::SendPayload(
-                                stream,
-                                body.into_body(),
-                            );
-                            self.poll(cx)
+                            match body.as_mut().poll_next(cx) {
+                                Poll::Pending => return Poll::Pending,
+                                Poll::Ready(None) => {
+                                    if let Err(e) = stream.send_data(Bytes::new(), true)
+                                    {
+                                        warn!("{:?}", e);
+                                    }
+                                    return Poll::Ready(());
+                                }
+                                Poll::Ready(Some(Ok(chunk))) => {
+                                    stream.reserve_capacity(std::cmp::min(
+                                        chunk.len(),
+                                        CHUNK_SIZE,
+                                    ));
+                                    *this.buffer = Some(chunk);
+                                }
+                                Poll::Ready(Some(Err(e))) => {
+                                    error!("Response payload stream error: {:?}", e);
+                                    return Poll::Ready(());
+                                }
+                            }
                         }
                     }
                 }
             }
-            ServiceResponseState::SendPayload(ref mut stream, ref mut body) => loop {
-                loop {
-                    if let Some(ref mut buffer) = this.buffer {
-                        match stream.poll_capacity(cx) {
-                            Poll::Pending => return Poll::Pending,
-                            Poll::Ready(None) => return Poll::Ready(()),
-                            Poll::Ready(Some(Ok(cap))) => {
-                                let len = buffer.len();
-                                let bytes = buffer.split_to(std::cmp::min(cap, len));
-
-                                if let Err(e) = stream.send_data(bytes, false) {
-                                    warn!("{:?}", e);
-                                    return Poll::Ready(());
-                                } else if !buffer.is_empty() {
-                                    let cap = std::cmp::min(buffer.len(), CHUNK_SIZE);
-                                    stream.reserve_capacity(cap);
-                                } else {
-                                    this.buffer.take();
-                                }
-                            }
-                            Poll::Ready(Some(Err(e))) => {
-                                warn!("{:?}", e);
-                                return Poll::Ready(());
-                            }
-                        }
-                    } else {
-                        match body.poll_next(cx) {
-                            Poll::Pending => return Poll::Pending,
-                            Poll::Ready(None) => {
-                                if let Err(e) = stream.send_data(Bytes::new(), true) {
-                                    warn!("{:?}", e);
-                                }
-                                return Poll::Ready(());
-                            }
-                            Poll::Ready(Some(Ok(chunk))) => {
-                                stream.reserve_capacity(std::cmp::min(
-                                    chunk.len(),
-                                    CHUNK_SIZE,
-                                ));
-                                *this.buffer = Some(chunk);
-                            }
-                            Poll::Ready(Some(Err(e))) => {
-                                error!("Response payload stream error: {:?}", e);
-                                return Poll::Ready(());
-                            }
-                        }
-                    }
-                }
-            },
         }
     }
 }

actix-http/src/h2/service.rs

@@ -83,13 +83,11 @@ where
         Error = DispatchError,
         InitError = S::InitError,
     > {
-        pipeline_factory(fn_factory(|| {
-            async {
-                Ok::<_, S::InitError>(fn_service(|io: TcpStream| {
-                    let peer_addr = io.peer_addr().ok();
-                    ok::<_, DispatchError>((io, peer_addr))
-                }))
-            }
+        pipeline_factory(fn_factory(|| async {
+            Ok::<_, S::InitError>(fn_service(|io: TcpStream| {
+                let peer_addr = io.peer_addr().ok();
+                ok::<_, DispatchError>((io, peer_addr))
+            }))
         }))
         .and_then(self)
     }
@@ -99,7 +97,7 @@ where
 mod openssl {
     use actix_service::{fn_factory, fn_service};
     use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::HandshakeError, SslError};
+    use actix_tls::{openssl::HandshakeError, TlsError};
 
     use super::*;
 
@@ -119,12 +117,12 @@ mod openssl {
             Config = (),
             Request = TcpStream,
             Response = (),
-            Error = SslError<HandshakeError<TcpStream>, DispatchError>,
+            Error = TlsError<HandshakeError<TcpStream>, DispatchError>,
             InitError = S::InitError,
         > {
             pipeline_factory(
                 Acceptor::new(acceptor)
-                    .map_err(SslError::Ssl)
+                    .map_err(TlsError::Tls)
                     .map_init_err(|_| panic!()),
             )
             .and_then(fn_factory(|| {
@@ -133,7 +131,7 @@ mod openssl {
                     ok((io, peer_addr))
                 }))
             }))
-            .and_then(self.map_err(SslError::Service))
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
@@ -142,7 +140,7 @@ mod openssl {
 mod rustls {
     use super::*;
     use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::SslError;
+    use actix_tls::TlsError;
     use std::io;
 
     impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
@@ -161,7 +159,7 @@ mod rustls {
             Config = (),
             Request = TcpStream,
             Response = (),
-            Error = SslError<io::Error, DispatchError>,
+            Error = TlsError<io::Error, DispatchError>,
             InitError = S::InitError,
         > {
             let protos = vec!["h2".to_string().into()];
@@ -169,7 +167,7 @@ mod rustls {
 
             pipeline_factory(
                 Acceptor::new(config)
-                    .map_err(SslError::Ssl)
+                    .map_err(TlsError::Tls)
                     .map_init_err(|_| panic!()),
             )
             .and_then(fn_factory(|| {
@@ -178,7 +176,7 @@ mod rustls {
                     ok((io, peer_addr))
                 }))
             }))
-            .and_then(self.map_err(SslError::Service))
+            .and_then(self.map_err(TlsError::Service))
         }
     }
 }
@@ -246,7 +244,7 @@ where
 }
 
 /// `Service` implementation for http/2 transport
-pub struct H2ServiceHandler<T, S, B> {
+pub struct H2ServiceHandler<T, S: Service, B> {
     srv: CloneableService<S>,
     cfg: ServiceConfig,
     on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,

actix-http/src/header/common/accept_charset.rs

@@ -63,7 +63,7 @@ header! {
     (AcceptCharset, ACCEPT_CHARSET) => (QualityItem<Charset>)+
 
     test_accept_charset {
-        /// Test case from RFC
+        // Test case from RFC
         test_header!(test1, vec![b"iso-8859-5, unicode-1-1;q=0.8"]);
     }
 }

actix-http/src/header/common/allow.rs

@@ -1,5 +1,5 @@
-use http::Method;
 use http::header;
+use http::Method;
 
 header! {
     /// `Allow` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.4.1)

actix-http/src/header/common/content_disposition.rs

@@ -90,40 +90,40 @@ pub enum DispositionParam {
     /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *token "=" value*. Recipients should
     /// ignore unrecognizable parameters.
     Unknown(String, String),
-    /// An unrecognized extended paramater as defined in
+    /// An unrecognized extended parameter as defined in
     /// [RFC5987](https://tools.ietf.org/html/rfc5987) as *ext-parameter*, in
     /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *ext-token "=" ext-value*. The single
-    /// trailling asterisk is not included. Recipients should ignore unrecognizable parameters.
+    /// trailing asterisk is not included. Recipients should ignore unrecognizable parameters.
     UnknownExt(String, ExtendedValue),
 }
 
 impl DispositionParam {
-    /// Returns `true` if the paramater is [`Name`](DispositionParam::Name).
+    /// Returns `true` if the parameter is [`Name`](DispositionParam::Name).
     #[inline]
     pub fn is_name(&self) -> bool {
         self.as_name().is_some()
     }
 
-    /// Returns `true` if the paramater is [`Filename`](DispositionParam::Filename).
+    /// Returns `true` if the parameter is [`Filename`](DispositionParam::Filename).
     #[inline]
     pub fn is_filename(&self) -> bool {
         self.as_filename().is_some()
     }
 
-    /// Returns `true` if the paramater is [`FilenameExt`](DispositionParam::FilenameExt).
+    /// Returns `true` if the parameter is [`FilenameExt`](DispositionParam::FilenameExt).
     #[inline]
     pub fn is_filename_ext(&self) -> bool {
         self.as_filename_ext().is_some()
     }
 
-    /// Returns `true` if the paramater is [`Unknown`](DispositionParam::Unknown) and the `name`
+    /// Returns `true` if the parameter is [`Unknown`](DispositionParam::Unknown) and the `name`
     #[inline]
     /// matches.
     pub fn is_unknown<T: AsRef<str>>(&self, name: T) -> bool {
         self.as_unknown(name).is_some()
     }
 
-    /// Returns `true` if the paramater is [`UnknownExt`](DispositionParam::UnknownExt) and the
+    /// Returns `true` if the parameter is [`UnknownExt`](DispositionParam::UnknownExt) and the
     /// `name` matches.
     #[inline]
     pub fn is_unknown_ext<T: AsRef<str>>(&self, name: T) -> bool {
@@ -283,11 +283,11 @@ impl DispositionParam {
 ///            Some("\u{1f600}.svg".as_bytes()));
 /// ```
 ///
-/// # WARN
+/// # Security Note
+///
 /// If "filename" parameter is supplied, do not use the file name blindly, check and possibly
 /// change to match local file system conventions if applicable, and do not use directory path
-/// information that may be present. See [RFC2183](https://tools.ietf.org/html/rfc2183#section-2.3)
-/// .
+/// information that may be present. See [RFC2183](https://tools.ietf.org/html/rfc2183#section-2.3).
 #[derive(Clone, Debug, PartialEq)]
 pub struct ContentDisposition {
     /// The disposition type
@@ -373,7 +373,7 @@ impl ContentDisposition {
                 let param = if param_name.eq_ignore_ascii_case("name") {
                     DispositionParam::Name(value)
                 } else if param_name.eq_ignore_ascii_case("filename") {
-                    // See also comments in test_from_raw_uncessary_percent_decode.
+                    // See also comments in test_from_raw_unnecessary_percent_decode.
                     DispositionParam::Filename(value)
                 } else {
                     DispositionParam::Unknown(param_name.to_owned(), value)
@@ -387,26 +387,17 @@ impl ContentDisposition {
 
     /// Returns `true` if it is [`Inline`](DispositionType::Inline).
     pub fn is_inline(&self) -> bool {
-        match self.disposition {
-            DispositionType::Inline => true,
-            _ => false,
-        }
+        matches!(self.disposition, DispositionType::Inline)
     }
 
     /// Returns `true` if it is [`Attachment`](DispositionType::Attachment).
     pub fn is_attachment(&self) -> bool {
-        match self.disposition {
-            DispositionType::Attachment => true,
-            _ => false,
-        }
+        matches!(self.disposition, DispositionType::Attachment)
     }
 
     /// Returns `true` if it is [`FormData`](DispositionType::FormData).
     pub fn is_form_data(&self) -> bool {
-        match self.disposition {
-            DispositionType::FormData => true,
-            _ => false,
-        }
+        matches!(self.disposition, DispositionType::FormData)
     }
 
     /// Returns `true` if it is [`Ext`](DispositionType::Ext) and the `disp_type` matches.
@@ -423,7 +414,7 @@ impl ContentDisposition {
 
     /// Return the value of *name* if exists.
     pub fn get_name(&self) -> Option<&str> {
-        self.parameters.iter().filter_map(|p| p.as_name()).nth(0)
+        self.parameters.iter().filter_map(|p| p.as_name()).next()
     }
 
     /// Return the value of *filename* if exists.
@@ -431,7 +422,7 @@ impl ContentDisposition {
         self.parameters
             .iter()
             .filter_map(|p| p.as_filename())
-            .nth(0)
+            .next()
     }
 
     /// Return the value of *filename\** if exists.
@@ -439,7 +430,7 @@ impl ContentDisposition {
         self.parameters
             .iter()
             .filter_map(|p| p.as_filename_ext())
-            .nth(0)
+            .next()
     }
 
     /// Return the value of the parameter which the `name` matches.
@@ -448,7 +439,7 @@ impl ContentDisposition {
         self.parameters
             .iter()
             .filter_map(|p| p.as_unknown(name))
-            .nth(0)
+            .next()
     }
 
     /// Return the value of the extended parameter which the `name` matches.
@@ -457,7 +448,7 @@ impl ContentDisposition {
         self.parameters
             .iter()
             .filter_map(|p| p.as_unknown_ext(name))
-            .nth(0)
+            .next()
     }
 }
 
@@ -529,7 +520,7 @@ impl fmt::Display for DispositionParam {
         //               ; to use within parameter values
         //
         //
-        // See also comments in test_from_raw_uncessary_percent_decode.
+        // See also comments in test_from_raw_unnecessary_percent_decode.
         lazy_static! {
             static ref RE: Regex = Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap();
         }
@@ -676,7 +667,7 @@ mod tests {
     fn test_from_raw_unordered() {
         let a = HeaderValue::from_static(
             "form-data; dummy=3; filename=\"sample.png\" ; name=upload;",
-            // Actually, a trailling semolocon is not compliant. But it is fine to accept.
+            // Actually, a trailing semicolon is not compliant. But it is fine to accept.
         );
         let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
         let b = ContentDisposition {
@@ -833,7 +824,7 @@ mod tests {
     }
 
     #[test]
-    fn test_from_raw_uncessary_percent_decode() {
+    fn test_from_raw_unnecessary_percent_decode() {
         // In fact, RFC7578 (multipart/form-data) Section 2 and 4.2 suggests that filename with
         // non-ASCII characters MAY be percent-encoded.
         // On the contrary, RFC6266 or other RFCs related to Content-Disposition response header

actix-http/src/header/common/mod.rs

@@ -9,11 +9,13 @@
 
 pub use self::accept_charset::AcceptCharset;
 //pub use self::accept_encoding::AcceptEncoding;
-pub use self::accept_language::AcceptLanguage;
 pub use self::accept::Accept;
+pub use self::accept_language::AcceptLanguage;
 pub use self::allow::Allow;
 pub use self::cache_control::{CacheControl, CacheDirective};
-pub use self::content_disposition::{ContentDisposition, DispositionType, DispositionParam};
+pub use self::content_disposition::{
+    ContentDisposition, DispositionParam, DispositionType,
+};
 pub use self::content_language::ContentLanguage;
 pub use self::content_range::{ContentRange, ContentRangeSpec};
 pub use self::content_type::ContentType;
@@ -47,7 +49,7 @@ macro_rules! __hyper__deref {
                 &mut self.0
             }
         }
-    }
+    };
 }
 
 #[doc(hidden)]
@@ -74,8 +76,8 @@ macro_rules! test_header {
     ($id:ident, $raw:expr) => {
         #[test]
         fn $id() {
-            use $crate::test;
             use super::*;
+            use $crate::test;
 
             let raw = $raw;
             let a: Vec<Vec<u8>> = raw.iter().map(|x| x.to_vec()).collect();
@@ -118,7 +120,7 @@ macro_rules! test_header {
             // Test formatting
             if typed.is_some() {
                 let raw = &($raw)[..];
-                let mut iter = raw.iter().map(|b|str::from_utf8(&b[..]).unwrap());
+                let mut iter = raw.iter().map(|b| str::from_utf8(&b[..]).unwrap());
                 let mut joined = String::new();
                 joined.push_str(iter.next().unwrap());
                 for s in iter {
@@ -128,7 +130,7 @@ macro_rules! test_header {
                 assert_eq!(format!("{}", typed.unwrap()), joined);
             }
         }
-    }
+    };
 }
 
 #[macro_export]
@@ -330,11 +332,10 @@ macro_rules! header {
     };
 }
 
-
 mod accept_charset;
 //mod accept_encoding;
-mod accept_language;
 mod accept;
+mod accept_language;
 mod allow;
 mod cache_control;
 mod content_disposition;

actix-http/src/header/common/range.rs

@@ -7,7 +7,7 @@ use header::{Header, Raw};
 /// `Range` header, defined in [RFC7233](https://tools.ietf.org/html/rfc7233#section-3.1)
 ///
 /// The "Range" header field on a GET request modifies the method
-/// semantics to request transfer of only one or more subranges of the
+/// semantics to request transfer of only one or more sub-ranges of the
 /// selected representation data, rather than the entire selected
 /// representation data.
 ///
@@ -183,13 +183,13 @@ impl fmt::Display for Range {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Range::Bytes(ref ranges) => {
-                try!(write!(f, "bytes="));
+                write!(f, "bytes=")?;
 
                 for (i, range) in ranges.iter().enumerate() {
                     if i != 0 {
-                        try!(f.write_str(","));
+                        f.write_str(",")?;
                     }
-                    try!(Display::fmt(range, f));
+                    Display::fmt(range, f)?;
                 }
                 Ok(())
             }
@@ -214,9 +214,9 @@ impl FromStr for Range {
                 }
                 Ok(Range::Bytes(ranges))
             }
-            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => Ok(
-                Range::Unregistered(unit.to_owned(), range_str.to_owned()),
-            ),
+            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => {
+                Ok(Range::Unregistered(unit.to_owned(), range_str.to_owned()))
+            }
             _ => Err(::Error::Header),
         }
     }
@@ -229,7 +229,8 @@ impl FromStr for ByteRangeSpec {
         let mut parts = s.splitn(2, '-');
 
         match (parts.next(), parts.next()) {
-            (Some(""), Some(end)) => end.parse()
+            (Some(""), Some(end)) => end
+                .parse()
                 .or(Err(::Error::Header))
                 .map(ByteRangeSpec::Last),
             (Some(start), Some("")) => start
@@ -272,163 +273,138 @@ impl Header for Range {
     }
 }
 
-#[test]
-fn test_parse_bytes_range_valid() {
-    let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
-    let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
-    let r3 = Range::bytes(1, 100);
-    assert_eq!(r, r2);
-    assert_eq!(r2, r3);
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
-    let r2: Range =
-        Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
-    let r3 = Range::Bytes(vec![
-        ByteRangeSpec::FromTo(1, 100),
-        ByteRangeSpec::AllFrom(200),
-    ]);
-    assert_eq!(r, r2);
-    assert_eq!(r2, r3);
+    #[test]
+    fn test_parse_bytes_range_valid() {
+        let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
+        let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
+        let r3 = Range::bytes(1, 100);
+        assert_eq!(r, r2);
+        assert_eq!(r2, r3);
 
-    let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
-    let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
-    let r3 = Range::Bytes(vec![
-        ByteRangeSpec::FromTo(1, 100),
-        ByteRangeSpec::Last(100),
-    ]);
-    assert_eq!(r, r2);
-    assert_eq!(r2, r3);
+        let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
+        let r2: Range =
+            Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
+        let r3 = Range::Bytes(vec![
+            ByteRangeSpec::FromTo(1, 100),
+            ByteRangeSpec::AllFrom(200),
+        ]);
+        assert_eq!(r, r2);
+        assert_eq!(r2, r3);
 
-    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
-    let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
-    assert_eq!(r, r2);
-}
-
-#[test]
-fn test_parse_unregistered_range_valid() {
-    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
-    let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
-    assert_eq!(r, r2);
-
-    let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
-    let r2 = Range::Unregistered("custom".to_owned(), "abcd".to_owned());
-    assert_eq!(r, r2);
-
-    let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
-    let r2 = Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
-    assert_eq!(r, r2);
-}
-
-#[test]
-fn test_parse_invalid() {
-    let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
-    assert_eq!(r.ok(), None);
-
-    let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
-    assert_eq!(r.ok(), None);
-
-    let r: ::Result<Range> = Header::parse_header(&"abc".into());
-    assert_eq!(r.ok(), None);
-
-    let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
-    assert_eq!(r.ok(), None);
-
-    let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
-    assert_eq!(r.ok(), None);
-
-    let r: ::Result<Range> = Header::parse_header(&"custom=".into());
-    assert_eq!(r.ok(), None);
-
-    let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
-    assert_eq!(r.ok(), None);
-}
-
-#[test]
-fn test_fmt() {
-    use header::Headers;
-
-    let mut headers = Headers::new();
-
-    headers.set(Range::Bytes(vec![
-        ByteRangeSpec::FromTo(0, 1000),
-        ByteRangeSpec::AllFrom(2000),
-    ]));
-    assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
-
-    headers.clear();
-    headers.set(Range::Bytes(vec![]));
-
-    assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
-
-    headers.clear();
-    headers.set(Range::Unregistered(
-        "custom".to_owned(),
-        "1-xxx".to_owned(),
-    ));
-
-    assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
-}
-
-#[test]
-fn test_byte_range_spec_to_satisfiable_range() {
-    assert_eq!(
-        Some((0, 0)),
-        ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        Some((1, 2)),
-        ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        Some((1, 2)),
-        ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        None,
-        ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        None,
-        ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        None,
-        ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0)
-    );
-
-    assert_eq!(
-        Some((0, 2)),
-        ByteRangeSpec::AllFrom(0).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        Some((2, 2)),
-        ByteRangeSpec::AllFrom(2).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        None,
-        ByteRangeSpec::AllFrom(3).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        None,
-        ByteRangeSpec::AllFrom(5).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        None,
-        ByteRangeSpec::AllFrom(0).to_satisfiable_range(0)
-    );
-
-    assert_eq!(
-        Some((1, 2)),
-        ByteRangeSpec::Last(2).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        Some((2, 2)),
-        ByteRangeSpec::Last(1).to_satisfiable_range(3)
-    );
-    assert_eq!(
-        Some((0, 2)),
-        ByteRangeSpec::Last(5).to_satisfiable_range(3)
-    );
-    assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
-    assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
+        let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
+        let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
+        let r3 = Range::Bytes(vec![
+            ByteRangeSpec::FromTo(1, 100),
+            ByteRangeSpec::Last(100),
+        ]);
+        assert_eq!(r, r2);
+        assert_eq!(r2, r3);
+
+        let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+        let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+        assert_eq!(r, r2);
+    }
+
+    #[test]
+    fn test_parse_unregistered_range_valid() {
+        let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+        let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+        assert_eq!(r, r2);
+
+        let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
+        let r2 = Range::Unregistered("custom".to_owned(), "abcd".to_owned());
+        assert_eq!(r, r2);
+
+        let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
+        let r2 = Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
+        assert_eq!(r, r2);
+    }
+
+    #[test]
+    fn test_parse_invalid() {
+        let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
+        assert_eq!(r.ok(), None);
+
+        let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
+        assert_eq!(r.ok(), None);
+
+        let r: ::Result<Range> = Header::parse_header(&"abc".into());
+        assert_eq!(r.ok(), None);
+
+        let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
+        assert_eq!(r.ok(), None);
+
+        let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
+        assert_eq!(r.ok(), None);
+
+        let r: ::Result<Range> = Header::parse_header(&"custom=".into());
+        assert_eq!(r.ok(), None);
+
+        let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
+        assert_eq!(r.ok(), None);
+    }
+
+    #[test]
+    fn test_fmt() {
+        use header::Headers;
+
+        let mut headers = Headers::new();
+
+        headers.set(Range::Bytes(vec![
+            ByteRangeSpec::FromTo(0, 1000),
+            ByteRangeSpec::AllFrom(2000),
+        ]));
+        assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
+
+        headers.clear();
+        headers.set(Range::Bytes(vec![]));
+
+        assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
+
+        headers.clear();
+        headers.set(Range::Unregistered("custom".to_owned(), "1-xxx".to_owned()));
+
+        assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
+    }
+
+    #[test]
+    fn test_byte_range_spec_to_satisfiable_range() {
+        assert_eq!(
+            Some((0, 0)),
+            ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3)
+        );
+        assert_eq!(
+            Some((1, 2)),
+            ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3)
+        );
+        assert_eq!(
+            Some((1, 2)),
+            ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3)
+        );
+        assert_eq!(None, ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3));
+        assert_eq!(None, ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3));
+        assert_eq!(None, ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0));
+
+        assert_eq!(
+            Some((0, 2)),
+            ByteRangeSpec::AllFrom(0).to_satisfiable_range(3)
+        );
+        assert_eq!(
+            Some((2, 2)),
+            ByteRangeSpec::AllFrom(2).to_satisfiable_range(3)
+        );
+        assert_eq!(None, ByteRangeSpec::AllFrom(3).to_satisfiable_range(3));
+        assert_eq!(None, ByteRangeSpec::AllFrom(5).to_satisfiable_range(3));
+        assert_eq!(None, ByteRangeSpec::AllFrom(0).to_satisfiable_range(0));
+
+        assert_eq!(Some((1, 2)), ByteRangeSpec::Last(2).to_satisfiable_range(3));
+        assert_eq!(Some((2, 2)), ByteRangeSpec::Last(1).to_satisfiable_range(3));
+        assert_eq!(Some((0, 2)), ByteRangeSpec::Last(5).to_satisfiable_range(3));
+        assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
+        assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
+    }
 }

actix-http/src/header/map.rs

@@ -7,7 +7,7 @@ use http::header::{HeaderName, HeaderValue};
 
 /// A set of HTTP headers
 ///
-/// `HeaderMap` is an multimap of [`HeaderName`] to values.
+/// `HeaderMap` is an multi-map of [`HeaderName`] to values.
 ///
 /// [`HeaderName`]: struct.HeaderName.html
 #[derive(Debug, Clone)]

actix-http/src/header/mod.rs

@@ -148,10 +148,7 @@ impl ContentEncoding {
     #[inline]
     /// Is the content compressed?
     pub fn is_compression(self) -> bool {
-        match self {
-            ContentEncoding::Identity | ContentEncoding::Auto => false,
-            _ => true,
-        }
+        matches!(self, ContentEncoding::Identity | ContentEncoding::Auto)
     }
 
     #[inline]